almost first rendering, fixing renderer issues

Makefile

@@ -6,7 +6,7 @@
 #    By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+         #
 #                                                 +#+#+#+#+#+   +#+            #
 #    Created: 2022/10/04 16:43:41 by maldavid          #+#    #+#              #
-#    Updated: 2022/12/18 01:57:53 by maldavid         ###   ########.fr        #
+#    Updated: 2022/12/19 00:06:48 by maldavid         ###   ########.fr        #
 #                                                                              #
 # **************************************************************************** #
 
@@ -14,6 +14,7 @@ NAME		= libmlx.so
 
 SRCS		=  $(wildcard $(addsuffix /*.cpp, ./src/core))
 SRCS		+= $(wildcard $(addsuffix /*.cpp, ./src/platform))
+SRCS		+= $(wildcard $(addsuffix /*.cpp, ./src/renderer))
 SRCS		+= $(wildcard $(addsuffix /*.cpp, ./src/renderer/**))
 
 OBJS		= $(SRCS:.cpp=.o)

src/core/application.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 22:10:52 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 02:49:45 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/19 00:40:17 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -19,8 +19,14 @@ namespace mlx::core
 		while(_in.is_running())
 		{
 			_in.update();
+			for(auto win : _wins)
+				win->beginFrame();
+
 			if(_loop_hook)
 				_loop_hook(_param);
+			
+			for(auto win : _wins)
+				win->endFrame();
 		}
 	}
 }

src/core/application.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 21:49:46 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 03:45:13 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 23:10:17 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -28,7 +28,7 @@ namespace mlx::core
 	class Application
 	{
 		public:
-			Application() : _in(_wins) {}
+			Application() : _in() {}
 
 			inline void* new_window(std::size_t w, std::size_t h, std::string title)
 			{

src/core/bridge.cpp

@@ -6,19 +6,20 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 17:35:20 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 03:42:18 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:24:25 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
-#include <iostream>
 #include <SDL2/SDL.h>
 #include "errors.h"
 #include "application.h"
+#include <renderer/core/render_core.h>
 
 extern "C"
 {
 	void* mlx_init()
 	{
+		mlx::Render_Core::get().init();
 		return new mlx::core::Application();
 	}
 
@@ -78,6 +79,7 @@ extern "C"
 	int mlx_destroy_display(void* mlx)
 	{
 		delete static_cast<mlx::core::Application*>(mlx);
+		mlx::Render_Core::get().destroy();
 		return 0;
 	}
 }

src/core/errors.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 17:48:06 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/17 23:28:22 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 17:47:51 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -21,21 +21,21 @@ namespace mlx::core::error
 {
 	void report(e_kind kind, std::string msg, ...)
 	{
-		char buffer[1024];
+		char buffer[4096];
 
 		va_list al;
 		va_start(al, msg);
-		std::vsprintf(buffer, std::move(msg).c_str(), al);
+		std::vsprintf(buffer, msg.c_str(), al);
 		va_end(al);
 
 		switch(kind)
 		{
-			case e_kind::message: std::cout << "[MicroLibX] Message : " << buffer << std::endl; break;
+			case e_kind::message: std::cout << "[MacroLibX] Message : " << buffer << std::endl; break;
-			case e_kind::warning: std::cout << "[MicroLibX] Warning : " << buffer << std::endl; break;
+			case e_kind::warning: std::cout << "[MacroLibX] Warning : " << buffer << std::endl; break;
-			case e_kind::error: std::cerr << "[MicroLibX] Error : " << buffer << std::endl; break;
+			case e_kind::error: std::cerr << "[MacroLibX] Error : " << buffer << std::endl; break;
 			case e_kind::fatal_error:
-				std::cerr << "[MicroLibX] Fatal Error : " << buffer << std::endl;
+				std::cerr << "[MacroLibX] Fatal Error : " << buffer << std::endl;
-				std::exit(EXIT_SUCCESS);
+				std::exit(EXIT_FAILURE);
 			break;
 		}
 	}

src/platform/inputs.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/05 16:30:19 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:13:32 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 23:09:55 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,7 +15,7 @@
 
 namespace mlx
 {
-	Input::Input(const std::vector<std::shared_ptr<MLX_Window>>& wins) : _wins(wins)
+	Input::Input()
 	{
 		std::memset(_keys.data(), 0, SDL_NUM_SCANCODES);
 		std::memset(_mouse.data(), 0, 8);

src/platform/inputs.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/05 16:27:35 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:13:19 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 23:09:41 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -25,7 +25,7 @@ namespace mlx
 	class Input
 	{
 		public:
-			Input(const std::vector<std::shared_ptr<MLX_Window>>& wins);
+			Input();
 
 			void update();
 
@@ -49,7 +49,6 @@ namespace mlx
 			SDL_Event _event;
 			std::array<uint8_t, SDL_NUM_SCANCODES> _keys;
 			std::array<uint8_t, 8> _mouse;
-			std::vector<std::shared_ptr<MLX_Window>> _wins;
 
 			int _x = 0;
 			int _y = 0;

src/platform/window.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 17:36:44 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:12:05 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/19 00:46:55 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,15 +15,44 @@
 
 namespace mlx
 {
-	MLX_Window::MLX_Window(std::size_t w, std::size_t h, std::string title, int id) : _id(id)
+	MLX_Window::MLX_Window(std::size_t w, std::size_t h, std::string title, int id) : _id(id), _renderer(new Renderer())
 	{
-		_win = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, /*SDL_WINDOW_VULKAN |*/ SDL_WINDOW_SHOWN);
+		_win = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, SDL_WINDOW_VULKAN | SDL_WINDOW_SHOWN);
 		if(!_win)
 			core::error::report(e_kind::fatal_error, std::string("Unable to open a new window, ") + SDL_GetError());
+		_renderer->setWindow(this);
+		_renderer->init();
+		_vbo.create(sizeof(Vertex));
+	}
+
+	bool MLX_Window::beginFrame()
+	{
+		return _renderer->beginFrame();
+	}
+
+	void MLX_Window::pixel_put(int x, int y, int color)
+	{
+		uint32_t ucolor = color;
+		Vertex vert;
+		vert.pos = glm::vec2(x, y);
+		vert.color.r = (ucolor >> 16) & 0xFF;
+		vert.color.g = (ucolor >> 8) & 0xFF;
+		vert.color.b = ucolor & 0xFF;
+		_vbo.setData(sizeof(Vertex), &vert);
+
+		_vbo.bind(*_renderer);
+		vkCmdDraw(_renderer->getActiveCmdBuffer().get(), 1, 1, 0, 0);
+	}
+
+	void MLX_Window::endFrame()
+	{
+		_renderer->endFrame();
 	}
 
 	MLX_Window::~MLX_Window()
 	{
+		_vbo.destroy();
+		_renderer->destroy();
 		if(_win)
 			SDL_DestroyWindow(_win);
 	}

src/platform/window.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 21:53:12 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 03:41:53 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/19 00:40:26 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,6 +15,9 @@
 
 #include <SDL2/SDL.h>
 #include <string>
+#include <memory>
+#include <renderer/renderer.h>
+#include <renderer/buffers/vk_vbo.h>
 
 namespace mlx
 {
@@ -26,11 +29,16 @@ namespace mlx
 			inline int& get_id() noexcept { return _id; }
 			inline SDL_Window* getNativeWindow() const noexcept { return _win; }
 
-			void pixel_put(int x, int y, int color) {}
+			bool beginFrame();
+			void endFrame();
+
+			void pixel_put(int x, int y, int color);
 			
 			~MLX_Window();
 
 		private:
+			std::unique_ptr<Renderer> _renderer;
+			VBO _vbo;
 			SDL_Window* _win = nullptr;
 			int _id;
 	};

src/renderer/buffers/vk_vbo.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:27:38 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 02:51:53 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 20:10:12 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,6 +14,7 @@
 #define __MLX_VK_VBO__
 
 #include "vk_buffer.h"
+#include <renderer/renderer.h>
 
 namespace mlx
 {
@@ -25,7 +26,7 @@ namespace mlx
 			void setData(uint32_t size, const void* data);
 			void setSubData(uint32_t offset, uint32_t size, const void* data);
 
-			inline void bind() noexcept { vkCmdBindVertexBuffers(Render_Core::get().getActiveCmdBuffer().get(), 0, 1, &_buffer, &_offset); }
+			inline void bind(Renderer& renderer) noexcept { vkCmdBindVertexBuffers(renderer.getActiveCmdBuffer().get(), 0, 1, &_buffer, &_offset); }
 
 		private:
 			uint32_t _used_size = 0;

src/renderer/command/vk_cmd_buffer.cpp

@@ -6,20 +6,23 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:26:06 by maldavid          #+#    #+#             */
-/*   Updated: 2022/10/06 18:27:27 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 20:33:04 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "vk_cmd_buffer.h"
 #include <renderer/core/render_core.h>
+#include <renderer/renderer.h>
 
 namespace mlx
 {
-	void CmdBuffer::init()
+	void CmdBuffer::init(Renderer* renderer)
 	{
+		_renderer = renderer;
+
 		VkCommandBufferAllocateInfo allocInfo{};
 		allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
-		allocInfo.commandPool = Render_Core::get().getCmdPool().get();
+		allocInfo.commandPool = renderer->getCmdPool().get();
 		allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
 		allocInfo.commandBufferCount = 1;
 
@@ -27,11 +30,6 @@ namespace mlx
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to allocate command buffer");
 	}
 
-	void CmdBuffer::destroy() noexcept
-	{
-		vkFreeCommandBuffers(Render_Core::get().getDevice().get(), Render_Core::get().getCmdPool().get(), 1, &_cmd_buffer);
-	}
-
 	void CmdBuffer::beginRecord(VkCommandBufferUsageFlags usage)
 	{
 		if(_is_recording)
@@ -55,4 +53,9 @@ namespace mlx
 
 		_is_recording = false;
 	}
+
+	void CmdBuffer::destroy() noexcept
+	{
+		vkFreeCommandBuffers(Render_Core::get().getDevice().get(), _renderer->getCmdPool().get(), 1, &_cmd_buffer);
+	}
 }

src/renderer/command/vk_cmd_buffer.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:25:42 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:08:34 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 20:32:45 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@ namespace mlx
 	class CmdBuffer
 	{
 		public:
-			void init();
+			void init(class Renderer* renderer);
 			void destroy() noexcept;
 
 			void beginRecord(VkCommandBufferUsageFlags usage = 0);
@@ -31,6 +31,7 @@ namespace mlx
 
 		private:
 			VkCommandBuffer _cmd_buffer = VK_NULL_HANDLE;
+			class Renderer* _renderer = nullptr;
 			bool _is_recording = false;
 	};
 }

src/renderer/command/vk_cmd_pool.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:24:33 by maldavid          #+#    #+#             */
-/*   Updated: 2022/10/06 18:25:10 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:56:26 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@ namespace mlx
 		VkCommandPoolCreateInfo poolInfo{};
 		poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
 		poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
-		poolInfo.queueFamilyIndex = Render_Core::get().getQueue().findQueueFamilies(Render_Core::get().getDevice().getPhysicalDevice()).graphicsFamily.value();
+		poolInfo.queueFamilyIndex = Render_Core::get().getQueue().getFamilies().graphicsFamily.value();
 
 		if(vkCreateCommandPool(Render_Core::get().getDevice().get(), &poolInfo, nullptr, &_cmd_pool) != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to create command pool");

src/renderer/core/render_core.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/17 23:33:34 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:25:02 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:40:58 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -66,122 +66,16 @@ namespace mlx
 		}
 	}
 
-	Render_Core::Render_Core() : _device(), _queues(), _surface(),
-								 _cmd_pool(), _swapchain(), _instance()
-	{}
-
 	void Render_Core::init()
 	{
+		volkInitialize();
+
 		_instance.init();
-		_surface.create();
 		_device.init();
 		_queues.init();
-		_swapchain.init();
-		_pass.init();
-		_swapchain.initFB();
-		_cmd_pool.init();
-		
-		for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
-			_cmd_buffers[i].init();
-
-		_semaphore.init();
-
-		_framebufferResized = false;
 		_is_init = true;
 	}
 
-	bool Render_Core::beginFrame()
-	{
-		if(!_is_init)
-			return false;
-
-		vkWaitForFences(_device(), 1, &_semaphore.getInFlightFence(_active_image_index), VK_TRUE, UINT64_MAX);
-
-		_image_index = 0;
-		VkResult result = vkAcquireNextImageKHR(_device(), _swapchain(), UINT64_MAX, _semaphore.getImageSemaphore(_active_image_index), VK_NULL_HANDLE, &_image_index);
-
-		if(result == VK_ERROR_OUT_OF_DATE_KHR)
-		{
-			_swapchain.recreate();
-			return false;
-		}
-		else if(result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
-			core::error::report(e_kind::fatal_error, "Vulkan error : failed to acquire swapchain image");
-
-		vkResetFences(_device(), 1, &_semaphore.getInFlightFence(_active_image_index));
-
-		vkResetCommandBuffer(_cmd_buffers[_active_image_index].get(), 0);
-
-		_cmd_buffers[_active_image_index].beginRecord();
-		_pass.begin();
-
-		return true;
-	}
-
-	void Render_Core::endFrame()
-	{
-		if(!_is_init)
-			return;
-		_pass.end();
-		_cmd_buffers[_active_image_index].endRecord();
-
-		VkSubmitInfo submitInfo{};
-		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
-
-		VkSemaphore waitSemaphores[] = { _semaphore.getImageSemaphore(_active_image_index) };
-		VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
-		submitInfo.waitSemaphoreCount = 1;
-		submitInfo.pWaitSemaphores = waitSemaphores;
-		submitInfo.pWaitDstStageMask = waitStages;
-
-		submitInfo.commandBufferCount = 1;
-		submitInfo.pCommandBuffers = &_cmd_buffers[_active_image_index].get();
-
-		VkSemaphore signalSemaphores[] = { _semaphore.getRenderImageSemaphore(_active_image_index) };
-		submitInfo.signalSemaphoreCount = 1;
-		submitInfo.pSignalSemaphores = signalSemaphores;
-
-		if(vkQueueSubmit(_queues.getGraphic(), 1, &submitInfo, _semaphore.getInFlightFence(_active_image_index)) != VK_SUCCESS)
-			core::error::report(e_kind::fatal_error, "Vulkan error : failed to submit draw command buffer");
-
-		VkPresentInfoKHR presentInfo{};
-		presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
-
-		presentInfo.waitSemaphoreCount = 1;
-		presentInfo.pWaitSemaphores = signalSemaphores;
-
-		presentInfo.swapchainCount = 1;
-		presentInfo.pSwapchains = &_swapchain();
-
-		presentInfo.pImageIndices = &_image_index;
-
-		VkResult result = vkQueuePresentKHR(_queues.getPresent(), &presentInfo);
-
-		if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || _framebufferResized)
-		{
-			_framebufferResized = false;
-			_swapchain.recreate();
-		}
-		else if(result != VK_SUCCESS)
-			core::error::report(e_kind::fatal_error, "Vulkan error : failed to present swap chain image");
-
-		_active_image_index = (_active_image_index + 1) % MAX_FRAMES_IN_FLIGHT;
-	}
-
-	void Render_Core::destroyCommandBuffers()
-	{
-		std::mutex mutex;
-        std::unique_lock<std::mutex> watchdog(mutex, std::try_to_lock);
-
-		if(!_is_init)
-			return;
-
-        vkDeviceWaitIdle(_device());
-
-		for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
-			_cmd_buffers[i].destroy();
-	}
-
 	void Render_Core::destroy()
 	{
 		std::mutex mutex;
@@ -192,13 +86,7 @@ namespace mlx
 
         vkDeviceWaitIdle(_device());
 
-		_swapchain.destroyFB();
-		_pass.destroy();
-		_swapchain.destroy();
-		_semaphore.destroy();
-		_cmd_pool.destroy();
 		_device.destroy();
-		_surface.destroy();
 		_instance.destroy();
 
 		_is_init = false;

src/renderer/core/render_core.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:16:32 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 03:42:51 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 17:51:47 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,19 +14,10 @@
 #define __MLX_RENDER_CORE__
 
 #include <volk.h>
-#include <array>
-#include <memory>
 
 #include "vk_queues.h"
 #include "vk_device.h"
-#include "vk_surface.h"
 #include "vk_instance.h"
-#include "vk_semaphore.h"
-
-#include <renderer/command/vk_cmd_pool.h>
-#include <renderer/command/vk_cmd_buffer.h>
-#include <renderer/swapchain/vk_swapchain.h>
-#include <renderer/swapchain/vk_render_pass.h>
 
 #include <utils/singleton.h>
 #include <core/errors.h>
@@ -43,51 +34,21 @@ namespace mlx
     class Render_Core : public Singleton<Render_Core>
     {
         public:
-            Render_Core();
+            Render_Core() = default;
 
             void init();
-
-			void destroyCommandBuffers();
             void destroy();
 
-            bool beginFrame();
+            inline Instance& getInstance() noexcept { return _instance; }
-            void endFrame();
+            inline Device& getDevice() noexcept { return _device; }
+            inline Queues& getQueue() noexcept { return _queues; }
 
-            inline std::shared_ptr<class MLX_Window> getWindow() { return _window; }
+			~Render_Core() = default;
-            inline void setWindow(std::shared_ptr<class MLX_Window> window) { _window = window; }
-
-            inline Instance&  getInstance()		   { return _instance; }
-            inline Device&    getDevice()		   { return _device; }
-            inline Surface&   getSurface()		   { return _surface; }
-            inline Queues&    getQueue()		   { return _queues; }
-            inline CmdPool&   getCmdPool()		   { return _cmd_pool; }
-            inline SwapChain& getSwapChain()	   { return _swapchain; }
-            inline Semaphore& getSemaphore()	   { return _semaphore; }
-            inline RenderPass& getRenderPass()	   { return _pass; }
-            inline CmdBuffer& getCmdBuffer(int i)  { return _cmd_buffers[i]; }
-            inline CmdBuffer& getActiveCmdBuffer() { return _cmd_buffers[_active_image_index]; }
-            inline uint32_t getActiveImageIndex()  { return _active_image_index; }
-            inline uint32_t getImageIndex()        { return _image_index; }
-
-            constexpr inline void requireFrameBufferResize(int index) noexcept { _framebufferResized = true; }
 
         private:
-            Device _device;
             Queues _queues;
-            Surface _surface;
+            Device _device;
-            RenderPass _pass;
-            CmdPool _cmd_pool;
             Instance _instance;
-            SwapChain _swapchain;
-            Semaphore _semaphore;
-            std::array<CmdBuffer, MAX_FRAMES_IN_FLIGHT> _cmd_buffers;
-
-			std::shared_ptr<class MLX_Window> _window;
-
-            bool _framebufferResized = false;
-
-            uint32_t _active_image_index = 0;
-            uint32_t _image_index = 0;
             bool _is_init = false;
     };
 }

src/renderer/core/vk_device.cpp

@@ -6,13 +6,16 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:14:29 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:10:42 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:56:47 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "render_core.h"
 #include <vector>
 #include <set>
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_vulkan.h>
+#include <iostream>
 
 namespace mlx
 {
@@ -22,7 +25,7 @@ namespace mlx
 	{
 		pickPhysicalDevice();
 
-		Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().findQueueFamilies(_physicalDevice);
+		Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().getFamilies();
 
 		std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
 		std::set<uint32_t> uniqueQueueFamilies = { indices.graphicsFamily.value(), indices.presentFamily.value() };
@@ -67,33 +70,42 @@ namespace mlx
 		std::vector<VkPhysicalDevice> devices(deviceCount);
 		vkEnumeratePhysicalDevices(Render_Core::get().getInstance().get(), &deviceCount, devices.data());
 
+		SDL_Window* window = SDL_CreateWindow("", 0, 0, 1, 1, SDL_WINDOW_VULKAN | SDL_WINDOW_HIDDEN);
+		if(!window)
+			core::error::report(e_kind::fatal_error, "Vulkan : failed to create a window to pick physical device");
+
+		VkSurfaceKHR surface = VK_NULL_HANDLE;
+		if(SDL_Vulkan_CreateSurface(window, Render_Core::get().getInstance().get(), &surface) != SDL_TRUE)
+			core::error::report(e_kind::fatal_error, "Vulkan : failed to create a surface to pick physical device");
+
 		for(const auto& device : devices)
 		{
-			if(isDeviceSuitable(device))
+			if(isDeviceSuitable(device, surface))
 			{
 				_physicalDevice = device;
 				break;
 			}
 		}
 
+		vkDestroySurfaceKHR(Render_Core::get().getInstance().get(), surface, nullptr);
+		SDL_DestroyWindow(window);
+
 		if(_physicalDevice == VK_NULL_HANDLE)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to find a suitable GPU");
 	}
-	bool Device::isDeviceSuitable(VkPhysicalDevice device)
+	
+	bool Device::isDeviceSuitable(VkPhysicalDevice device, VkSurfaceKHR surface)
 	{
-		Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().findQueueFamilies(device);
+		Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().findQueueFamilies(device, surface);
 
 		bool extensionsSupported = checkDeviceExtensionSupport(device);
 
-		bool swapChainAdequate = false;
+		uint32_t formatCount = 0;
 		if(extensionsSupported)
-		{
+			vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
-			SwapChain::SwapChainSupportDetails swapChainSupport = Render_Core::get().getSwapChain().querySwapChainSupport(device);
+		return indices.isComplete() && extensionsSupported && formatCount != 0;
-			swapChainAdequate = !swapChainSupport.formats.empty();
-		}
-
-		return indices.isComplete() && extensionsSupported && swapChainAdequate;
 	}
+
 	bool Device::checkDeviceExtensionSupport(VkPhysicalDevice device)
 	{
 		uint32_t extensionCount;

src/renderer/core/vk_device.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:13:42 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:08:11 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:55:30 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,6 +14,7 @@
 #define __MLX_VK_DEVICE__
 
 #include <volk.h>
+#include "vk_queues.h"
 
 namespace mlx
 {
@@ -30,7 +31,7 @@ namespace mlx
 			
 		private:
 			void pickPhysicalDevice();
-			bool isDeviceSuitable(VkPhysicalDevice device);
+			bool isDeviceSuitable(VkPhysicalDevice device, VkSurfaceKHR surface);
 			bool checkDeviceExtensionSupport(VkPhysicalDevice device);
 
 			VkPhysicalDevice _physicalDevice = VK_NULL_HANDLE;

src/renderer/core/vk_instance.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:04:21 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 00:34:58 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:37:00 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -23,9 +23,9 @@ namespace mlx
 	{
         VkApplicationInfo appInfo{};
         appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
-        appInfo.pApplicationName = "MicroLibX";
+        appInfo.pApplicationName = "MacroLibX";
         appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
-        appInfo.pEngineName = "MicroLibX";
+        appInfo.pEngineName = "MacroLibX";
         appInfo.engineVersion = VK_MAKE_VERSION(0, 0, 1);
         appInfo.apiVersion = VK_API_VERSION_1_2;
 
@@ -44,20 +44,27 @@ namespace mlx
 		VkResult res;
         if((res = vkCreateInstance(&createInfo, nullptr, &_instance)) != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to create Vulkan instance : %s", RCore::verbaliseResultVk(res));
+		volkLoadInstance(_instance);
 	}
 
 	std::vector<const char*> Instance::getRequiredExtensions()
     {
         unsigned int count = 0;
-        if(!SDL_Vulkan_GetInstanceExtensions(Render_Core::get().getWindow()->getNativeWindow(), &count, nullptr))
+		SDL_Window* window = SDL_CreateWindow("", 0, 0, 1, 1, SDL_WINDOW_VULKAN | SDL_WINDOW_HIDDEN);
+		if(!window)
+			core::error::report(e_kind::fatal_error, "Vulkan : cannot get instance extentions from window : %s",  SDL_GetError());
+
+        if(!SDL_Vulkan_GetInstanceExtensions(window, &count, nullptr))
 			core::error::report(e_kind::fatal_error, "Vulkan : cannot get instance extentions from window : %s",  SDL_GetError());
 
         std::vector<const char*> extensions = { VK_EXT_DEBUG_REPORT_EXTENSION_NAME };
         size_t additional_extension_count = extensions.size();
         extensions.resize(additional_extension_count + count);
 
-        if(!SDL_Vulkan_GetInstanceExtensions(Render_Core::get().getWindow()->getNativeWindow(), &count, extensions.data() + additional_extension_count))
+        if(!SDL_Vulkan_GetInstanceExtensions(window, &count, extensions.data() + additional_extension_count))
 			core::error::report(e_kind::error, "Vulkan : cannot get instance extentions from window : %s", SDL_GetError());
+
+		SDL_DestroyWindow(window);
         return extensions;
     }
 

src/renderer/core/vk_instance.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:03:04 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:08:07 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 17:42:08 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -21,7 +21,6 @@ namespace mlx
 	class Instance
 	{
 		public:
-
 			void init();
 			void destroy() noexcept;
 

src/renderer/core/vk_queues.cpp

@@ -6,15 +6,17 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:02:42 by maldavid          #+#    #+#             */
-/*   Updated: 2022/10/08 19:02:52 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:52:04 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "render_core.h"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_vulkan.h>
 
 namespace mlx
 {
-	Queues::QueueFamilyIndices Queues::findQueueFamilies(VkPhysicalDevice device)
+	Queues::QueueFamilyIndices Queues::findQueueFamilies(VkPhysicalDevice device, VkSurfaceKHR surface)
     {
 		uint32_t queueFamilyCount = 0;
 		vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
@@ -23,7 +25,6 @@ namespace mlx
 		vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
 
 		_families = Queues::QueueFamilyIndices{};
-
 		int i = 0;
 		for(const auto& queueFamily : queueFamilies)
 		{
@@ -31,7 +32,7 @@ namespace mlx
 				_families->graphicsFamily = i;
 
 			VkBool32 presentSupport = false;
-			vkGetPhysicalDeviceSurfaceSupportKHR(device, i, Render_Core::get().getSurface().get(), &presentSupport);
+			vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
 
 			if(presentSupport)
 				_families->presentFamily = i;
@@ -40,13 +41,27 @@ namespace mlx
 				break;
 			i++;
 		}
+
 		return *_families;
 	}
 
 	void Queues::init()
 	{
 		if(!_families.has_value())
-			findQueueFamilies(Render_Core::get().getDevice().getPhysicalDevice());
+		{
+			SDL_Window* window = SDL_CreateWindow("", 0, 0, 1, 1, SDL_WINDOW_VULKAN | SDL_WINDOW_HIDDEN);
+			if(!window)
+				core::error::report(e_kind::fatal_error, "Vulkan : failed to create a window to init queues");
+
+			VkSurfaceKHR surface = VK_NULL_HANDLE;
+			if(SDL_Vulkan_CreateSurface(window, Render_Core::get().getInstance().get(), &surface) != SDL_TRUE)
+				core::error::report(e_kind::fatal_error, "Vulkan : failed to create a surface to init queues");
+
+			findQueueFamilies(Render_Core::get().getDevice().getPhysicalDevice(), surface);
+
+			vkDestroySurfaceKHR(Render_Core::get().getInstance().get(), surface, nullptr);
+			SDL_DestroyWindow(window);
+		}
 		vkGetDeviceQueue(Render_Core::get().getDevice().get(), _families->graphicsFamily.value(), 0, &_graphicsQueue);
 		vkGetDeviceQueue(Render_Core::get().getDevice().get(), _families->presentFamily.value(), 0, &_presentQueue);
 	}

src/renderer/core/vk_queues.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:01:49 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:08:04 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:44:37 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -30,7 +30,7 @@ namespace mlx
 				inline bool isComplete() { return graphicsFamily.has_value() && presentFamily.has_value(); }
 			};
 
-			QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device);
+			QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device, VkSurfaceKHR surface);
 
 			void init();
 

src/renderer/core/vk_semaphore.cpp

@@ -6,21 +6,22 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:01:08 by maldavid          #+#    #+#             */
-/*   Updated: 2022/10/08 19:01:44 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 20:12:40 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "vk_semaphore.h"
 #include "render_core.h"
+#include <renderer/renderer.h>
 
 namespace mlx
 {
-	void Semaphore::init()
+	void Semaphore::init(Renderer& renderer)
 	{
 		_imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
 		_renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
 		_inFlightFences.resize(MAX_FRAMES_IN_FLIGHT);
-		_imagesInFlight.resize(Render_Core::get().getSwapChain().getImagesNumber(), VK_NULL_HANDLE);
+		_imagesInFlight.resize(renderer.getSwapChain().getImagesNumber(), VK_NULL_HANDLE);
 
 		VkSemaphoreCreateInfo semaphoreInfo{};
 		semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;

src/renderer/core/vk_semaphore.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 18:59:38 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:08:00 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 19:50:10 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -21,7 +21,7 @@ namespace mlx
 	class Semaphore
 	{
 		public:
-			void init();
+			void init(class Renderer& renderer);
 			void destroy() noexcept;
 
 			inline VkSemaphore& getImageSemaphore(int i) noexcept { return _imageAvailableSemaphores[i]; }

src/renderer/core/vk_surface.cpp

@@ -6,20 +6,22 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 18:58:49 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 00:35:03 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:20:57 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "render_core.h"
 #include <platform/window.h>
+#include <renderer/renderer.h>
 #include <SDL2/SDL_vulkan.h>
+#include <SDL2/SDL.h>
 
 namespace mlx
 {
-	void Surface::create()
+	void Surface::create(Renderer& renderer)
 	{
-		if(SDL_Vulkan_CreateSurface(Render_Core::get().getWindow()->getNativeWindow(), Render_Core::get().getInstance().get(), &_surface) != SDL_TRUE)
+		if(SDL_Vulkan_CreateSurface(renderer.getWindow()->getNativeWindow(), Render_Core::get().getInstance().get(), &_surface) != SDL_TRUE)
-			core::error::report(e_kind::fatal_error, "Vulkan : failed to create a surface");
+			core::error::report(e_kind::fatal_error, "Vulkan : failed to create a surface : %s", SDL_GetError());
 	}
 
 	VkSurfaceFormatKHR Surface::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)

src/renderer/core/vk_surface.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 18:57:55 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:07:57 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 19:34:04 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -21,7 +21,7 @@ namespace mlx
 	class Surface
 	{
 		public:
-			void create();
+			void create(class Renderer& renderer);
 			void destroy() noexcept;
 			
 			VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);

src/renderer/pipeline/pipeline.cpp

@@ -0,0 +1,215 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   pipeline.cpp                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2022/12/18 21:27:38 by maldavid          #+#    #+#             */
+/*   Updated: 2022/12/19 00:26:39 by maldavid         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "pipeline.h"
+#include <renderer/renderer.h>
+#include <renderer/core/render_core.h>
+
+namespace mlx
+{
+	const std::vector<uint32_t> vertex_shader = {
+		0x07230203,0x00010000,0x0008000a,0x00000021,0x00000000,0x00020011,0x00000001,0x0006000b,
+		0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
+		0x0009000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x0000000d,0x00000012,0x0000001d,
+		0x0000001f,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,0x00000000,
+		0x00060005,0x0000000b,0x505f6c67,0x65567265,0x78657472,0x00000000,0x00060006,0x0000000b,
+		0x00000000,0x505f6c67,0x7469736f,0x006e6f69,0x00070006,0x0000000b,0x00000001,0x505f6c67,
+		0x746e696f,0x657a6953,0x00000000,0x00070006,0x0000000b,0x00000002,0x435f6c67,0x4470696c,
+		0x61747369,0x0065636e,0x00070006,0x0000000b,0x00000003,0x435f6c67,0x446c6c75,0x61747369,
+		0x0065636e,0x00030005,0x0000000d,0x00000000,0x00050005,0x00000012,0x6f506e69,0x69746973,
+		0x00006e6f,0x00050005,0x0000001d,0x67617266,0x6f6c6f43,0x00000072,0x00040005,0x0000001f,
+		0x6f436e69,0x00726f6c,0x00050048,0x0000000b,0x00000000,0x0000000b,0x00000000,0x00050048,
+		0x0000000b,0x00000001,0x0000000b,0x00000001,0x00050048,0x0000000b,0x00000002,0x0000000b,
+		0x00000003,0x00050048,0x0000000b,0x00000003,0x0000000b,0x00000004,0x00030047,0x0000000b,
+		0x00000002,0x00040047,0x00000012,0x0000001e,0x00000000,0x00040047,0x0000001d,0x0000001e,
+		0x00000000,0x00040047,0x0000001f,0x0000001e,0x00000001,0x00020013,0x00000002,0x00030021,
+		0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,
+		0x00000004,0x00040015,0x00000008,0x00000020,0x00000000,0x0004002b,0x00000008,0x00000009,
+		0x00000001,0x0004001c,0x0000000a,0x00000006,0x00000009,0x0006001e,0x0000000b,0x00000007,
+		0x00000006,0x0000000a,0x0000000a,0x00040020,0x0000000c,0x00000003,0x0000000b,0x0004003b,
+		0x0000000c,0x0000000d,0x00000003,0x00040015,0x0000000e,0x00000020,0x00000001,0x0004002b,
+		0x0000000e,0x0000000f,0x00000000,0x00040017,0x00000010,0x00000006,0x00000002,0x00040020,
+		0x00000011,0x00000001,0x00000010,0x0004003b,0x00000011,0x00000012,0x00000001,0x0004002b,
+		0x00000006,0x00000014,0x00000000,0x0004002b,0x00000006,0x00000015,0x3f800000,0x00040020,
+		0x00000019,0x00000003,0x00000007,0x00040017,0x0000001b,0x00000006,0x00000003,0x00040020,
+		0x0000001c,0x00000003,0x0000001b,0x0004003b,0x0000001c,0x0000001d,0x00000003,0x00040020,
+		0x0000001e,0x00000001,0x0000001b,0x0004003b,0x0000001e,0x0000001f,0x00000001,0x00050036,
+		0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003d,0x00000010,
+		0x00000013,0x00000012,0x00050051,0x00000006,0x00000016,0x00000013,0x00000000,0x00050051,
+		0x00000006,0x00000017,0x00000013,0x00000001,0x00070050,0x00000007,0x00000018,0x00000016,
+		0x00000017,0x00000014,0x00000015,0x00050041,0x00000019,0x0000001a,0x0000000d,0x0000000f,
+		0x0003003e,0x0000001a,0x00000018,0x0004003d,0x0000001b,0x00000020,0x0000001f,0x0003003e,
+		0x0000001d,0x00000020,0x000100fd,0x00010038
+	};
+
+	const std::vector<uint32_t> fragment_shader = {
+		0x07230203,0x00010000,0x0008000a,0x00000013,0x00000000,0x00020011,0x00000001,0x0006000b,
+		0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
+		0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x00000009,0x0000000c,0x00030010,
+		0x00000004,0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,
+		0x00000000,0x00050005,0x00000009,0x4374756f,0x726f6c6f,0x00000000,0x00050005,0x0000000c,
+		0x67617266,0x6f6c6f43,0x00000072,0x00040047,0x00000009,0x0000001e,0x00000000,0x00040047,
+		0x0000000c,0x0000001e,0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,
+		0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x00040020,
+		0x00000008,0x00000003,0x00000007,0x0004003b,0x00000008,0x00000009,0x00000003,0x00040017,
+		0x0000000a,0x00000006,0x00000003,0x00040020,0x0000000b,0x00000001,0x0000000a,0x0004003b,
+		0x0000000b,0x0000000c,0x00000001,0x0004002b,0x00000006,0x0000000e,0x3f800000,0x00050036,
+		0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003d,0x0000000a,
+		0x0000000d,0x0000000c,0x00050051,0x00000006,0x0000000f,0x0000000d,0x00000000,0x00050051,
+		0x00000006,0x00000010,0x0000000d,0x00000001,0x00050051,0x00000006,0x00000011,0x0000000d,
+		0x00000002,0x00070050,0x00000007,0x00000012,0x0000000f,0x00000010,0x00000011,0x0000000e,
+		0x0003003e,0x00000009,0x00000012,0x000100fd,0x00010038
+	};
+
+	void GraphicPipeline::init(Renderer& renderer)
+    {
+		std::vector<VkPipelineShaderStageCreateInfo> stages;
+
+		VkShaderModuleCreateInfo createInfo{};
+		createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+		createInfo.codeSize = vertex_shader.size();
+		createInfo.pCode = vertex_shader.data();
+		VkShaderModule vshader;
+		if(vkCreateShaderModule(Render_Core::get().getDevice().get(), &createInfo, nullptr, &vshader) != VK_SUCCESS)
+			core::error::report(e_kind::fatal_error, "Vulkan : failed to create a vertex shader module");
+
+		createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+		createInfo.codeSize = fragment_shader.size();
+		createInfo.pCode = fragment_shader.data();
+		VkShaderModule fshader;
+		if(vkCreateShaderModule(Render_Core::get().getDevice().get(), &createInfo, nullptr, &fshader) != VK_SUCCESS)
+			core::error::report(e_kind::fatal_error, "Vulkan : failed to create a fragment shader module");
+
+		VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
+        vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+        vertShaderStageInfo.module = vshader;
+        vertShaderStageInfo.pName = "main";
+
+        VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
+        fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+        fragShaderStageInfo.module = fshader;
+        fragShaderStageInfo.pName = "main";
+
+		VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};
+
+		auto bindingDescription = Vertex::getBindingDescription();
+        auto attributeDescriptions = Vertex::getAttributeDescriptions();
+
+		VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo{};
+		vertexInputStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+		vertexInputStateCreateInfo.vertexBindingDescriptionCount = 1;
+		vertexInputStateCreateInfo.pVertexBindingDescriptions = &bindingDescription;
+		vertexInputStateCreateInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size());
+		vertexInputStateCreateInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
+
+        VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
+        inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+        inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+        inputAssembly.primitiveRestartEnable = VK_FALSE;
+
+		VkDynamicState states[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
+
+		constexpr size_t statesCount = sizeof(states) / sizeof(VkDynamicState);
+		VkPipelineDynamicStateCreateInfo dynamicStates{};
+		dynamicStates.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+		dynamicStates.dynamicStateCount = statesCount;
+		dynamicStates.pDynamicStates = states;
+
+        VkViewport viewport{};
+        viewport.x = 0.0f;
+        viewport.y = 0.0f;
+        viewport.width = (float)renderer.getSwapChain()._swapChainExtent.width;
+        viewport.height = (float)renderer.getSwapChain()._swapChainExtent.height;
+        viewport.minDepth = 0.0f;
+        viewport.maxDepth = 1.0f;
+
+        VkRect2D scissor{};
+        scissor.offset = { 0, 0 };
+        scissor.extent = renderer.getSwapChain()._swapChainExtent;
+
+        VkPipelineViewportStateCreateInfo viewportState{};
+        viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+        viewportState.viewportCount = 1;
+        viewportState.pViewports = &viewport;
+        viewportState.scissorCount = 1;
+        viewportState.pScissors = &scissor;
+
+        VkPipelineRasterizationStateCreateInfo rasterizer{};
+        rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+        rasterizer.depthClampEnable = VK_FALSE;
+        rasterizer.rasterizerDiscardEnable = VK_FALSE;
+        rasterizer.polygonMode = VK_POLYGON_MODE_POINT;
+        rasterizer.lineWidth = 1.0f;
+        rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
+        rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
+        rasterizer.depthBiasEnable = VK_FALSE;
+
+        VkPipelineMultisampleStateCreateInfo multisampling{};
+        multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+        multisampling.sampleShadingEnable = VK_FALSE;
+        multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+
+        VkPipelineColorBlendAttachmentState colorBlendAttachment{};
+        colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+        colorBlendAttachment.blendEnable = VK_FALSE;
+
+        VkPipelineColorBlendStateCreateInfo colorBlending{};
+        colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+        colorBlending.logicOpEnable = VK_FALSE;
+        colorBlending.logicOp = VK_LOGIC_OP_COPY;
+        colorBlending.attachmentCount = 1;
+        colorBlending.pAttachments = &colorBlendAttachment;
+        colorBlending.blendConstants[0] = 0.0f;
+        colorBlending.blendConstants[1] = 0.0f;
+        colorBlending.blendConstants[2] = 0.0f;
+        colorBlending.blendConstants[3] = 0.0f;
+
+		VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
+        pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+        pipelineLayoutInfo.setLayoutCount = 0;
+        pipelineLayoutInfo.pSetLayouts = 0;
+
+        if(vkCreatePipelineLayout(Render_Core::get().getDevice().get(), &pipelineLayoutInfo, nullptr, &_pipelineLayout) != VK_SUCCESS)
+            core::error::report(e_kind::fatal_error, "Vulkan : failed to create a graphics pipeline layout");
+
+        VkGraphicsPipelineCreateInfo pipelineInfo{};
+        pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+        pipelineInfo.stageCount = stages.size();
+        pipelineInfo.pStages = stages.data();
+        pipelineInfo.pVertexInputState = &vertexInputStateCreateInfo;
+        pipelineInfo.pInputAssemblyState = &inputAssembly;
+        pipelineInfo.pViewportState = &viewportState;
+        pipelineInfo.pRasterizationState = &rasterizer;
+        pipelineInfo.pMultisampleState = &multisampling;
+        pipelineInfo.pColorBlendState = &colorBlending;
+		pipelineInfo.pDynamicState = &dynamicStates;
+        pipelineInfo.layout = _pipelineLayout;
+        pipelineInfo.renderPass = renderer.getRenderPass().get();
+        pipelineInfo.subpass = 0;
+        pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
+
+        if(vkCreateGraphicsPipelines(Render_Core::get().getDevice().get(), VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &_graphicsPipeline) != VK_SUCCESS)
+            core::error::report(e_kind::fatal_error, "Vulkan : failed to create a graphics pipeline");
+
+		vkDestroyShaderModule(Render_Core::get().getDevice().get(), fshader, nullptr);
+        vkDestroyShaderModule(Render_Core::get().getDevice().get(), vshader, nullptr);
+    }
+
+    void GraphicPipeline::destroy() noexcept
+    {
+        vkDestroyPipeline(Render_Core::get().getDevice().get(), _graphicsPipeline, nullptr);
+		vkDestroyPipelineLayout(Render_Core::get().getDevice().get(), _pipelineLayout, nullptr);
+    }
+
+}

src/renderer/pipeline/pipeline.h

@@ -0,0 +1,39 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   pipeline.h                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2022/12/18 21:23:52 by maldavid          #+#    #+#             */
+/*   Updated: 2022/12/19 00:27:29 by maldavid         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef __PIPELINE__
+#define __PIPELINE__
+
+#include <volk.h>
+#include <renderer/command/vk_cmd_buffer.h>
+
+namespace mlx
+{
+	class GraphicPipeline
+	{
+		public:
+			void init(class Renderer& renderer);
+			void destroy() noexcept;
+
+			inline void bindPipeline(CmdBuffer& commandBuffer) noexcept { vkCmdBindPipeline(commandBuffer.get(), VK_PIPELINE_BIND_POINT_GRAPHICS, _graphicsPipeline); }
+
+			inline const VkPipeline& getPipeline() const noexcept { return _graphicsPipeline; }
+			inline const VkPipelineLayout& getPipelineLayout() const noexcept { return _pipelineLayout; }
+
+		private:
+			VkPipeline _graphicsPipeline = VK_NULL_HANDLE;
+			VkPipelineCache _cache = VK_NULL_HANDLE;
+			VkPipelineLayout _pipelineLayout = VK_NULL_HANDLE;
+	};
+}
+
+#endif

src/renderer/renderer.cpp

@@ -0,0 +1,144 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   renderer.cpp                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2022/12/18 17:25:16 by maldavid          #+#    #+#             */
+/*   Updated: 2022/12/19 00:00:46 by maldavid         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include <mutex>
+#include <renderer/renderer.h>
+#include <renderer/core/render_core.h>
+
+namespace mlx
+{
+	void Renderer::init()
+	{
+		_surface.create(*this);
+		_swapchain.init(this);
+		_pass.init(this);
+		_swapchain.initFB();
+		_cmd_pool.init();
+		
+		for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
+			_cmd_buffers[i].init(this);
+
+		_semaphore.init(*this);
+		_pipeline.init(*this);
+
+		_framebufferResized = false;
+	}
+	
+	bool Renderer::beginFrame()
+	{
+		auto device = Render_Core::get().getDevice().get();
+
+		vkWaitForFences(device, 1, &_semaphore.getInFlightFence(_active_image_index), VK_TRUE, UINT64_MAX);
+
+		_image_index = 0;
+		VkResult result = vkAcquireNextImageKHR(device, _swapchain(), UINT64_MAX, _semaphore.getImageSemaphore(_active_image_index), VK_NULL_HANDLE, &_image_index);
+
+		if(result == VK_ERROR_OUT_OF_DATE_KHR)
+		{
+			_swapchain.recreate();
+			return false;
+		}
+		else if(result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
+			core::error::report(e_kind::fatal_error, "Vulkan error : failed to acquire swapchain image");
+
+		vkResetFences(device, 1, &_semaphore.getInFlightFence(_active_image_index));
+
+		vkResetCommandBuffer(_cmd_buffers[_active_image_index].get(), 0);
+
+		_cmd_buffers[_active_image_index].beginRecord();
+		_pass.begin();
+
+		_pipeline.bindPipeline(_cmd_buffers[_active_image_index]);
+
+		VkViewport viewport{};
+		viewport.x = 0.0f;
+		viewport.y = 0.0f;
+		viewport.width = (float)_swapchain._swapChainExtent.width;
+		viewport.height = (float)_swapchain._swapChainExtent.height;
+		viewport.minDepth = 0.0f;
+		viewport.maxDepth = 1.0f;
+		vkCmdSetViewport(_cmd_buffers[_active_image_index].get(), 0, 1, &viewport);
+
+		VkRect2D scissor{};
+		scissor.offset = { 0, 0 };
+		scissor.extent = _swapchain._swapChainExtent;
+		vkCmdSetScissor(_cmd_buffers[_active_image_index].get(), 0, 1, &scissor);
+
+		return true;
+	}
+
+	void Renderer::endFrame()
+	{
+		_pass.end();
+		_cmd_buffers[_active_image_index].endRecord();
+
+		VkSubmitInfo submitInfo{};
+		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+
+		VkSemaphore waitSemaphores[] = { _semaphore.getImageSemaphore(_active_image_index) };
+		VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
+		submitInfo.waitSemaphoreCount = 1;
+		submitInfo.pWaitSemaphores = waitSemaphores;
+		submitInfo.pWaitDstStageMask = waitStages;
+
+		submitInfo.commandBufferCount = 1;
+		submitInfo.pCommandBuffers = &_cmd_buffers[_active_image_index].get();
+
+		VkSemaphore signalSemaphores[] = { _semaphore.getRenderImageSemaphore(_active_image_index) };
+		submitInfo.signalSemaphoreCount = 1;
+		submitInfo.pSignalSemaphores = signalSemaphores;
+
+		if(vkQueueSubmit(Render_Core::get().getQueue().getGraphic(), 1, &submitInfo, _semaphore.getInFlightFence(_active_image_index)) != VK_SUCCESS)
+			core::error::report(e_kind::fatal_error, "Vulkan error : failed to submit draw command buffer");
+
+		VkPresentInfoKHR presentInfo{};
+		presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+
+		presentInfo.waitSemaphoreCount = 1;
+		presentInfo.pWaitSemaphores = signalSemaphores;
+
+		presentInfo.swapchainCount = 1;
+		presentInfo.pSwapchains = &_swapchain();
+
+		presentInfo.pImageIndices = &_image_index;
+
+		VkResult result = vkQueuePresentKHR(Render_Core::get().getQueue().getPresent(), &presentInfo);
+
+		if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || _framebufferResized)
+		{
+			_framebufferResized = false;
+			_swapchain.recreate();
+		}
+		else if(result != VK_SUCCESS)
+			core::error::report(e_kind::fatal_error, "Vulkan error : failed to present swap chain image");
+
+		_active_image_index = (_active_image_index + 1) % MAX_FRAMES_IN_FLIGHT;
+	}
+
+	void Renderer::destroy()
+	{
+		std::mutex mutex;
+        std::unique_lock<std::mutex> watchdog(mutex, std::try_to_lock);
+
+        vkDeviceWaitIdle(Render_Core::get().getDevice().get());
+
+		for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
+			_cmd_buffers[i].destroy();
+
+		_swapchain.destroyFB();
+		_pass.destroy();
+		_swapchain.destroy();
+		_semaphore.destroy();
+		_cmd_pool.destroy();
+		_surface.destroy();
+	}
+}

src/renderer/renderer.h

@@ -0,0 +1,114 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   renderer.h                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2022/12/18 17:14:45 by maldavid          #+#    #+#             */
+/*   Updated: 2022/12/18 22:15:50 by maldavid         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef __RENDERER__
+#define __RENDERER__
+
+#include <array>
+#include <vector>
+#include <memory>
+
+#include <renderer/core/vk_surface.h>
+#include <renderer/core/render_core.h>
+#include <renderer/core/vk_semaphore.h>
+#include <renderer/pipeline/pipeline.h>
+#include <renderer/command/vk_cmd_pool.h>
+#include <renderer/command/vk_cmd_buffer.h>
+#include <renderer/swapchain/vk_swapchain.h>
+#include <renderer/swapchain/vk_render_pass.h>
+
+#include <core/errors.h>
+
+#include <glm/glm.hpp>
+
+namespace mlx
+{
+	struct Vertex
+	{
+		glm::vec2 pos;
+		glm::vec3 color;
+
+		static VkVertexInputBindingDescription getBindingDescription()
+		{
+			VkVertexInputBindingDescription bindingDescription{};
+			bindingDescription.binding = 0;
+			bindingDescription.stride = sizeof(Vertex);
+			bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+
+			return bindingDescription;
+		}
+
+		static std::array<VkVertexInputAttributeDescription, 2> getAttributeDescriptions()
+		{
+			std::array<VkVertexInputAttributeDescription, 2> attributeDescriptions;
+
+			attributeDescriptions[0].binding = 0;
+			attributeDescriptions[0].location = 0;
+			attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
+			attributeDescriptions[0].offset = offsetof(Vertex, pos);
+
+			attributeDescriptions[1].binding = 0;
+			attributeDescriptions[1].location = 1;
+			attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
+			attributeDescriptions[1].offset = offsetof(Vertex, color);
+
+			return attributeDescriptions;
+		}
+	};
+
+	class Renderer
+	{
+		public:
+			Renderer() = default;
+
+            void init();
+
+            bool beginFrame();
+            void endFrame();
+
+			void destroy();
+            
+			inline class MLX_Window* getWindow() { return _window; }
+            inline void setWindow(class MLX_Window* window) { _window = window; }
+
+            inline Surface& getSurface() noexcept { return _surface; }
+            inline CmdPool& getCmdPool() noexcept { return _cmd_pool; }
+            inline SwapChain& getSwapChain() noexcept { return _swapchain; }
+            inline Semaphore& getSemaphore() noexcept { return _semaphore; }
+            inline RenderPass& getRenderPass() noexcept { return _pass; }
+            inline CmdBuffer& getCmdBuffer(int i) noexcept { return _cmd_buffers[i]; }
+            inline CmdBuffer& getActiveCmdBuffer() noexcept { return _cmd_buffers[_active_image_index]; }
+            inline uint32_t getActiveImageIndex() noexcept { return _active_image_index; }
+            inline uint32_t getImageIndex() noexcept { return _image_index; }
+
+            constexpr inline void requireFrameBufferResize(int index) noexcept { _framebufferResized = true; }
+
+			~Renderer() = default;
+
+		private:
+			GraphicPipeline _pipeline;
+            RenderPass _pass;
+            Surface _surface;
+            CmdPool _cmd_pool;
+            SwapChain _swapchain;
+            Semaphore _semaphore;
+            std::array<CmdBuffer, MAX_FRAMES_IN_FLIGHT> _cmd_buffers;
+
+			class MLX_Window* _window;
+
+            uint32_t _active_image_index = 0;
+            uint32_t _image_index = 0;
+            bool _framebufferResized = false;
+	};
+}
+
+#endif

src/renderer/swapchain/vk_framebuffer.cpp

@@ -6,26 +6,27 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:18:06 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/17 23:34:57 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 20:01:51 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include <volk.h>
 #include <renderer/core/render_core.h>
+#include <renderer/renderer.h>
 
 namespace mlx
 {
-	void FrameBuffer::init(SwapChain* swapchain, ImageView& image)
+	void FrameBuffer::init(Renderer& renderer, ImageView& image)
 	{
 		VkImageView attachments[] = { image() };
 
 		VkFramebufferCreateInfo framebufferInfo{};
 		framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
-		framebufferInfo.renderPass = Render_Core::get().getRenderPass().get();
+		framebufferInfo.renderPass = renderer.getRenderPass().get();
 		framebufferInfo.attachmentCount = 1;
 		framebufferInfo.pAttachments = attachments;
-		framebufferInfo.width = swapchain->_swapChainExtent.width;
+		framebufferInfo.width = renderer.getSwapChain()._swapChainExtent.width;
-		framebufferInfo.height = swapchain->_swapChainExtent.height;
+		framebufferInfo.height = renderer.getSwapChain()._swapChainExtent.height;
 		framebufferInfo.layers = 1;
 
 		if(vkCreateFramebuffer(Render_Core::get().getDevice().get(), &framebufferInfo, nullptr, &_framebuffer) != VK_SUCCESS)	

src/renderer/swapchain/vk_framebuffer.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:19:44 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:07:54 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 19:53:00 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@ namespace mlx
     class FrameBuffer
     {
         public:
-            void init(class SwapChain* swapchain, class ImageView& image);
+            void init(class Renderer& renderer, class ImageView& image);
             void destroy() noexcept;
 
             inline VkFramebuffer& operator()() noexcept { return _framebuffer; }

src/renderer/swapchain/vk_imageview.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:20:49 by maldavid          #+#    #+#             */
-/*   Updated: 2022/10/06 18:21:51 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 19:55:03 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -16,13 +16,13 @@
 
 namespace mlx
 {
-	void ImageView::init(SwapChain* swapchain, VkImage& image)
+	void ImageView::init(SwapChain& swapchain, VkImage& image)
 	{
 		VkImageViewCreateInfo createInfo{};
 		createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
 		createInfo.image = image;
 		createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
-		createInfo.format = swapchain->_swapChainImageFormat;
+		createInfo.format = swapchain._swapChainImageFormat;
 		createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
 		createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
 		createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;

src/renderer/swapchain/vk_imageview.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:20:19 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:07:51 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 19:54:44 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@ namespace mlx
 	class ImageView
 	{
 		public:
-			void init(class SwapChain* swapchain, VkImage& image);
+			void init(class SwapChain& swapchain, VkImage& image);
 			void destroy() noexcept;
 
             inline VkImageView& operator()() noexcept { return _image; }

src/renderer/swapchain/vk_render_pass.cpp

@@ -6,19 +6,24 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:21:36 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:13:49 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/19 00:06:34 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "vk_render_pass.h"
 #include <renderer/core/render_core.h>
+#include <renderer/renderer.h>
 
 namespace mlx
 {
-	void RenderPass::init()
+	static const VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
+
+	void RenderPass::init(Renderer* renderer)
 	{
+		_renderer = renderer;
+
 		VkAttachmentDescription colorAttachment{};
-		colorAttachment.format = Render_Core::get().getSwapChain()._swapChainImageFormat;
+		colorAttachment.format = renderer->getSwapChain()._swapChainImageFormat;
 		colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
 		colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
 		colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
@@ -52,18 +57,16 @@ namespace mlx
 		if(_is_running)
 			return;
 
-        static const VkClearValue clearColor = {0.0f, 0.0f, 0.0f, 1.0f};
-
 		VkRenderPassBeginInfo renderPassInfo{};
 		renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
 		renderPassInfo.renderPass = _renderPass;
-		renderPassInfo.framebuffer = Render_Core::get().getSwapChain()._framebuffers[Render_Core::get().getImageIndex()].get();
+		renderPassInfo.framebuffer = _renderer->getSwapChain()._framebuffers[_renderer->getImageIndex()].get();
 		renderPassInfo.renderArea.offset = { 0, 0 };
-		renderPassInfo.renderArea.extent = Render_Core::get().getSwapChain()._swapChainExtent;
+		renderPassInfo.renderArea.extent = _renderer->getSwapChain()._swapChainExtent;
 		renderPassInfo.clearValueCount = 1;
 		renderPassInfo.pClearValues = &clearColor;
 
-		vkCmdBeginRenderPass(Render_Core::get().getActiveCmdBuffer().get(), &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
+		vkCmdBeginRenderPass(_renderer->getActiveCmdBuffer().get(), &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
 
 		_is_running = true;
 	}
@@ -73,7 +76,7 @@ namespace mlx
 		if(!_is_running)
 			return;
 
-		vkCmdEndRenderPass(Render_Core::get().getActiveCmdBuffer().get());
+		vkCmdEndRenderPass(_renderer->getActiveCmdBuffer().get());
 		_is_running = false;
 	}
 

src/renderer/swapchain/vk_render_pass.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:22:00 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:07:47 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 20:33:28 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@ namespace mlx
 	class RenderPass
 	{
 		public:
-			void init();
+			void init(class Renderer* renderer);
 			void destroy() noexcept;
 
 			void begin();
@@ -31,6 +31,7 @@ namespace mlx
 
 		private:
 			VkRenderPass _renderPass = VK_NULL_HANDLE;
+			class Renderer* _renderer = nullptr;
 			bool _is_running = false;
 	};
 }

src/renderer/swapchain/vk_swapchain.cpp

@@ -6,22 +6,25 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:22:28 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:01:32 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/19 00:05:32 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include <renderer/core/render_core.h>
+#include <renderer/renderer.h>
 #include <platform/window.h>
 #include <SDL2/SDL_vulkan.h>
 #include <algorithm>
 
 namespace mlx
 {
-    void SwapChain::init()
+    void SwapChain::init(Renderer* renderer)
     {
+		_renderer = renderer;
+
         _swapChainSupport = querySwapChainSupport(Render_Core::get().getDevice().getPhysicalDevice());
 
-        VkSurfaceFormatKHR surfaceFormat = Render_Core::get().getSurface().chooseSwapSurfaceFormat(_swapChainSupport.formats);
+        VkSurfaceFormatKHR surfaceFormat = renderer->getSurface().chooseSwapSurfaceFormat(_swapChainSupport.formats);
         VkPresentModeKHR presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
         VkExtent2D extent = chooseSwapExtent(_swapChainSupport.capabilities);
 
@@ -31,7 +34,7 @@ namespace mlx
 
         VkSwapchainCreateInfoKHR createInfo{};
         createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
-        createInfo.surface = Render_Core::get().getSurface().get();
+        createInfo.surface = renderer->getSurface().get();
 
         createInfo.minImageCount = imageCount;
         createInfo.imageFormat = surfaceFormat.format;
@@ -40,7 +43,7 @@ namespace mlx
         createInfo.imageArrayLayers = 1;
         createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
-        Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().findQueueFamilies(Render_Core::get().getDevice().getPhysicalDevice());
+        Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().getFamilies();
         uint32_t queueFamilyIndices[] = {indices.graphicsFamily.value(), indices.presentFamily.value()};
 
         if(indices.graphicsFamily != indices.presentFamily)
@@ -74,10 +77,7 @@ namespace mlx
         _imageViews.resize(_swapChainImages.size());
 
         for(size_t i = 0; i < _swapChainImages.size(); i++)
-        {
+            _imageViews[i].init(*this, _swapChainImages[i]);
-            _imageViews.emplace_back();
-            _imageViews.back().init(this, _swapChainImages[i]);
-        }
     }
 
     void SwapChain::initFB()
@@ -85,16 +85,13 @@ namespace mlx
         _framebuffers.resize(_imageViews.size());
 
         for(size_t i = 0; i < _imageViews.size(); i++)
-        {
+            _framebuffers[i].init(*_renderer, _imageViews[i]);
-            _framebuffers.emplace_back();
-            _framebuffers.back().init(this, _imageViews[i]);
-        }
     }
 
     SwapChain::SwapChainSupportDetails SwapChain::querySwapChainSupport(VkPhysicalDevice device)
     {
         SwapChain::SwapChainSupportDetails details;
-        VkSurfaceKHR surface = Render_Core::get().getSurface().get();
+        VkSurfaceKHR surface = _renderer->getSurface().get();
 
         vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
 
@@ -115,7 +112,7 @@ namespace mlx
             return capabilities.currentExtent;
 
         int width, height;
-        SDL_Vulkan_GetDrawableSize(Render_Core::get().getWindow()->getNativeWindow(), &width, &height);
+        SDL_Vulkan_GetDrawableSize(_renderer->getWindow()->getNativeWindow(), &width, &height);
 
         VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
 
@@ -129,10 +126,10 @@ namespace mlx
     {
         destroyFB();
         destroy();
-        Render_Core::get().getRenderPass().destroy();
+        _renderer->getRenderPass().destroy();
 
-        init();
+        init(_renderer);
-        Render_Core::get().getRenderPass().init();
+        _renderer->getRenderPass().init(_renderer);
         initFB();
     }
 

src/renderer/swapchain/vk_swapchain.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:23:27 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 01:07:44 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/18 22:08:36 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -26,7 +26,7 @@ namespace mlx
         friend class ImageView;
         friend class GraphicPipeline;
         friend class RenderPass;
-		friend class RendererComponent;
+		friend class Renderer;
 
         public:
             struct SwapChainSupportDetails
@@ -35,7 +35,7 @@ namespace mlx
                 std::vector<VkSurfaceFormatKHR> formats;
             };
 
-            void init();
+            void init(class Renderer* renderer);
             void initFB();
             void destroy() noexcept;
             void destroyFB() noexcept;
@@ -53,12 +53,13 @@ namespace mlx
 
         private:
             SwapChainSupportDetails _swapChainSupport;
-            VkSwapchainKHR _swapChain;
             std::vector<VkImage> _swapChainImages;
-            VkFormat _swapChainImageFormat;
-            VkExtent2D _swapChainExtent;
             std::vector<FrameBuffer> _framebuffers;
             std::vector<ImageView> _imageViews;
+            VkSwapchainKHR _swapChain;
+            VkFormat _swapChainImageFormat;
+            VkExtent2D _swapChainExtent;
+			class Renderer* _renderer = nullptr;
     };
 }
 

test/main.c

@@ -6,34 +6,40 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 17:55:21 by maldavid          #+#    #+#             */
-/*   Updated: 2022/12/18 03:51:19 by maldavid         ###   ########.fr       */
+/*   Updated: 2022/12/19 00:55:44 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include <stdio.h>
 #include "../includes/mlx.h"
 
-int	update(void *mlx)
+typedef struct
+{
+	void	*mlx;
+	void	*win;
+}	t_mlx;
+
+int	update(t_mlx *mlx)
 {
 	static int	i = 0;
 
-	puts("dude");
+	printf("%d\r", i);
+	mlx_pixel_put(mlx->mlx, mlx->win, 0, 0, 0xFF0000);
 	i++;
-	if (i > 1000000)
+	if (i > 20000)
-		mlx_loop_end(mlx);
+		mlx_loop_end(mlx->mlx);
 	return (0);
 }
 
 int	main(void)
 {
-	void	*win_ptr;
+	t_mlx	mlx;
-	void	*mlx_ptr;
 	
-	mlx_ptr = mlx_init();
+	mlx.mlx = mlx_init();
-	win_ptr = mlx_new_window(mlx_ptr, 400, 400, "My window");
+	mlx.win = mlx_new_window(mlx.mlx, 400, 400, "My window");
-	mlx_loop_hook(mlx_ptr, update, mlx_ptr);
+	mlx_loop_hook(mlx.mlx, update, &mlx);
-	mlx_loop(mlx_ptr);
+	mlx_loop(mlx.mlx);
-	mlx_destroy_window(mlx_ptr, win_ptr);
+	mlx_destroy_window(mlx.mlx, mlx.win);
-	mlx_destroy_display(mlx_ptr);
+	mlx_destroy_display(mlx.mlx);
 	return (0);
 }

third_party/glm/common.hpp

@@ -0,0 +1,539 @@
+/// @ref core
+/// @file glm/common.hpp
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+///
+/// @defgroup core_func_common Common functions
+/// @ingroup core
+///
+/// Provides GLSL common functions
+///
+/// These all operate component-wise. The description is per component.
+///
+/// Include <glm/common.hpp> to use these core features.
+
+#pragma once
+
+#include "detail/qualifier.hpp"
+#include "detail/_fixes.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_common
+	/// @{
+
+	/// Returns x if x >= 0; otherwise, it returns -x.
+	///
+	/// @tparam genType floating-point or signed integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType abs(genType x);
+
+	/// Returns x if x >= 0; otherwise, it returns -x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or signed integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> abs(vec<L, T, Q> const& x);
+
+	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> sign(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer that is less then or equal to x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> floor(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer to x
+	/// whose absolute value is not larger than the absolute value of x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> trunc(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer to x.
+	/// The fraction 0.5 will round in a direction chosen by the
+	/// implementation, presumably the direction that is fastest.
+	/// This includes the possibility that round(x) returns the
+	/// same value as roundEven(x) for all values of x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> round(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer to x.
+	/// A fractional part of 0.5 will round toward the nearest even
+	/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> roundEven(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer
+	/// that is greater than or equal to x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> ceil(vec<L, T, Q> const& x);
+
+	/// Return x - floor(x).
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType fract(genType x);
+
+	/// Return x - floor(x).
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fract(vec<L, T, Q> const& x);
+
+	template<typename genType>
+	GLM_FUNC_DECL genType mod(genType x, genType y);
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> mod(vec<L, T, Q> const& x, T y);
+
+	/// Modulus. Returns x - y * floor(x / y)
+	/// for each component in x using the floating point value y.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types, include glm/gtc/integer for integer scalar types support
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> mod(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns the fractional part of x and sets i to the integer
+	/// part (as a whole number floating point value). Both the
+	/// return value and the output parameter will have the same
+	/// sign as x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType modf(genType x, genType& i);
+
+	/// Returns y if y < x; otherwise, it returns x.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType min(genType x, genType y);
+
+	/// Returns y if y < x; otherwise, it returns x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& x, T y);
+
+	/// Returns y if y < x; otherwise, it returns x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns y if x < y; otherwise, it returns x.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType max(genType x, genType y);
+
+	/// Returns y if x < y; otherwise, it returns x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, T y);
+
+	/// Returns y if x < y; otherwise, it returns x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x
+	/// using the floating-point values minVal and maxVal.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x
+	/// using the floating-point values minVal and maxVal.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, T minVal, T maxVal);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x
+	/// using the floating-point values minVal and maxVal.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal);
+
+	/// If genTypeU is a floating scalar or vector:
+	/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
+	/// x and y using the floating-point value a.
+	/// The value for a is not restricted to the range [0, 1].
+	///
+	/// If genTypeU is a boolean scalar or vector:
+	/// Selects which vector each returned component comes
+	/// from. For a component of 'a' that is false, the
+	/// corresponding component of 'x' is returned. For a
+	/// component of 'a' that is true, the corresponding
+	/// component of 'y' is returned. Components of 'x' and 'y' that
+	/// are not selected are allowed to be invalid floating point
+	/// values and will have no effect on the results. Thus, this
+	/// provides different functionality than
+	/// genType mix(genType x, genType y, genType(a))
+	/// where a is a Boolean vector.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mix.xml">GLSL mix man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	///
+	/// @param[in]  x Value to interpolate.
+	/// @param[in]  y Value to interpolate.
+	/// @param[in]  a Interpolant.
+	///
+	/// @tparam	genTypeT Floating point scalar or vector.
+	/// @tparam genTypeU Floating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT.
+	///
+	/// @code
+	/// #include <glm/glm.hpp>
+	/// ...
+	/// float a;
+	/// bool b;
+	/// glm::dvec3 e;
+	/// glm::dvec3 f;
+	/// glm::vec4 g;
+	/// glm::vec4 h;
+	/// ...
+	/// glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors.
+	/// glm::vec4 s = glm::mix(g, h, b); // Returns g or h;
+	/// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
+	/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
+	/// @endcode
+	template<typename genTypeT, typename genTypeU>
+	GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
+
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a);
+
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType step(genType edge, genType x);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> step(T edge, vec<L, T, Q> const& x);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> step(vec<L, T, Q> const& edge, vec<L, T, Q> const& x);
+
+	/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
+	/// performs smooth Hermite interpolation between 0 and 1
+	/// when edge0 < x < edge1. This is useful in cases where
+	/// you would want a threshold function with a smooth
+	/// transition. This is equivalent to:
+	/// genType t;
+	/// t = clamp ((x - edge0) / (edge1 - edge0), 0, 1);
+	/// return t * t * (3 - 2 * t);
+	/// Results are undefined if edge0 >= edge1.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x);
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> smoothstep(T edge0, T edge1, vec<L, T, Q> const& x);
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> smoothstep(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x);
+
+	/// Returns true if x holds a NaN (not a number)
+	/// representation in the underlying implementation's set of
+	/// floating point representations. Returns false otherwise,
+	/// including for implementations with no NaN
+	/// representations.
+	///
+	/// /!\ When using compiler fast math, this function may fail.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> isnan(vec<L, T, Q> const& x);
+
+	/// Returns true if x holds a positive infinity or negative
+	/// infinity representation in the underlying implementation's
+	/// set of floating point representations. Returns false
+	/// otherwise, including for implementations with no infinity
+	/// representations.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> isinf(vec<L, T, Q> const& x);
+
+	/// Returns a signed integer value representing
+	/// the encoding of a floating-point value. The floating-point
+	/// value's bit-level representation is preserved.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL int floatBitsToInt(float const& v);
+
+	/// Returns a signed integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, int, Q> floatBitsToInt(vec<L, float, Q> const& v);
+
+	/// Returns a unsigned integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL uint floatBitsToUint(float const& v);
+
+	/// Returns a unsigned integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, uint, Q> floatBitsToUint(vec<L, float, Q> const& v);
+
+	/// Returns a floating-point value corresponding to a signed
+	/// integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL float intBitsToFloat(int const& v);
+
+	/// Returns a floating-point value corresponding to a signed
+	/// integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, float, Q> intBitsToFloat(vec<L, int, Q> const& v);
+
+	/// Returns a floating-point value corresponding to a
+	/// unsigned integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL float uintBitsToFloat(uint const& v);
+
+	/// Returns a floating-point value corresponding to a
+	/// unsigned integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, float, Q> uintBitsToFloat(vec<L, uint, Q> const& v);
+
+	/// Computes and returns a * b + c.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType fma(genType const& a, genType const& b, genType const& c);
+
+	/// Splits x into a floating-point significand in the range
+	/// [0.5, 1.0) and an integral exponent of two, such that:
+	/// x = significand * exp(2, exponent)
+	///
+	/// The significand is returned by the function and the
+	/// exponent is returned in the parameter exp. For a
+	/// floating-point value of zero, the significant and exponent
+	/// are both zero. For a floating-point value that is an
+	/// infinity or is not a number, the results are undefined.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType frexp(genType x, int& exp);
+	
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> frexp(vec<L, T, Q> const& v, vec<L, int, Q>& exp);
+
+	/// Builds a floating-point number from x and the
+	/// corresponding integral exponent of two in exp, returning:
+	/// significand * exp(2, exponent)
+	///
+	/// If this product is too large to be represented in the
+	/// floating-point type, the result is undefined.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>;
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType ldexp(genType const& x, int const& exp);
+	
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> ldexp(vec<L, T, Q> const& v, vec<L, int, Q> const& exp);
+
+	/// @}
+}//namespace glm
+
+#include "detail/func_common.inl"
+

third_party/glm/detail/_features.hpp

@@ -0,0 +1,394 @@
+#pragma once
+
+// #define GLM_CXX98_EXCEPTIONS
+// #define GLM_CXX98_RTTI
+
+// #define GLM_CXX11_RVALUE_REFERENCES
+// Rvalue references - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html
+
+// GLM_CXX11_TRAILING_RETURN
+// Rvalue references for *this - GCC not supported
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Initialization of class objects by rvalues - GCC any
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Non-static data member initializers - GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm
+
+// #define GLM_CXX11_VARIADIC_TEMPLATE
+// Variadic templates - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf
+
+//
+// Extending variadic template template parameters - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
+
+// #define GLM_CXX11_GENERALIZED_INITIALIZERS
+// Initializer lists - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
+
+// #define GLM_CXX11_STATIC_ASSERT
+// Static assertions - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html
+
+// #define GLM_CXX11_AUTO_TYPE
+// auto-typed variables - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Multi-declarator auto - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Removal of auto as a storage-class specifier - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm
+
+// #define GLM_CXX11_AUTO_TYPE
+// New function declarator syntax - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm
+
+// #define GLM_CXX11_LAMBDAS
+// New wording for C++0x lambdas - GCC 4.5
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf
+
+// #define GLM_CXX11_DECLTYPE
+// Declared type of an expression - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf
+
+//
+// Right angle brackets - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html
+
+//
+// Default template arguments for function templates	DR226	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226
+
+//
+// Solving the SFINAE problem for expressions	DR339	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html
+
+// #define GLM_CXX11_ALIAS_TEMPLATE
+// Template aliases	N2258	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
+
+//
+// Extern templates	N1987	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm
+
+// #define GLM_CXX11_NULLPTR
+// Null pointer constant	N2431	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
+
+// #define GLM_CXX11_STRONG_ENUMS
+// Strongly-typed enums	N2347	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf
+
+//
+// Forward declarations for enums	N2764	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf
+
+//
+// Generalized attributes	N2761	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf
+
+//
+// Generalized constant expressions	N2235	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
+
+//
+// Alignment support	N2341	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
+
+// #define GLM_CXX11_DELEGATING_CONSTRUCTORS
+// Delegating constructors	N1986	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
+
+//
+// Inheriting constructors	N2540	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm
+
+// #define GLM_CXX11_EXPLICIT_CONVERSIONS
+// Explicit conversion operators	N2437	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
+
+//
+// New character types	N2249	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html
+
+//
+// Unicode string literals	N2442	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+//
+// Raw string literals	N2442	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+//
+// Universal character name literals	N2170	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html
+
+// #define GLM_CXX11_USER_LITERALS
+// User-defined literals		N2765	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf
+
+//
+// Standard Layout Types	N2342	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm
+
+// #define GLM_CXX11_DEFAULTED_FUNCTIONS
+// #define GLM_CXX11_DELETED_FUNCTIONS
+// Defaulted and deleted functions	N2346	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm
+
+//
+// Extended friend declarations	N1791	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
+
+//
+// Extending sizeof	N2253	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html
+
+// #define GLM_CXX11_INLINE_NAMESPACES
+// Inline namespaces	N2535	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm
+
+// #define GLM_CXX11_UNRESTRICTED_UNIONS
+// Unrestricted unions	N2544	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+
+// #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+// Local and unnamed types as template arguments	N2657	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm
+
+// #define GLM_CXX11_RANGE_FOR
+// Range-based for	N2930	GCC 4.6
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html
+
+// #define GLM_CXX11_OVERRIDE_CONTROL
+// Explicit virtual overrides	N2928 N3206 N3272	GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm
+
+//
+// Minimal support for garbage collection and reachability-based leak detection	N2670	No
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm
+
+// #define GLM_CXX11_NOEXCEPT
+// Allowing move constructors to throw [noexcept]	N3050	GCC 4.6 (core language only)
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html
+
+//
+// Defining move special member functions	N3053	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html
+
+//
+// Sequence points	N2239	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+//
+// Atomic operations	N2427	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+//
+// Strong Compare and Exchange	N2748	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
+
+//
+// Bidirectional Fences	N2752	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm
+
+//
+// Memory model	N2429	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm
+
+//
+// Data-dependency ordering: atomics and memory model	N2664	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm
+
+//
+// Propagating exceptions	N2179	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html
+
+//
+// Abandoning a process and at_quick_exit	N2440	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm
+
+//
+// Allow atomics use in signal handlers	N2547	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm
+
+//
+// Thread-local storage	N2659	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm
+
+//
+// Dynamic initialization and destruction with concurrency	N2660	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm
+
+//
+// __func__ predefined identifier	N2340	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm
+
+//
+// C99 preprocessor	N1653	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
+
+//
+// long long	N1811	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf
+
+//
+// Extended integral types	N1988	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf
+
+#if(GLM_COMPILER & GLM_COMPILER_GCC)
+
+#	define GLM_CXX11_STATIC_ASSERT
+
+#elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+#	if(__has_feature(cxx_exceptions))
+#		define GLM_CXX98_EXCEPTIONS
+#	endif
+
+#	if(__has_feature(cxx_rtti))
+#		define GLM_CXX98_RTTI
+#	endif
+
+#	if(__has_feature(cxx_access_control_sfinae))
+#		define GLM_CXX11_ACCESS_CONTROL_SFINAE
+#	endif
+
+#	if(__has_feature(cxx_alias_templates))
+#		define GLM_CXX11_ALIAS_TEMPLATE
+#	endif
+
+#	if(__has_feature(cxx_alignas))
+#		define GLM_CXX11_ALIGNAS
+#	endif
+
+#	if(__has_feature(cxx_attributes))
+#		define GLM_CXX11_ATTRIBUTES
+#	endif
+
+#	if(__has_feature(cxx_constexpr))
+#		define GLM_CXX11_CONSTEXPR
+#	endif
+
+#	if(__has_feature(cxx_decltype))
+#		define GLM_CXX11_DECLTYPE
+#	endif
+
+#	if(__has_feature(cxx_default_function_template_args))
+#		define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS
+#	endif
+
+#	if(__has_feature(cxx_defaulted_functions))
+#		define GLM_CXX11_DEFAULTED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_delegating_constructors))
+#		define GLM_CXX11_DELEGATING_CONSTRUCTORS
+#	endif
+
+#	if(__has_feature(cxx_deleted_functions))
+#		define GLM_CXX11_DELETED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_explicit_conversions))
+#		define GLM_CXX11_EXPLICIT_CONVERSIONS
+#	endif
+
+#	if(__has_feature(cxx_generalized_initializers))
+#		define GLM_CXX11_GENERALIZED_INITIALIZERS
+#	endif
+
+#	if(__has_feature(cxx_implicit_moves))
+#		define GLM_CXX11_IMPLICIT_MOVES
+#	endif
+
+#	if(__has_feature(cxx_inheriting_constructors))
+#		define GLM_CXX11_INHERITING_CONSTRUCTORS
+#	endif
+
+#	if(__has_feature(cxx_inline_namespaces))
+#		define GLM_CXX11_INLINE_NAMESPACES
+#	endif
+
+#	if(__has_feature(cxx_lambdas))
+#		define GLM_CXX11_LAMBDAS
+#	endif
+
+#	if(__has_feature(cxx_local_type_template_args))
+#		define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+#	endif
+
+#	if(__has_feature(cxx_noexcept))
+#		define GLM_CXX11_NOEXCEPT
+#	endif
+
+#	if(__has_feature(cxx_nonstatic_member_init))
+#		define GLM_CXX11_NONSTATIC_MEMBER_INIT
+#	endif
+
+#	if(__has_feature(cxx_nullptr))
+#		define GLM_CXX11_NULLPTR
+#	endif
+
+#	if(__has_feature(cxx_override_control))
+#		define GLM_CXX11_OVERRIDE_CONTROL
+#	endif
+
+#	if(__has_feature(cxx_reference_qualified_functions))
+#		define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_range_for))
+#		define GLM_CXX11_RANGE_FOR
+#	endif
+
+#	if(__has_feature(cxx_raw_string_literals))
+#		define GLM_CXX11_RAW_STRING_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_rvalue_references))
+#		define GLM_CXX11_RVALUE_REFERENCES
+#	endif
+
+#	if(__has_feature(cxx_static_assert))
+#		define GLM_CXX11_STATIC_ASSERT
+#	endif
+
+#	if(__has_feature(cxx_auto_type))
+#		define GLM_CXX11_AUTO_TYPE
+#	endif
+
+#	if(__has_feature(cxx_strong_enums))
+#		define GLM_CXX11_STRONG_ENUMS
+#	endif
+
+#	if(__has_feature(cxx_trailing_return))
+#		define GLM_CXX11_TRAILING_RETURN
+#	endif
+
+#	if(__has_feature(cxx_unicode_literals))
+#		define GLM_CXX11_UNICODE_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_unrestricted_unions))
+#		define GLM_CXX11_UNRESTRICTED_UNIONS
+#	endif
+
+#	if(__has_feature(cxx_user_literals))
+#		define GLM_CXX11_USER_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_variadic_templates))
+#		define GLM_CXX11_VARIADIC_TEMPLATES
+#	endif
+
+#endif//(GLM_COMPILER & GLM_COMPILER_CLANG)

third_party/glm/detail/_fixes.hpp

@@ -0,0 +1,27 @@
+#include <cmath>
+
+//! Workaround for compatibility with other libraries
+#ifdef max
+#undef max
+#endif
+
+//! Workaround for compatibility with other libraries
+#ifdef min
+#undef min
+#endif
+
+//! Workaround for Android
+#ifdef isnan
+#undef isnan
+#endif
+
+//! Workaround for Android
+#ifdef isinf
+#undef isinf
+#endif
+
+//! Workaround for Chrone Native Client
+#ifdef log2
+#undef log2
+#endif
+

third_party/glm/detail/_noise.hpp

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "../common.hpp"
+
+namespace glm{
+namespace detail
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER T mod289(T const& x)
+	{
+		return x - floor(x * (static_cast<T>(1.0) / static_cast<T>(289.0))) * static_cast<T>(289.0);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T permute(T const& x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r)
+	{
+		return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r)
+	{
+		return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r)
+	{
+		return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r)
+	{
+		return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t)
+	{
+		return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t)
+	{
+		return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t)
+	{
+		return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+	}
+}//namespace detail
+}//namespace glm
+

third_party/glm/detail/_swizzle.hpp

@@ -0,0 +1,804 @@
+#pragma once
+
+namespace glm{
+namespace detail
+{
+	// Internal class for implementing swizzle operators
+	template<typename T, int N>
+	struct _swizzle_base0
+	{
+	protected:
+		GLM_FUNC_QUALIFIER T& elem(size_t i){ return (reinterpret_cast<T*>(_buffer))[i]; }
+		GLM_FUNC_QUALIFIER T const& elem(size_t i) const{ return (reinterpret_cast<const T*>(_buffer))[i]; }
+
+		// Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
+		// The size 1 buffer is assumed to aligned to the actual members so that the
+		// elem()
+		char    _buffer[1];
+	};
+
+	template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, bool Aligned>
+	struct _swizzle_base1 : public _swizzle_base0<T, N>
+	{
+	};
+
+	template<typename T, qualifier Q, int E0, int E1, bool Aligned>
+	struct _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2>
+	{
+		GLM_FUNC_QUALIFIER vec<2, T, Q> operator ()()  const { return vec<2, T, Q>(this->elem(E0), this->elem(E1)); }
+	};
+
+	template<typename T, qualifier Q, int E0, int E1, int E2, bool Aligned>
+	struct _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> : public _swizzle_base0<T, 3>
+	{
+		GLM_FUNC_QUALIFIER vec<3, T, Q> operator ()()  const { return vec<3, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2)); }
+	};
+
+	template<typename T, qualifier Q, int E0, int E1, int E2, int E3, bool Aligned>
+	struct _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> : public _swizzle_base0<T, 4>
+	{
+		GLM_FUNC_QUALIFIER vec<4, T, Q> operator ()()  const { return vec<4, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
+	};
+
+	// Internal class for implementing swizzle operators
+	/*
+		Template parameters:
+
+		T			= type of scalar values (e.g. float, double)
+		N			= number of components in the vector (e.g. 3)
+		E0...3		= what index the n-th element of this swizzle refers to in the unswizzled vec
+
+		DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
+			containing duplicate elements so that they cannot be used as r-values).
+	*/
+	template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
+	struct _swizzle_base2 : public _swizzle_base1<N, T, Q, E0,E1,E2,E3, detail::is_aligned<Q>::value>
+	{
+		struct op_equal
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e = t; }
+		};
+
+		struct op_minus
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e -= t; }
+		};
+
+		struct op_plus
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e += t; }
+		};
+
+		struct op_mul
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e *= t; }
+		};
+
+		struct op_div
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e /= t; }
+		};
+
+	public:
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t)
+		{
+			for (int i = 0; i < N; ++i)
+				(*this)[i] = t;
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_equal());
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER void operator -= (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_minus());
+		}
+
+		GLM_FUNC_QUALIFIER void operator += (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_plus());
+		}
+
+		GLM_FUNC_QUALIFIER void operator *= (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_mul());
+		}
+
+		GLM_FUNC_QUALIFIER void operator /= (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_div());
+		}
+
+		GLM_FUNC_QUALIFIER T& operator[](size_t i)
+		{
+			const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+		GLM_FUNC_QUALIFIER T operator[](size_t i) const
+		{
+			const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+
+	protected:
+		template<typename U>
+		GLM_FUNC_QUALIFIER void _apply_op(vec<N, T, Q> const& that, const U& op)
+		{
+			// Make a copy of the data in this == &that.
+			// The copier should optimize out the copy in cases where the function is
+			// properly inlined and the copy is not necessary.
+			T t[N];
+			for (int i = 0; i < N; ++i)
+				t[i] = that[i];
+			for (int i = 0; i < N; ++i)
+				op( (*this)[i], t[i] );
+		}
+	};
+
+	// Specialization for swizzles containing duplicate elements.  These cannot be modified.
+	template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle_base2<N, T, Q, E0,E1,E2,E3, 1> : public _swizzle_base1<N, T, Q, E0,E1,E2,E3, detail::is_aligned<Q>::value>
+	{
+		struct Stub {};
+
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const&) { return *this; }
+
+		GLM_FUNC_QUALIFIER T operator[]  (size_t i) const
+		{
+			const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+	};
+
+	template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle : public _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)>
+	{
+		typedef _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)> base_type;
+
+		using base_type::operator=;
+
+		GLM_FUNC_QUALIFIER operator vec<N, T, Q> () const { return (*this)(); }
+	};
+
+//
+// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
+//
+#define GLM_SWIZZLE_TEMPLATE1   template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+#define GLM_SWIZZLE_TEMPLATE2   template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
+#define GLM_SWIZZLE_TYPE1       _swizzle<N, T, Q, E0, E1, E2, E3>
+#define GLM_SWIZZLE_TYPE2       _swizzle<N, T, Q, F0, F1, F2, F3>
+
+//
+// Wrapper for a binary operator (e.g. u.yy + v.zy)
+//
+#define GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
+	GLM_SWIZZLE_TEMPLATE2                                                          \
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b)  \
+	{                                                                               \
+		return a() OPERAND b();                                                     \
+	}                                                                               \
+	GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const vec<N, T, Q>& b)                   \
+	{                                                                               \
+		return a() OPERAND b;                                                       \
+	}                                                                               \
+	GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const vec<N, T, Q>& a, const GLM_SWIZZLE_TYPE1& b)                   \
+	{                                                                               \
+		return a OPERAND b();                                                       \
+	}
+
+//
+// Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
+//
+#define GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)								\
+	GLM_SWIZZLE_TEMPLATE1																		\
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const T& b)	\
+	{																							\
+		return a() OPERAND b;																	\
+	}																							\
+	GLM_SWIZZLE_TEMPLATE1																		\
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const T& a, const GLM_SWIZZLE_TYPE1& b)	\
+	{																							\
+		return a OPERAND b();																	\
+	}
+
+//
+// Macro for wrapping a function taking one argument (e.g. abs())
+//
+#define GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION)												\
+	GLM_SWIZZLE_TEMPLATE1																				\
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a)		\
+	{																									\
+		return FUNCTION(a());																			\
+	}
+
+//
+// Macro for wrapping a function taking two vector arguments (e.g. dot()).
+//
+#define GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION)                                                       \
+	GLM_SWIZZLE_TEMPLATE2                                                                                       \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \
+	{                                                                                                           \
+		return FUNCTION(a(), b());                                                                              \
+	}                                                                                                           \
+	GLM_SWIZZLE_TEMPLATE1                                                                                       \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b) \
+	{                                                                                                           \
+		return FUNCTION(a(), b());                                                                              \
+	}                                                                                                           \
+	GLM_SWIZZLE_TEMPLATE1                                                                                       \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename V& b)         \
+	{                                                                                                           \
+		return FUNCTION(a(), b);                                                                                \
+	}                                                                                                           \
+	GLM_SWIZZLE_TEMPLATE1                                                                                       \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const GLM_SWIZZLE_TYPE1& b)                  \
+	{                                                                                                           \
+		return FUNCTION(a, b());                                                                                \
+	}
+
+//
+// Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
+//
+#define GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION)                                                             \
+	GLM_SWIZZLE_TEMPLATE2                                                                                                    \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b, const T& c)   \
+	{                                                                                                                         \
+		return FUNCTION(a(), b(), c);                                                                                         \
+	}                                                                                                                         \
+	GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b, const T& c)   \
+	{                                                                                                                         \
+		return FUNCTION(a(), b(), c);                                                                                         \
+	}                                                                                                                         \
+	GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
+	{                                                                                                                         \
+		return FUNCTION(a(), b, c);                                                                                           \
+	}                                                                                                                         \
+	GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const GLM_SWIZZLE_TYPE1& b, const T& c)           \
+	{                                                                                                                         \
+		return FUNCTION(a, b(), c);                                                                                           \
+	}
+
+}//namespace detail
+}//namespace glm
+
+namespace glm
+{
+	namespace detail
+	{
+		GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
+		GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
+		GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
+		GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
+		GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
+		GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
+	}
+
+	//
+	// Swizzles are distinct types from the unswizzled type.  The below macros will
+	// provide template specializations for the swizzle types for the given functions
+	// so that the compiler does not have any ambiguity to choosing how to handle
+	// the function.
+	//
+	// The alternative is to use the operator()() when calling the function in order
+	// to explicitly convert the swizzled type to the unswizzled type.
+	//
+
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    abs);
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acos);
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acosh);
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    all);
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    any);
+
+	//GLM_SWIZZLE_FUNCTION_2_ARGS(value_type,  dot);
+	//GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    cross);
+	//GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    step);
+	//GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
+}
+
+#define GLM_SWIZZLE2_2_MEMBERS(T, Q, E0,E1) \
+	struct { detail::_swizzle<2, T, Q, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2, T, Q, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2, T, Q, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2, T, Q, 1,1,-1,-2> E1 ## E1; };
+
+#define GLM_SWIZZLE2_3_MEMBERS(T, Q, E0,E1) \
+	struct { detail::_swizzle<3,T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T, Q, 1,1,1,-1> E1 ## E1 ## E1; };
+
+#define GLM_SWIZZLE2_4_MEMBERS(T, Q, E0,E1) \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; };
+
+#define GLM_SWIZZLE3_2_MEMBERS(T, Q, E0,E1,E2) \
+	struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; };
+
+#define GLM_SWIZZLE3_3_MEMBERS(T, Q ,E0,E1,E2) \
+	struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; };
+
+#define GLM_SWIZZLE3_4_MEMBERS(T, Q, E0,E1,E2) \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; };
+
+#define GLM_SWIZZLE4_2_MEMBERS(T, Q, E0,E1,E2,E3) \
+	struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 0,3,-1,-2> E0 ## E3; }; \
+	struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 1,3,-1,-2> E1 ## E3; }; \
+	struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 2,3,-1,-2> E2 ## E3; }; \
+	struct { detail::_swizzle<2,T, Q, 3,0,-1,-2> E3 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 3,1,-1,-2> E3 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 3,2,-1,-2> E3 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 3,3,-1,-2> E3 ## E3; };
+
+#define GLM_SWIZZLE4_3_MEMBERS(T, Q, E0,E1,E2,E3) \
+	struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,3,-1> E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,3,-1> E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,3,-1> E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 0,3,0,-1> E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,3,1,-1> E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,3,2,-1> E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,3,3,-1> E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,3,-1> E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,3,-1> E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,3,-1> E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 1,3,0,-1> E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,3,1,-1> E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,3,2,-1> E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,3,3,-1> E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,3,-1> E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,3,-1> E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,3,-1> E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 2,3,0,-1> E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,3,1,-1> E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,3,2,-1> E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,3,3,-1> E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 3,0,0,-1> E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 3,0,1,-1> E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 3,0,2,-1> E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 3,0,3,-1> E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 3,1,0,-1> E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 3,1,1,-1> E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 3,1,2,-1> E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 3,1,3,-1> E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 3,2,0,-1> E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 3,2,1,-1> E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 3,2,2,-1> E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 3,2,3,-1> E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 3,3,0,-1> E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 3,3,1,-1> E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 3,3,2,-1> E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 3,3,3,-1> E3 ## E3 ## E3; };
+
+#define GLM_SWIZZLE4_4_MEMBERS(T, Q, E0,E1,E2,E3) \
+	struct { detail::_swizzle<4, T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,3,3> E3 ## E3 ## E3 ## E3; };

third_party/glm/detail/_swizzle_func.hpp

@@ -0,0 +1,682 @@
+#pragma once
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, CONST, A, B)	\
+	vec<2, T, Q> A ## B() CONST							\
+	{													\
+		return vec<2, T, Q>(this->A, this->B);			\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, CONST, A, B, C)		\
+	vec<3, T, Q> A ## B ## C() CONST							\
+	{															\
+		return vec<3, T, Q>(this->A, this->B, this->C);			\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, CONST, A, B, C, D)					\
+	vec<4, T, Q> A ## B ## C ## D() CONST									\
+	{																		\
+		return vec<4, T, Q>(this->A, this->B, this->C, this->D);			\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(T, P, L, CONST, A, B)	\
+	template<typename T>										\
+	vec<L, T, Q> vec<L, T, Q>::A ## B() CONST					\
+	{															\
+		return vec<2, T, Q>(this->A, this->B);					\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(T, P, L, CONST, A, B, C)		\
+	template<typename T>											\
+	vec<3, T, Q> vec<L, T, Q>::A ## B ## C() CONST					\
+	{																\
+		return vec<3, T, Q>(this->A, this->B, this->C);				\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(T, P, L, CONST, A, B, C, D)		\
+	template<typename T>												\
+	vec<4, T, Q> vec<L, T, Q>::A ## B ## C ## D() CONST					\
+	{																	\
+		return vec<4, T, Q>(this->A, this->B, this->C, this->D);		\
+	}
+
+#define GLM_MUTABLE
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(T, P) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, x, y) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, r, g) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, s, t)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, x, y, z) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, r, g, b) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, s, t, p)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, C)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, B)
+
+#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, C, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, x, y, z, w) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, r, g, b, a) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, s, t, p, q)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P)			\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, x, y)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, r, g)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, s, t)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, x, y, z) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, r, g, b) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, s, t, p)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, x, y, z, w) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, r, g, b, a) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, s, t, p, q)
+

third_party/glm/detail/_vectorize.hpp

@@ -0,0 +1,162 @@
+#pragma once
+
+namespace glm{
+namespace detail
+{
+	template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename R, typename T, qualifier Q>
+	struct functor1{};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+	struct functor1<vec, 1, R, T, Q>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<1, R, Q> call(R (*Func) (T x), vec<1, T, Q> const& v)
+		{
+			return vec<1, R, Q>(Func(v.x));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+	struct functor1<vec, 2, R, T, Q>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<2, R, Q> call(R (*Func) (T x), vec<2, T, Q> const& v)
+		{
+			return vec<2, R, Q>(Func(v.x), Func(v.y));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+	struct functor1<vec, 3, R, T, Q>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<3, R, Q> call(R (*Func) (T x), vec<3, T, Q> const& v)
+		{
+			return vec<3, R, Q>(Func(v.x), Func(v.y), Func(v.z));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+	struct functor1<vec, 4, R, T, Q>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, R, Q> call(R (*Func) (T x), vec<4, T, Q> const& v)
+		{
+			return vec<4, R, Q>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+	struct functor2{};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2<vec, 1, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, vec<1, T, Q> const& b)
+		{
+			return vec<1, T, Q>(Func(a.x, b.x));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2<vec, 2, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, vec<2, T, Q> const& b)
+		{
+			return vec<2, T, Q>(Func(a.x, b.x), Func(a.y, b.y));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2<vec, 3, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, vec<3, T, Q> const& b)
+		{
+			return vec<3, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2<vec, 4, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+	struct functor2_vec_sca{};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2_vec_sca<vec, 1, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, T b)
+		{
+			return vec<1, T, Q>(Func(a.x, b));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2_vec_sca<vec, 2, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, T b)
+		{
+			return vec<2, T, Q>(Func(a.x, b), Func(a.y, b));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2_vec_sca<vec, 3, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, T b)
+		{
+			return vec<3, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2_vec_sca<vec, 4, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, T b)
+		{
+			return vec<4, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct functor2_vec_int {};
+
+	template<typename T, qualifier Q>
+	struct functor2_vec_int<1, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<1, int, Q> call(int (*Func) (T x, int y), vec<1, T, Q> const& a, vec<1, int, Q> const& b)
+		{
+			return vec<1, int, Q>(Func(a.x, b.x));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct functor2_vec_int<2, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<2, int, Q> call(int (*Func) (T x, int y), vec<2, T, Q> const& a, vec<2, int, Q> const& b)
+		{
+			return vec<2, int, Q>(Func(a.x, b.x), Func(a.y, b.y));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct functor2_vec_int<3, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, int, Q> call(int (*Func) (T x, int y), vec<3, T, Q> const& a, vec<3, int, Q> const& b)
+		{
+			return vec<3, int, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct functor2_vec_int<4, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(int (*Func) (T x, int y), vec<4, T, Q> const& a, vec<4, int, Q> const& b)
+		{
+			return vec<4, int, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
+		}
+	};
+}//namespace detail
+}//namespace glm

third_party/glm/detail/compute_common.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "setup.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template<typename genFIType, bool /*signed*/>
+	struct compute_abs
+	{};
+
+	template<typename genFIType>
+	struct compute_abs<genFIType, true>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
+		{
+			GLM_STATIC_ASSERT(
+				std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed,
+				"'abs' only accept floating-point and integer scalar or vector inputs");
+
+			return x >= genFIType(0) ? x : -x;
+			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
+		}
+	};
+
+#if GLM_COMPILER & GLM_COMPILER_CUDA
+	template<>
+	struct compute_abs<float, true>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static float call(float x)
+		{
+			return fabsf(x);
+		}
+	};
+#endif
+
+	template<typename genFIType>
+	struct compute_abs<genFIType, false>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
+		{
+			GLM_STATIC_ASSERT(
+				(!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
+				"'abs' only accept floating-point and integer scalar or vector inputs");
+			return x;
+		}
+	};
+}//namespace detail
+}//namespace glm

third_party/glm/detail/compute_vector_relational.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+//#include "compute_common.hpp"
+#include "setup.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template <typename T, bool isFloat>
+	struct compute_equal
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b)
+		{
+			return a == b;
+		}
+	};
+/*
+	template <typename T>
+	struct compute_equal<T, true>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b)
+		{
+			return detail::compute_abs<T, std::numeric_limits<T>::is_signed>::call(b - a) <= static_cast<T>(0);
+			//return std::memcmp(&a, &b, sizeof(T)) == 0;
+		}
+	};
+*/
+}//namespace detail
+}//namespace glm

third_party/glm/detail/func_common.inl

@@ -0,0 +1,792 @@
+/// @ref core
+/// @file glm/detail/func_common.inl
+
+#include "../vector_relational.hpp"
+#include "compute_common.hpp"
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include "_vectorize.hpp"
+#include <limits>
+
+namespace glm
+{
+	// min
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType min(genType x, genType y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'min' only accept floating-point or integer inputs");
+		return (y < x) ? y : x;
+	}
+
+	// max
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType max(genType x, genType y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'max' only accept floating-point or integer inputs");
+
+		return (x < y) ? y : x;
+	}
+
+	// abs
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR int abs(int x)
+	{
+		int const y = x >> (sizeof(int) * 8 - 1);
+		return (x ^ y) - y;
+	}
+
+	// round
+#	if GLM_HAS_CXX11_STL
+		using ::std::round;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType round(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'round' only accept floating-point inputs");
+
+			return x < static_cast<genType>(0) ? static_cast<genType>(int(x - static_cast<genType>(0.5))) : static_cast<genType>(int(x + static_cast<genType>(0.5)));
+		}
+#	endif
+
+	// trunc
+#	if GLM_HAS_CXX11_STL
+		using ::std::trunc;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType trunc(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'trunc' only accept floating-point inputs");
+
+			return x < static_cast<genType>(0) ? -std::floor(-x) : std::floor(x);
+		}
+#	endif
+
+}//namespace glm
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_abs_vector
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(abs, x);
+		}
+	};
+
+	template<length_t L, typename T, typename U, qualifier Q, bool Aligned>
+	struct compute_mix_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return vec<L, T, Q>(vec<L, U, Q>(x) * (static_cast<U>(1) - a) + vec<L, U, Q>(y) * a);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_mix_vector<L, T, bool, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, bool, Q> const& a)
+		{
+			vec<L, T, Q> Result;
+			for(length_t i = 0; i < x.length(); ++i)
+				Result[i] = a[i] ? y[i] : x[i];
+			return Result;
+		}
+	};
+
+	template<length_t L, typename T, typename U, qualifier Q, bool Aligned>
+	struct compute_mix_scalar
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U const& a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return vec<L, T, Q>(vec<L, U, Q>(x) * (static_cast<U>(1) - a) + vec<L, U, Q>(y) * a);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_mix_scalar<L, T, bool, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, bool const& a)
+		{
+			return a ? y : x;
+		}
+	};
+
+	template<typename T, typename U>
+	struct compute_mix
+	{
+		GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, U const& a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return static_cast<T>(static_cast<U>(x) * (static_cast<U>(1) - a) + static_cast<U>(y) * a);
+		}
+	};
+
+	template<typename T>
+	struct compute_mix<T, bool>
+	{
+		GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, bool const& a)
+		{
+			return a ? y : x;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned>
+	struct compute_sign
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return vec<L, T, Q>(glm::lessThan(vec<L, T, Q>(0), x)) - vec<L, T, Q>(glm::lessThan(x, vec<L, T, Q>(0)));
+		}
+	};
+
+#	if GLM_ARCH == GLM_ARCH_X86
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_sign<L, T, Q, false, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
+			vec<L, T, Q> const y(vec<L, typename detail::make_unsigned<T>::type, Q>(-x) >> typename detail::make_unsigned<T>::type(Shift));
+
+			return (x >> Shift) | y;
+		}
+	};
+#	endif
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_floor
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(std::floor, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_ceil
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(std::ceil, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_fract
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return x - floor(x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_trunc
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(trunc, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_round
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(round, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_mod
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
+			return a - b * floor(a / b);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_min_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+		{
+			return detail::functor2<vec, L, T, Q>::call(min, x, y);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_max_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+		{
+			return detail::functor2<vec, L, T, Q>::call(max, x, y);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_clamp_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
+		{
+			return min(max(x, minVal), maxVal);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_step_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& edge, vec<L, T, Q> const& x)
+		{
+			return mix(vec<L, T, Q>(1), vec<L, T, Q>(0), glm::lessThan(x, edge));
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_smoothstep_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
+			vec<L, T, Q> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
+			return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
+		}
+	};
+}//namespace detail
+
+	template<typename genFIType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genFIType abs(genFIType x)
+	{
+		return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> abs(vec<L, T, Q> const& x)
+	{
+		return detail::compute_abs_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// sign
+	// fast and works for any type
+	template<typename genFIType>
+	GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
+			"'sign' only accept signed inputs");
+
+		return detail::compute_sign<1, genFIType, defaultp,
+                                    std::numeric_limits<genFIType>::is_iec559, detail::is_aligned<highp>::value>::call(vec<1, genFIType>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sign(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
+			"'sign' only accept signed inputs");
+
+		return detail::compute_sign<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// floor
+	using ::std::floor;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> floor(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'floor' only accept floating-point inputs.");
+		return detail::compute_floor<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> trunc(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'trunc' only accept floating-point inputs");
+		return detail::compute_trunc<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> round(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'round' only accept floating-point inputs");
+		return detail::compute_round<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+/*
+	// roundEven
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
+
+		return genType(int(x + genType(int(x) % 2)));
+	}
+*/
+
+	// roundEven
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType roundEven(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
+
+		int Integer = static_cast<int>(x);
+		genType IntegerPart = static_cast<genType>(Integer);
+		genType FractionalPart = fract(x);
+
+		if(FractionalPart > static_cast<genType>(0.5) || FractionalPart < static_cast<genType>(0.5))
+		{
+			return round(x);
+		}
+		else if((Integer % 2) == 0)
+		{
+			return IntegerPart;
+		}
+		else if(x <= static_cast<genType>(0)) // Work around...
+		{
+			return IntegerPart - static_cast<genType>(1);
+		}
+		else
+		{
+			return IntegerPart + static_cast<genType>(1);
+		}
+		//else // Bug on MinGW 4.5.2
+		//{
+		//	return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0));
+		//}
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> roundEven(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'roundEven' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(roundEven, x);
+	}
+
+	// ceil
+	using ::std::ceil;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> ceil(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ceil' only accept floating-point inputs");
+		return detail::compute_ceil<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// fract
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fract(genType x)
+	{
+		return fract(vec<1, genType>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fract(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fract' only accept floating-point inputs");
+		return detail::compute_fract<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// mod
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType mod(genType x, genType y)
+	{
+#		if GLM_COMPILER & GLM_COMPILER_CUDA
+			// Another Cuda compiler bug https://github.com/g-truc/glm/issues/530
+			vec<1, genType, defaultp> Result(mod(vec<1, genType, defaultp>(x), y));
+			return Result.x;
+#		else
+			return mod(vec<1, genType, defaultp>(x), y).x;
+#		endif
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mod(vec<L, T, Q> const& x, T y)
+	{
+		return detail::compute_mod<L, T, Q, detail::is_aligned<Q>::value>::call(x, vec<L, T, Q>(y));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mod(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		return detail::compute_mod<L, T, Q, detail::is_aligned<Q>::value>::call(x, y);
+	}
+
+	// modf
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType modf(genType x, genType & i)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'modf' only accept floating-point inputs");
+		return std::modf(x, &i);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<1, T, Q> modf(vec<1, T, Q> const& x, vec<1, T, Q> & i)
+	{
+		return vec<1, T, Q>(
+			modf(x.x, i.x));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> modf(vec<2, T, Q> const& x, vec<2, T, Q> & i)
+	{
+		return vec<2, T, Q>(
+			modf(x.x, i.x),
+			modf(x.y, i.y));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> modf(vec<3, T, Q> const& x, vec<3, T, Q> & i)
+	{
+		return vec<3, T, Q>(
+			modf(x.x, i.x),
+			modf(x.y, i.y),
+			modf(x.z, i.z));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> modf(vec<4, T, Q> const& x, vec<4, T, Q> & i)
+	{
+		return vec<4, T, Q>(
+			modf(x.x, i.x),
+			modf(x.y, i.y),
+			modf(x.z, i.z),
+			modf(x.w, i.w));
+	}
+
+	//// Only valid if (INT_MIN <= x-y <= INT_MAX)
+	//// min(x,y)
+	//r = y + ((x - y) & ((x - y) >> (sizeof(int) *
+	//CHAR_BIT - 1)));
+	//// max(x,y)
+	//r = x - ((x - y) & ((x - y) >> (sizeof(int) *
+	//CHAR_BIT - 1)));
+
+	// min
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, T b)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'min' only accept floating-point or integer inputs");
+		return detail::compute_min_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::compute_min_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, b);
+	}
+
+	// max
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& a, T b)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'max' only accept floating-point or integer inputs");
+		return detail::compute_max_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::compute_max_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, b);
+	}
+
+	// clamp
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'clamp' only accept floating-point or integer inputs");
+		return min(max(x, minVal), maxVal);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, T minVal, T maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+		return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, vec<L, T, Q>(minVal), vec<L, T, Q>(maxVal));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+		return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, minVal, maxVal);
+	}
+
+	template<typename genTypeT, typename genTypeU>
+	GLM_FUNC_QUALIFIER genTypeT mix(genTypeT x, genTypeT y, genTypeU a)
+	{
+		return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a);
+	}
+
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a)
+	{
+		return detail::compute_mix_scalar<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a);
+	}
+
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a)
+	{
+		return detail::compute_mix_vector<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a);
+	}
+
+	// step
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType step(genType edge, genType x)
+	{
+		return mix(static_cast<genType>(1), static_cast<genType>(0), x < edge);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> step(T edge, vec<L, T, Q> const& x)
+	{
+		return detail::compute_step_vector<L, T, Q, detail::is_aligned<Q>::value>::call(vec<L, T, Q>(edge), x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> step(vec<L, T, Q> const& edge, vec<L, T, Q> const& x)
+	{
+		return detail::compute_step_vector<L, T, Q, detail::is_aligned<Q>::value>::call(edge, x);
+	}
+
+	// smoothstep
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
+
+		genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1)));
+		return tmp * tmp * (genType(3) - genType(2) * tmp);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> smoothstep(T edge0, T edge1, vec<L, T, Q> const& x)
+	{
+		return detail::compute_smoothstep_vector<L, T, Q, detail::is_aligned<Q>::value>::call(vec<L, T, Q>(edge0), vec<L, T, Q>(edge1), x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> smoothstep(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x)
+	{
+		return detail::compute_smoothstep_vector<L, T, Q, detail::is_aligned<Q>::value>::call(edge0, edge1, x);
+	}
+
+#	if GLM_HAS_CXX11_STL
+		using std::isnan;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER bool isnan(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isnan' only accept floating-point inputs");
+
+#			if GLM_HAS_CXX11_STL
+				return std::isnan(x);
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+				return _isnan(x) != 0;
+#			elif GLM_COMPILER & GLM_COMPILER_INTEL
+#				if GLM_PLATFORM & GLM_PLATFORM_WINDOWS
+					return _isnan(x) != 0;
+#				else
+					return ::isnan(x) != 0;
+#				endif
+#			elif (GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) && (GLM_PLATFORM & GLM_PLATFORM_ANDROID) && __cplusplus < 201103L
+				return _isnan(x) != 0;
+#			elif GLM_COMPILER & GLM_COMPILER_CUDA
+				return ::isnan(x) != 0;
+#			else
+				return std::isnan(x);
+#			endif
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> isnan(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
+
+		vec<L, bool, Q> Result;
+		for (length_t l = 0; l < v.length(); ++l)
+			Result[l] = glm::isnan(v[l]);
+		return Result;
+	}
+
+#	if GLM_HAS_CXX11_STL
+		using std::isinf;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER bool isinf(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isinf' only accept floating-point inputs");
+
+#			if GLM_HAS_CXX11_STL
+				return std::isinf(x);
+#			elif GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)
+#				if(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
+					return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
+#				else
+					return ::isinf(x);
+#				endif
+#			elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)
+#				if(GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L)
+					return _isinf(x) != 0;
+#				else
+					return std::isinf(x);
+#				endif
+#			elif GLM_COMPILER & GLM_COMPILER_CUDA
+				// http://developer.download.nvidia.com/compute/cuda/4_2/rel/toolkit/docs/online/group__CUDA__MATH__DOUBLE_g13431dd2b40b51f9139cbb7f50c18fab.html#g13431dd2b40b51f9139cbb7f50c18fab
+				return ::isinf(double(x)) != 0;
+#			else
+				return std::isinf(x);
+#			endif
+	}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> isinf(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
+
+		vec<L, bool, Q> Result;
+		for (length_t l = 0; l < v.length(); ++l)
+			Result[l] = glm::isinf(v[l]);
+		return Result;
+	}
+
+	GLM_FUNC_QUALIFIER int floatBitsToInt(float const& v)
+	{
+		union
+		{
+			float in;
+			int out;
+		} u;
+
+		u.in = v;
+
+		return u.out;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> floatBitsToInt(vec<L, float, Q> const& v)
+	{
+		return reinterpret_cast<vec<L, int, Q>&>(const_cast<vec<L, float, Q>&>(v));
+	}
+
+	GLM_FUNC_QUALIFIER uint floatBitsToUint(float const& v)
+	{
+		union
+		{
+			float in;
+			uint out;
+		} u;
+
+		u.in = v;
+
+		return u.out;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, uint, Q> floatBitsToUint(vec<L, float, Q> const& v)
+	{
+		return reinterpret_cast<vec<L, uint, Q>&>(const_cast<vec<L, float, Q>&>(v));
+	}
+
+	GLM_FUNC_QUALIFIER float intBitsToFloat(int const& v)
+	{
+		union
+		{
+			int in;
+			float out;
+		} u;
+
+		u.in = v;
+
+		return u.out;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, float, Q> intBitsToFloat(vec<L, int, Q> const& v)
+	{
+		return reinterpret_cast<vec<L, float, Q>&>(const_cast<vec<L, int, Q>&>(v));
+	}
+
+	GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const& v)
+	{
+		union
+		{
+			uint in;
+			float out;
+		} u;
+
+		u.in = v;
+
+		return u.out;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, float, Q> uintBitsToFloat(vec<L, uint, Q> const& v)
+	{
+		return reinterpret_cast<vec<L, float, Q>&>(const_cast<vec<L, uint, Q>&>(v));
+	}
+
+#	if GLM_HAS_CXX11_STL
+		using std::fma;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType fma(genType const& a, genType const& b, genType const& c)
+		{
+			return a * b + c;
+		}
+#	endif
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType frexp(genType x, int& exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'frexp' only accept floating-point inputs");
+
+		return std::frexp(x, &exp);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> frexp(vec<L, T, Q> const& v, vec<L, int, Q>& exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+
+		vec<L, T, Q> Result;
+		for (length_t l = 0; l < v.length(); ++l)
+			Result[l] = std::frexp(v[l], &exp[l]);
+		return Result;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType ldexp(genType const& x, int const& exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+		return std::ldexp(x, exp);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> ldexp(vec<L, T, Q> const& v, vec<L, int, Q> const& exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+		vec<L, T, Q> Result;
+		for (length_t l = 0; l < v.length(); ++l)
+			Result[l] = std::ldexp(v[l], exp[l]);
+		return Result;
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_common_simd.inl"
+#endif

third_party/glm/detail/func_common_simd.inl

@@ -0,0 +1,231 @@
+/// @ref core
+/// @file glm/detail/func_common_simd.inl
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#include "../simd/common.h"
+
+#include <immintrin.h>
+
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_abs_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_abs(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_abs_vector<4, int, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v)
+		{
+			vec<4, int, Q> result;
+			result.data = glm_ivec4_abs(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_floor<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_floor(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_ceil<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_ceil(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_fract<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_fract(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_round<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_round(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_mod<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_mod(x.data, y.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_min_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			vec<4, float, Q> result;
+			result.data = _mm_min_ps(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_min_vector<4, int, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			vec<4, int, Q> result;
+			result.data = _mm_min_epi32(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_min_vector<4, uint, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+		{
+			vec<4, uint, Q> result;
+			result.data = _mm_min_epu32(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_max_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			vec<4, float, Q> result;
+			result.data = _mm_max_ps(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_max_vector<4, int, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			vec<4, int, Q> result;
+			result.data = _mm_max_epi32(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_max_vector<4, uint, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+		{
+			vec<4, uint, Q> result;
+			result.data = _mm_max_epu32(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_clamp_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& minVal, vec<4, float, Q> const& maxVal)
+		{
+			vec<4, float, Q> result;
+			result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_clamp_vector<4, int, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& x, vec<4, int, Q> const& minVal, vec<4, int, Q> const& maxVal)
+		{
+			vec<4, int, Q> result;
+			result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_clamp_vector<4, uint, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& x, vec<4, uint, Q> const& minVal, vec<4, uint, Q> const& maxVal)
+		{
+			vec<4, uint, Q> result;
+			result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_mix_vector<4, float, bool, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y, vec<4, bool, Q> const& a)
+		{
+			__m128i const Load = _mm_set_epi32(-static_cast<int>(a.w), -static_cast<int>(a.z), -static_cast<int>(a.y), -static_cast<int>(a.x));
+			__m128 const Mask = _mm_castsi128_ps(Load);
+
+			vec<4, float, Q> Result;
+#			if 0 && GLM_ARCH & GLM_ARCH_AVX
+				Result.data = _mm_blendv_ps(x.data, y.data, Mask);
+#			else
+				Result.data = _mm_or_ps(_mm_and_ps(Mask, y.data), _mm_andnot_ps(Mask, x.data));
+#			endif
+			return Result;
+		}
+	};
+/* FIXME
+	template<qualifier Q>
+	struct compute_step_vector<float, Q, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge, vec<4, float, Q> const& x)
+		{
+			vec<4, float, Q> Result;
+			result.data = glm_vec4_step(edge.data, x.data);
+			return result;
+		}
+	};
+*/
+	template<qualifier Q>
+	struct compute_smoothstep_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge0, vec<4, float, Q> const& edge1, vec<4, float, Q> const& x)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data);
+			return Result;
+		}
+	};
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

third_party/glm/detail/func_exponential.inl

@@ -0,0 +1,152 @@
+/// @ref core
+/// @file glm/detail/func_exponential.inl
+
+#include "../vector_relational.hpp"
+#include "_vectorize.hpp"
+#include <limits>
+#include <cmath>
+#include <cassert>
+
+namespace glm{
+namespace detail
+{
+#	if GLM_HAS_CXX11_STL
+		using std::log2;
+#	else
+		template<typename genType>
+		genType log2(genType Value)
+		{
+			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned>
+	struct compute_log2
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'log2' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
+
+			return detail::functor1<vec, L, T, T, Q>::call(log2, v);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_sqrt
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(std::sqrt, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_inversesqrt
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return static_cast<T>(1) / sqrt(x);
+		}
+	};
+
+	template<length_t L, bool Aligned>
+	struct compute_inversesqrt<L, float, lowp, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, float, lowp> call(vec<L, float, lowp> const& x)
+		{
+			vec<L, float, lowp> tmp(x);
+			vec<L, float, lowp> xhalf(tmp * 0.5f);
+			vec<L, uint, lowp>* p = reinterpret_cast<vec<L, uint, lowp>*>(const_cast<vec<L, float, lowp>*>(&x));
+			vec<L, uint, lowp> i = vec<L, uint, lowp>(0x5f375a86) - (*p >> vec<L, uint, lowp>(1));
+			vec<L, float, lowp>* ptmp = reinterpret_cast<vec<L, float, lowp>*>(&i);
+			tmp = *ptmp;
+			tmp = tmp * (1.5f - xhalf * tmp * tmp);
+			return tmp;
+		}
+	};
+}//namespace detail
+
+	// pow
+	using std::pow;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> pow(vec<L, T, Q> const& base, vec<L, T, Q> const& exponent)
+	{
+		return detail::functor2<vec, L, T, Q>::call(pow, base, exponent);
+	}
+
+	// exp
+	using std::exp;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> exp(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(exp, x);
+	}
+
+	// log
+	using std::log;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> log(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(log, x);
+	}
+
+#   if GLM_HAS_CXX11_STL
+    using std::exp2;
+#   else
+	//exp2, ln2 = 0.69314718055994530941723212145818f
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType exp2(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
+
+		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
+	}
+#   endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> exp2(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(exp2, x);
+	}
+
+	// log2, ln2 = 0.69314718055994530941723212145818f
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType log2(genType x)
+	{
+		return log2(vec<1, genType>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> log2(vec<L, T, Q> const& x)
+	{
+		return detail::compute_log2<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// sqrt
+	using std::sqrt;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sqrt(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
+		return detail::compute_sqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// inversesqrt
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
+	{
+		return static_cast<genType>(1) / sqrt(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> inversesqrt(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
+		return detail::compute_inversesqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_exponential_simd.inl"
+#endif
+

third_party/glm/detail/func_exponential_simd.inl

@@ -0,0 +1,37 @@
+/// @ref core
+/// @file glm/detail/func_exponential_simd.inl
+
+#include "../simd/exponential.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_sqrt<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_sqrt_ps(v.data);
+			return Result;
+		}
+	};
+
+#	if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+	template<>
+	struct compute_sqrt<4, float, aligned_lowp, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v)
+		{
+			vec<4, float, aligned_lowp> Result;
+			Result.data = glm_vec4_sqrt_lowp(v.data);
+			return Result;
+		}
+	};
+#	endif
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

third_party/glm/detail/func_geometric.inl

@@ -0,0 +1,243 @@
+#include "../exponential.hpp"
+#include "../common.hpp"
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_length
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<L, T, Q> const& v)
+		{
+			return sqrt(dot(v, v));
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_distance
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1)
+		{
+			return length(p1 - p0);
+		}
+	};
+
+	template<typename V, typename T, bool Aligned>
+	struct compute_dot{};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<vec<1, T, Q>, T, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<1, T, Q> const& a, vec<1, T, Q> const& b)
+		{
+			return a.x * b.x;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<vec<2, T, Q>, T, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& a, vec<2, T, Q> const& b)
+		{
+			vec<2, T, Q> tmp(a * b);
+			return tmp.x + tmp.y;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<vec<3, T, Q>, T, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<3, T, Q> const& a, vec<3, T, Q> const& b)
+		{
+			vec<3, T, Q> tmp(a * b);
+			return tmp.x + tmp.y + tmp.z;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<vec<4, T, Q>, T, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> tmp(a * b);
+			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_cross
+	{
+		GLM_FUNC_QUALIFIER static vec<3, T, Q> call(vec<3, T, Q> const& x, vec<3, T, Q> const& y)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs");
+
+			return vec<3, T, Q>(
+				x.y * y.z - y.y * x.z,
+				x.z * y.x - y.z * x.x,
+				x.x * y.y - y.x * x.y);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_normalize
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+			return v * inversesqrt(dot(v, v));
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_faceforward
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& N, vec<L, T, Q> const& I, vec<L, T, Q> const& Nref)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+			return dot(Nref, I) < static_cast<T>(0) ? N : -N;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_reflect
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& I, vec<L, T, Q> const& N)
+		{
+			return I - N * dot(N, I) * static_cast<T>(2);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_refract
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& I, vec<L, T, Q> const& N, T eta)
+		{
+			T const dotValue(dot(N, I));
+			T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
+			vec<L, T, Q> const Result =
+                (k >= static_cast<T>(0)) ? (eta * I - (eta * dotValue + std::sqrt(k)) * N) : vec<L, T, Q>(0);
+			return Result;
+		}
+	};
+}//namespace detail
+
+	// length
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType length(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' accepts only floating-point inputs");
+
+		return abs(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T length(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' accepts only floating-point inputs");
+
+		return detail::compute_length<L, T, Q, detail::is_aligned<Q>::value>::call(v);
+	}
+
+	// distance
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType distance(genType const& p0, genType const& p1)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' accepts only floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T distance(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1)
+	{
+		return detail::compute_distance<L, T, Q, detail::is_aligned<Q>::value>::call(p0, p1);
+	}
+
+	// dot
+	template<typename T>
+	GLM_FUNC_QUALIFIER T dot(T x, T y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
+		return x * y;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T dot(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
+		return detail::compute_dot<vec<L, T, Q>, T, detail::is_aligned<Q>::value>::call(x, y);
+	}
+
+	// cross
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y)
+	{
+		return detail::compute_cross<T, Q, detail::is_aligned<Q>::value>::call(x, y);
+	}
+/*
+	// normalize
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType normalize(genType const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+		return x < genType(0) ? genType(-1) : genType(1);
+	}
+*/
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> normalize(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+		return detail::compute_normalize<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// faceforward
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType faceforward(genType const& N, genType const& I, genType const& Nref)
+	{
+		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> faceforward(vec<L, T, Q> const& N, vec<L, T, Q> const& I, vec<L, T, Q> const& Nref)
+	{
+		return detail::compute_faceforward<L, T, Q, detail::is_aligned<Q>::value>::call(N, I, Nref);
+	}
+
+	// reflect
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType reflect(genType const& I, genType const& N)
+	{
+		return I - N * dot(N, I) * genType(2);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> reflect(vec<L, T, Q> const& I, vec<L, T, Q> const& N)
+	{
+		return detail::compute_reflect<L, T, Q, detail::is_aligned<Q>::value>::call(I, N);
+	}
+
+	// refract
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType refract(genType const& I, genType const& N, genType eta)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' accepts only floating-point inputs");
+		genType const dotValue(dot(N, I));
+		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
+		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> refract(vec<L, T, Q> const& I, vec<L, T, Q> const& N, T eta)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' accepts only floating-point inputs");
+		return detail::compute_refract<L, T, Q, detail::is_aligned<Q>::value>::call(I, N, eta);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_geometric_simd.inl"
+#endif

third_party/glm/detail/func_geometric_simd.inl

@@ -0,0 +1,165 @@
+/// @ref core
+/// @file glm/detail/func_geometric_simd.inl
+
+#include "../simd/geometric.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_length<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v)
+		{
+			return _mm_cvtss_f32(glm_vec4_length(v.data));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_distance<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1)
+		{
+			return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_dot<vec<4, float, Q>, float, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
+		{
+			return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_cross<float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<3, float, Q> const& a, vec<3, float, Q> const& b)
+		{
+			__m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x);
+			__m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x);
+			__m128 const xpd0 = glm_vec4_cross(set0, set1);
+
+			vec<4, float, Q> Result;
+			Result.data = xpd0;
+			return vec<3, float, Q>(Result);
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_normalize<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_normalize(v.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_faceforward<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& N, vec<4, float, Q> const& I, vec<4, float, Q> const& Nref)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_faceforward(N.data, I.data, Nref.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_reflect<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_reflect(I.data, N.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_refract<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N, float eta)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta));
+			return Result;
+		}
+	};
+}//namespace detail
+}//namespace glm
+
+#elif GLM_ARCH & GLM_ARCH_NEON_BIT
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_length<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v)
+		{
+			return compute_dot<vec<4, float, Q>, float, true>::call(v, v);
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_distance<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1)
+		{
+			return compute_length<4, float, Q, true>::call(p1 - p0);
+		}
+	};
+
+
+	template<qualifier Q>
+	struct compute_dot<vec<4, float, Q>, float, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
+		{
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+			float32x4_t v = vmulq_f32(x.data, y.data);
+			v = vpaddq_f32(v, v);
+			v = vpaddq_f32(v, v);
+			return vgetq_lane_f32(v, 0);
+#else  // Armv7a with Neon
+			float32x4_t p = vmulq_f32(x.data, y.data);
+			float32x2_t v = vpadd_f32(vget_low_f32(p), vget_high_f32(p));
+			v = vpadd_f32(v, v);
+			return vget_lane_f32(v, 0);
+#endif
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_normalize<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			float32x4_t p = vmulq_f32(v.data, v.data);
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+			p = vpaddq_f32(p, p);
+			p = vpaddq_f32(p, p);
+#else
+			float32x2_t t = vpadd_f32(vget_low_f32(p), vget_high_f32(p));
+			t = vpadd_f32(t, t);
+			p = vcombine_f32(t, t);
+#endif
+
+			float32x4_t vd = vrsqrteq_f32(p);
+			vec<4, float, Q> Result;
+			Result.data = vmulq_f32(v.data, vd);
+			return Result;
+		}
+	};
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

third_party/glm/detail/func_integer.inl

@@ -0,0 +1,372 @@
+/// @ref core
+
+#include "_vectorize.hpp"
+#if(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC)
+#	include <intrin.h>
+#	pragma intrinsic(_BitScanReverse)
+#endif//(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC)
+#include <limits>
+
+#if !GLM_HAS_EXTENDED_INTEGER_TYPE
+#	if GLM_COMPILER & GLM_COMPILER_GCC
+#		pragma GCC diagnostic ignored "-Wlong-long"
+#	endif
+#	if (GLM_COMPILER & GLM_COMPILER_CLANG)
+#		pragma clang diagnostic ignored "-Wc++11-long-long"
+#	endif
+#endif
+
+namespace glm{
+namespace detail
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER T mask(T Bits)
+	{
+		return Bits >= static_cast<T>(sizeof(T) * 8) ? ~static_cast<T>(0) : (static_cast<T>(1) << Bits) - static_cast<T>(1);
+	}
+
+	template<length_t L, typename T, qualifier Q, bool Aligned, bool EXEC>
+	struct compute_bitfieldReverseStep
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_bitfieldReverseStep<L, T, Q, Aligned, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T Mask, T Shift)
+		{
+			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned, bool EXEC>
+	struct compute_bitfieldBitCountStep
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_bitfieldBitCountStep<L, T, Q, Aligned, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T Mask, T Shift)
+		{
+			return (v & Mask) + ((v >> Shift) & Mask);
+		}
+	};
+
+	template<typename genIUType, size_t Bits>
+	struct compute_findLSB
+	{
+		GLM_FUNC_QUALIFIER static int call(genIUType Value)
+		{
+			if(Value == 0)
+				return -1;
+
+			return glm::bitCount(~Value & (Value - static_cast<genIUType>(1)));
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template<typename genIUType>
+		struct compute_findLSB<genIUType, 32>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward(&Result, *reinterpret_cast<unsigned long*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template<typename genIUType>
+		struct compute_findLSB<genIUType, 64>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+
+	template<length_t L, typename T, qualifier Q, bool EXEC = true>
+	struct compute_findMSB_step_vec
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, T Shift)
+		{
+			return x | (x >> Shift);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct compute_findMSB_step_vec<L, T, Q, false>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, T)
+		{
+			return x;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, int>
+	struct compute_findMSB_vec
+	{
+		GLM_FUNC_QUALIFIER static vec<L, int, Q> call(vec<L, T, Q> const& v)
+		{
+			vec<L, T, Q> x(v);
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 1));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 2));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 4));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 16>::call(x, static_cast<T>( 8));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 32>::call(x, static_cast<T>(16));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 64>::call(x, static_cast<T>(32));
+			return vec<L, int, Q>(sizeof(T) * 8 - 1) - glm::bitCount(~x);
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template<typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_32(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse(&Result, *reinterpret_cast<unsigned long*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template<length_t L, typename T, qualifier Q>
+		struct compute_findMSB_vec<L, T, Q, 32>
+		{
+			GLM_FUNC_QUALIFIER static vec<L, int, Q> call(vec<L, T, Q> const& x)
+			{
+				return detail::functor1<vec, L, int, T, Q>::call(compute_findMSB_32, x);
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template<typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_64(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template<length_t L, typename T, qualifier Q>
+		struct compute_findMSB_vec<L, T, Q, 64>
+		{
+			GLM_FUNC_QUALIFIER static vec<L, int, Q> call(vec<L, T, Q> const& x)
+			{
+				return detail::functor1<vec, L, int, T, Q>::call(compute_findMSB_64, x);
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+}//namespace detail
+
+	// uaddCarry
+	GLM_FUNC_QUALIFIER uint uaddCarry(uint const& x, uint const& y, uint & Carry)
+	{
+		detail::uint64 const Value64(static_cast<detail::uint64>(x) + static_cast<detail::uint64>(y));
+		detail::uint64 const Max32((static_cast<detail::uint64>(1) << static_cast<detail::uint64>(32)) - static_cast<detail::uint64>(1));
+		Carry = Value64 > Max32 ? 1u : 0u;
+		return static_cast<uint>(Value64 % (Max32 + static_cast<detail::uint64>(1)));
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, uint, Q> uaddCarry(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& Carry)
+	{
+		vec<L, detail::uint64, Q> Value64(vec<L, detail::uint64, Q>(x) + vec<L, detail::uint64, Q>(y));
+		vec<L, detail::uint64, Q> Max32((static_cast<detail::uint64>(1) << static_cast<detail::uint64>(32)) - static_cast<detail::uint64>(1));
+		Carry = mix(vec<L, uint, Q>(0), vec<L, uint, Q>(1), greaterThan(Value64, Max32));
+		return vec<L, uint, Q>(Value64 % (Max32 + static_cast<detail::uint64>(1)));
+	}
+
+	// usubBorrow
+	GLM_FUNC_QUALIFIER uint usubBorrow(uint const& x, uint const& y, uint & Borrow)
+	{
+		Borrow = x >= y ? static_cast<uint>(0) : static_cast<uint>(1);
+		if(y >= x)
+			return y - x;
+		else
+			return static_cast<uint>((static_cast<detail::int64>(1) << static_cast<detail::int64>(32)) + (static_cast<detail::int64>(y) - static_cast<detail::int64>(x)));
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, uint, Q> usubBorrow(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& Borrow)
+	{
+		Borrow = mix(vec<L, uint, Q>(1), vec<L, uint, Q>(0), greaterThanEqual(x, y));
+		vec<L, uint, Q> const YgeX(y - x);
+		vec<L, uint, Q> const XgeY(vec<L, uint, Q>((static_cast<detail::int64>(1) << static_cast<detail::int64>(32)) + (vec<L, detail::int64, Q>(y) - vec<L, detail::int64, Q>(x))));
+		return mix(XgeY, YgeX, greaterThanEqual(y, x));
+	}
+
+	// umulExtended
+	GLM_FUNC_QUALIFIER void umulExtended(uint const& x, uint const& y, uint & msb, uint & lsb)
+	{
+		detail::uint64 Value64 = static_cast<detail::uint64>(x) * static_cast<detail::uint64>(y);
+		msb = static_cast<uint>(Value64 >> static_cast<detail::uint64>(32));
+		lsb = static_cast<uint>(Value64);
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER void umulExtended(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& msb, vec<L, uint, Q>& lsb)
+	{
+		vec<L, detail::uint64, Q> Value64(vec<L, detail::uint64, Q>(x) * vec<L, detail::uint64, Q>(y));
+		msb = vec<L, uint, Q>(Value64 >> static_cast<detail::uint64>(32));
+		lsb = vec<L, uint, Q>(Value64);
+	}
+
+	// imulExtended
+	GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int& msb, int& lsb)
+	{
+		detail::int64 Value64 = static_cast<detail::int64>(x) * static_cast<detail::int64>(y);
+		msb = static_cast<int>(Value64 >> static_cast<detail::int64>(32));
+		lsb = static_cast<int>(Value64);
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER void imulExtended(vec<L, int, Q> const& x, vec<L, int, Q> const& y, vec<L, int, Q>& msb, vec<L, int, Q>& lsb)
+	{
+		vec<L, detail::int64, Q> Value64(vec<L, detail::int64, Q>(x) * vec<L, detail::int64, Q>(y));
+		lsb = vec<L, int, Q>(Value64 & static_cast<detail::int64>(0xFFFFFFFF));
+		msb = vec<L, int, Q>((Value64 >> static_cast<detail::int64>(32)) & static_cast<detail::int64>(0xFFFFFFFF));
+	}
+
+	// bitfieldExtract
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldExtract(genIUType Value, int Offset, int Bits)
+	{
+		return bitfieldExtract(vec<1, genIUType>(Value), Offset, Bits).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldExtract(vec<L, T, Q> const& Value, int Offset, int Bits)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldExtract' only accept integer inputs");
+
+		return (Value >> static_cast<T>(Offset)) & static_cast<T>(detail::mask(Bits));
+	}
+
+	// bitfieldInsert
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const& Base, genIUType const& Insert, int Offset, int Bits)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
+
+		return bitfieldInsert(vec<1, genIUType>(Base), vec<1, genIUType>(Insert), Offset, Bits).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldInsert(vec<L, T, Q> const& Base, vec<L, T, Q> const& Insert, int Offset, int Bits)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldInsert' only accept integer values");
+
+		T const Mask = static_cast<T>(detail::mask(Bits) << Offset);
+		return (Base & ~Mask) | ((Insert << static_cast<T>(Offset)) & Mask);
+	}
+
+	// bitfieldReverse
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
+
+		return bitfieldReverse(glm::vec<1, genIUType, glm::defaultp>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldReverse(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldReverse' only accept integer values");
+
+		vec<L, T, Q> x(v);
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  2>::call(x, static_cast<T>(0x5555555555555555ull), static_cast<T>( 1));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  4>::call(x, static_cast<T>(0x3333333333333333ull), static_cast<T>( 2));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  8>::call(x, static_cast<T>(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 16>::call(x, static_cast<T>(0x00FF00FF00FF00FFull), static_cast<T>( 8));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 32>::call(x, static_cast<T>(0x0000FFFF0000FFFFull), static_cast<T>(16));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 64>::call(x, static_cast<T>(0x00000000FFFFFFFFull), static_cast<T>(32));
+		return x;
+	}
+
+	// bitCount
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER int bitCount(genIUType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
+
+		return bitCount(glm::vec<1, genIUType, glm::defaultp>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> bitCount(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitCount' only accept integer values");
+
+#		if GLM_COMPILER & GLM_COMPILER_VC
+#			pragma warning(push)
+#			pragma warning(disable : 4310) //cast truncates constant value
+#		endif
+
+		vec<L, typename detail::make_unsigned<T>::type, Q> x(*reinterpret_cast<vec<L, typename detail::make_unsigned<T>::type, Q> const *>(&v));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  4>::call(x, typename detail::make_unsigned<T>::type(0x3333333333333333ull), typename detail::make_unsigned<T>::type( 2));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  8>::call(x, typename detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned<T>::type( 4));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 16>::call(x, typename detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned<T>::type( 8));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
+		return vec<L, int, Q>(x);
+
+#		if GLM_COMPILER & GLM_COMPILER_VC
+#			pragma warning(pop)
+#		endif
+	}
+
+	// findLSB
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER int findLSB(genIUType Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+
+		return detail::compute_findLSB<genIUType, sizeof(genIUType) * 8>::call(Value);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> findLSB(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findLSB' only accept integer values");
+
+		return detail::functor1<vec, L, int, T, Q>::call(findLSB, x);
+	}
+
+	// findMSB
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER int findMSB(genIUType v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+
+		return findMSB(vec<1, genIUType>(v)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> findMSB(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findMSB' only accept integer values");
+
+		return detail::compute_findMSB_vec<L, T, Q, sizeof(T) * 8>::call(v);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_integer_simd.inl"
+#endif
+

third_party/glm/detail/func_integer_simd.inl

@@ -0,0 +1,65 @@
+#include "../simd/integer.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_bitfieldReverseStep<4, uint, Q, true, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v, uint Mask, uint Shift)
+		{
+			__m128i const set0 = v.data;
+
+			__m128i const set1 = _mm_set1_epi32(static_cast<int>(Mask));
+			__m128i const and1 = _mm_and_si128(set0, set1);
+			__m128i const sft1 = _mm_slli_epi32(and1, Shift);
+
+			__m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1));
+			__m128i const and2 = _mm_and_si128(set0, set2);
+			__m128i const sft2 = _mm_srai_epi32(and2, Shift);
+
+			__m128i const or0 = _mm_or_si128(sft1, sft2);
+
+			return or0;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_bitfieldBitCountStep<4, uint, Q, true, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v, uint Mask, uint Shift)
+		{
+			__m128i const set0 = v.data;
+
+			__m128i const set1 = _mm_set1_epi32(static_cast<int>(Mask));
+			__m128i const and0 = _mm_and_si128(set0, set1);
+			__m128i const sft0 = _mm_slli_epi32(set0, Shift);
+			__m128i const and1 = _mm_and_si128(sft0, set1);
+			__m128i const add0 = _mm_add_epi32(and0, and1);
+
+			return add0;
+		}
+	};
+}//namespace detail
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<>
+	GLM_FUNC_QUALIFIER int bitCount(uint x)
+	{
+		return _mm_popcnt_u32(x);
+	}
+
+#	if(GLM_MODEL == GLM_MODEL_64)
+	template<>
+	GLM_FUNC_QUALIFIER int bitCount(detail::uint64 x)
+	{
+		return static_cast<int>(_mm_popcnt_u64(x));
+	}
+#	endif//GLM_MODEL
+#	endif//GLM_ARCH
+
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

third_party/glm/detail/func_matrix.inl

@@ -0,0 +1,398 @@
+#include "../geometric.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+	struct compute_matrixCompMult
+	{
+		GLM_FUNC_QUALIFIER static mat<C, R, T, Q> call(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y)
+		{
+			mat<C, R, T, Q> Result;
+			for(length_t i = 0; i < Result.length(); ++i)
+				Result[i] = x[i] * y[i];
+			return Result;
+		}
+	};
+
+	template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+	struct compute_transpose{};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<2, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m)
+		{
+			mat<2, 2, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<2, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<3, 2, T, Q> call(mat<2, 3, T, Q> const& m)
+		{
+			mat<3,2, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<2, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 2, T, Q> call(mat<2, 4, T, Q> const& m)
+		{
+			mat<4, 2, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[3][0] = m[0][3];
+			Result[3][1] = m[1][3];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<3, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<2, 3, T, Q> call(mat<3, 2, T, Q> const& m)
+		{
+			mat<2, 3, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<3, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m)
+		{
+			mat<3, 3, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[2][2] = m[2][2];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<3, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 3, T, Q> call(mat<3, 4, T, Q> const& m)
+		{
+			mat<4, 3, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[2][2] = m[2][2];
+			Result[3][0] = m[0][3];
+			Result[3][1] = m[1][3];
+			Result[3][2] = m[2][3];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<4, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<2, 4, T, Q> call(mat<4, 2, T, Q> const& m)
+		{
+			mat<2, 4, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[0][3] = m[3][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			Result[1][3] = m[3][1];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<4, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<3, 4, T, Q> call(mat<4, 3, T, Q> const& m)
+		{
+			mat<3, 4, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[0][3] = m[3][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			Result[1][3] = m[3][1];
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[2][2] = m[2][2];
+			Result[2][3] = m[3][2];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<4, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m)
+		{
+			mat<4, 4, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[0][3] = m[3][0];
+
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			Result[1][3] = m[3][1];
+
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[2][2] = m[2][2];
+			Result[2][3] = m[3][2];
+
+			Result[3][0] = m[0][3];
+			Result[3][1] = m[1][3];
+			Result[3][2] = m[2][3];
+			Result[3][3] = m[3][3];
+			return Result;
+		}
+	};
+
+	template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+	struct compute_determinant{};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_determinant<2, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(mat<2, 2, T, Q> const& m)
+		{
+			return m[0][0] * m[1][1] - m[1][0] * m[0][1];
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_determinant<3, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(mat<3, 3, T, Q> const& m)
+		{
+			return
+				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_determinant<4, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(mat<4, 4, T, Q> const& m)
+		{
+			T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+			vec<4, T, Q> DetCof(
+				+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+				- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+				+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+				- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+			return
+				m[0][0] * DetCof[0] + m[0][1] * DetCof[1] +
+				m[0][2] * DetCof[2] + m[0][3] * DetCof[3];
+		}
+	};
+
+	template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+	struct compute_inverse{};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_inverse<2, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m)
+		{
+			T OneOverDeterminant = static_cast<T>(1) / (
+				+ m[0][0] * m[1][1]
+				- m[1][0] * m[0][1]);
+
+			mat<2, 2, T, Q> Inverse(
+				+ m[1][1] * OneOverDeterminant,
+				- m[0][1] * OneOverDeterminant,
+				- m[1][0] * OneOverDeterminant,
+				+ m[0][0] * OneOverDeterminant);
+
+			return Inverse;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_inverse<3, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m)
+		{
+			T OneOverDeterminant = static_cast<T>(1) / (
+				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]));
+
+			mat<3, 3, T, Q> Inverse;
+			Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
+			Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
+			Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
+			Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant;
+			Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant;
+			Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant;
+			Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant;
+			Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant;
+			Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant;
+
+			return Inverse;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_inverse<4, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m)
+		{
+			T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+			T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+			T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+			T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+			T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+			T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+			T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+			T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+			T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+			T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+			T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+			T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+			vec<4, T, Q> Fac0(Coef00, Coef00, Coef02, Coef03);
+			vec<4, T, Q> Fac1(Coef04, Coef04, Coef06, Coef07);
+			vec<4, T, Q> Fac2(Coef08, Coef08, Coef10, Coef11);
+			vec<4, T, Q> Fac3(Coef12, Coef12, Coef14, Coef15);
+			vec<4, T, Q> Fac4(Coef16, Coef16, Coef18, Coef19);
+			vec<4, T, Q> Fac5(Coef20, Coef20, Coef22, Coef23);
+
+			vec<4, T, Q> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
+			vec<4, T, Q> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
+			vec<4, T, Q> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
+			vec<4, T, Q> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
+
+			vec<4, T, Q> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
+			vec<4, T, Q> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
+			vec<4, T, Q> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
+			vec<4, T, Q> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
+
+			vec<4, T, Q> SignA(+1, -1, +1, -1);
+			vec<4, T, Q> SignB(-1, +1, -1, +1);
+			mat<4, 4, T, Q> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
+
+			vec<4, T, Q> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
+
+			vec<4, T, Q> Dot0(m[0] * Row0);
+			T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w);
+
+			T OneOverDeterminant = static_cast<T>(1) / Dot1;
+
+			return Inverse * OneOverDeterminant;
+		}
+	};
+}//namespace detail
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<C, R, T, Q> matrixCompMult(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs");
+		return detail::compute_matrixCompMult<C, R, T, Q, detail::is_aligned<Q>::value>::call(x, y);
+	}
+
+	template<length_t DA, length_t DB, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<DA, DB, T, Q>::type outerProduct(vec<DA, T, Q> const& c, vec<DB, T, Q> const& r)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs");
+
+		typename detail::outerProduct_trait<DA, DB, T, Q>::type m;
+		for(length_t i = 0; i < m.length(); ++i)
+			m[i] = c * r[i];
+		return m;
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<C, R, T, Q>::transpose_type transpose(mat<C, R, T, Q> const& m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs");
+		return detail::compute_transpose<C, R, T, Q, detail::is_aligned<Q>::value>::call(m);
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T determinant(mat<C, R, T, Q> const& m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs");
+		return detail::compute_determinant<C, R, T, Q, detail::is_aligned<Q>::value>::call(m);
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<C, R, T, Q> inverse(mat<C, R, T, Q> const& m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs");
+		return detail::compute_inverse<C, R, T, Q, detail::is_aligned<Q>::value>::call(m);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_matrix_simd.inl"
+#endif
+

third_party/glm/detail/func_matrix_simd.inl

@@ -0,0 +1,249 @@
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#include "type_mat4x4.hpp"
+#include "../geometric.hpp"
+#include "../simd/matrix.h"
+#include <cstring>
+
+namespace glm{
+namespace detail
+{
+#	if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+	template<qualifier Q>
+	struct compute_matrixCompMult<4, 4, float, Q, true>
+	{
+		GLM_STATIC_ASSERT(detail::is_aligned<Q>::value, "Specialization requires aligned");
+
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& x, mat<4, 4, float, Q> const& y)
+		{
+			mat<4, 4, float, Q> Result;
+			glm_mat4_matrixCompMult(
+				*static_cast<glm_vec4 const (*)[4]>(&x[0].data),
+				*static_cast<glm_vec4 const (*)[4]>(&y[0].data),
+				*static_cast<glm_vec4(*)[4]>(&Result[0].data));
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_transpose<4, 4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m)
+		{
+			mat<4, 4, float, Q> Result;
+			glm_mat4_transpose(&m[0].data, &Result[0].data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_determinant<4, 4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(mat<4, 4, float, Q> const& m)
+		{
+			return _mm_cvtss_f32(glm_mat4_determinant(&m[0].data));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_inverse<4, 4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m)
+		{
+			mat<4, 4, float, Q> Result;
+			glm_mat4_inverse(&m[0].data, &Result[0].data);
+			return Result;
+		}
+	};
+}//namespace detail
+
+#	if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+	template<>
+	GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_lowp> outerProduct<4, 4, float, aligned_lowp>(vec<4, float, aligned_lowp> const& c, vec<4, float, aligned_lowp> const& r)
+	{
+		__m128 NativeResult[4];
+		glm_mat4_outerProduct(c.data, r.data, NativeResult);
+		mat<4, 4, float, aligned_lowp> Result;
+		std::memcpy(&Result[0], &NativeResult[0], sizeof(Result));
+		return Result;
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_mediump> outerProduct<4, 4, float, aligned_mediump>(vec<4, float, aligned_mediump> const& c, vec<4, float, aligned_mediump> const& r)
+	{
+		__m128 NativeResult[4];
+		glm_mat4_outerProduct(c.data, r.data, NativeResult);
+		mat<4, 4, float, aligned_mediump> Result;
+		std::memcpy(&Result[0], &NativeResult[0], sizeof(Result));
+		return Result;
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_highp> outerProduct<4, 4, float, aligned_highp>(vec<4, float, aligned_highp> const& c, vec<4, float, aligned_highp> const& r)
+	{
+		__m128 NativeResult[4];
+		glm_mat4_outerProduct(c.data, r.data, NativeResult);
+		mat<4, 4, float, aligned_highp> Result;
+		std::memcpy(&Result[0], &NativeResult[0], sizeof(Result));
+		return Result;
+	}
+#	endif
+}//namespace glm
+
+#elif GLM_ARCH & GLM_ARCH_NEON_BIT
+
+namespace glm {
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+	template <qualifier Q>
+	GLM_FUNC_QUALIFIER
+	typename std::enable_if<detail::is_aligned<Q>::value, mat<4, 4, float, Q>>::type
+	operator*(mat<4, 4, float, Q> const & m1, mat<4, 4, float, Q> const & m2)
+	{
+		auto MulRow = [&](int l) {
+			float32x4_t const SrcA = m2[l].data;
+
+			float32x4_t r = neon::mul_lane(m1[0].data, SrcA, 0);
+			r = neon::madd_lane(r, m1[1].data, SrcA, 1);
+			r = neon::madd_lane(r, m1[2].data, SrcA, 2);
+			r = neon::madd_lane(r, m1[3].data, SrcA, 3);
+
+			return r;
+		};
+
+		mat<4, 4, float, aligned_highp> Result;
+		Result[0].data = MulRow(0);
+		Result[1].data = MulRow(1);
+		Result[2].data = MulRow(2);
+		Result[3].data = MulRow(3);
+
+		return Result;
+	}
+#endif // CXX11
+
+	template<qualifier Q>
+	struct detail::compute_inverse<4, 4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m)
+		{
+			float32x4_t const& m0 = m[0].data;
+			float32x4_t const& m1 = m[1].data;
+			float32x4_t const& m2 = m[2].data;
+			float32x4_t const& m3 = m[3].data;
+
+			// m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			// m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			// m[1][2] * m[3][3] - m[3][2] * m[1][3];
+			// m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+			float32x4_t Fac0;
+			{
+				float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 2), neon::dup_lane(m1, 2));
+				float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 3), 3, m2, 3);
+				float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 2), 3, m2, 2);
+				float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 3), neon::dup_lane(m1, 3));
+				Fac0 = w0 * w1 -  w2 * w3;
+			}
+
+			// m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			// m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			// m[1][1] * m[3][3] - m[3][1] * m[1][3];
+			// m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+			float32x4_t Fac1;
+			{
+				float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 1), neon::dup_lane(m1, 1));
+				float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 3), 3, m2, 3);
+				float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 1), 3, m2, 1);
+				float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 3), neon::dup_lane(m1, 3));
+				Fac1 = w0 * w1 - w2 * w3;
+			}
+
+			// m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			// m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			// m[1][1] * m[3][2] - m[3][1] * m[1][2];
+			// m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+			float32x4_t Fac2;
+			{
+				float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 1), neon::dup_lane(m1, 1));
+				float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 2), 3, m2, 2);
+				float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 1), 3, m2, 1);
+				float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 2), neon::dup_lane(m1, 2));
+				Fac2 = w0 * w1 - w2 * w3;
+			}
+
+			// m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			// m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			// m[1][0] * m[3][3] - m[3][0] * m[1][3];
+			// m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+			float32x4_t Fac3;
+			{
+				float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 0), neon::dup_lane(m1, 0));
+				float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 3), 3, m2, 3);
+				float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 0), 3, m2, 0);
+				float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 3), neon::dup_lane(m1, 3));
+				Fac3 = w0 * w1 - w2 * w3;
+			}
+
+			// m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			// m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			// m[1][0] * m[3][2] - m[3][0] * m[1][2];
+			// m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+			float32x4_t Fac4;
+			{
+				float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 0), neon::dup_lane(m1, 0));
+				float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 2), 3, m2, 2);
+				float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 0), 3, m2, 0);
+				float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 2), neon::dup_lane(m1, 2));
+				Fac4 = w0 * w1 - w2 * w3;
+			}
+
+			// m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			// m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			// m[1][0] * m[3][1] - m[3][0] * m[1][1];
+			// m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+			float32x4_t Fac5;
+			{
+				float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 0), neon::dup_lane(m1, 0));
+				float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 1), 3, m2, 1);
+				float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 0), 3, m2, 0);
+				float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 1), neon::dup_lane(m1, 1));
+				Fac5 = w0 * w1 - w2 * w3;
+			}
+
+			float32x4_t Vec0 = neon::copy_lane(neon::dupq_lane(m0, 0), 0, m1, 0); // (m[1][0], m[0][0], m[0][0], m[0][0]);
+			float32x4_t Vec1 = neon::copy_lane(neon::dupq_lane(m0, 1), 0, m1, 1); // (m[1][1], m[0][1], m[0][1], m[0][1]);
+			float32x4_t Vec2 = neon::copy_lane(neon::dupq_lane(m0, 2), 0, m1, 2); // (m[1][2], m[0][2], m[0][2], m[0][2]);
+			float32x4_t Vec3 = neon::copy_lane(neon::dupq_lane(m0, 3), 0, m1, 3); // (m[1][3], m[0][3], m[0][3], m[0][3]);
+
+			float32x4_t Inv0 = Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2;
+			float32x4_t Inv1 = Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4;
+			float32x4_t Inv2 = Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5;
+			float32x4_t Inv3 = Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5;
+
+			float32x4_t r0 = float32x4_t{-1, +1, -1, +1} * Inv0;
+			float32x4_t r1 = float32x4_t{+1, -1, +1, -1} * Inv1;
+			float32x4_t r2 = float32x4_t{-1, +1, -1, +1} * Inv2;
+			float32x4_t r3 = float32x4_t{+1, -1, +1, -1} * Inv3;
+
+			float32x4_t det = neon::mul_lane(r0, m0, 0);
+			det = neon::madd_lane(det, r1, m0, 1);
+			det = neon::madd_lane(det, r2, m0, 2);
+			det = neon::madd_lane(det, r3, m0, 3);
+
+			float32x4_t rdet = vdupq_n_f32(1 / vgetq_lane_f32(det, 0));
+
+			mat<4, 4, float, Q> r;
+			r[0].data = vmulq_f32(r0, rdet);
+			r[1].data = vmulq_f32(r1, rdet);
+			r[2].data = vmulq_f32(r2, rdet);
+			r[3].data = vmulq_f32(r3, rdet);
+			return r;
+		}
+	};
+}//namespace glm
+#endif

third_party/glm/detail/func_packing.inl

@@ -0,0 +1,189 @@
+/// @ref core
+/// @file glm/detail/func_packing.inl
+
+#include "../common.hpp"
+#include "type_half.hpp"
+
+namespace glm
+{
+	GLM_FUNC_QUALIFIER uint packUnorm2x16(vec2 const& v)
+	{
+		union
+		{
+			unsigned short in[2];
+			uint out;
+		} u;
+
+		vec<2, unsigned short, defaultp> result(round(clamp(v, 0.0f, 1.0f) * 65535.0f));
+
+		u.in[0] = result[0];
+		u.in[1] = result[1];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint p)
+	{
+		union
+		{
+			uint in;
+			unsigned short out[2];
+		} u;
+
+		u.in = p;
+
+		return vec2(u.out[0], u.out[1]) * 1.5259021896696421759365224689097e-5f;
+	}
+
+	GLM_FUNC_QUALIFIER uint packSnorm2x16(vec2 const& v)
+	{
+		union
+		{
+			signed short in[2];
+			uint out;
+		} u;
+ 
+		vec<2, short, defaultp> result(round(clamp(v, -1.0f, 1.0f) * 32767.0f));
+
+		u.in[0] = result[0];
+		u.in[1] = result[1];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint p)
+	{
+		union
+		{
+			uint in;
+			signed short out[2];
+		} u;
+
+		u.in = p;
+
+		return clamp(vec2(u.out[0], u.out[1]) * 3.0518509475997192297128208258309e-5f, -1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER uint packUnorm4x8(vec4 const& v)
+	{
+		union
+		{
+			unsigned char in[4];
+			uint out;
+		} u;
+
+		vec<4, unsigned char, defaultp> result(round(clamp(v, 0.0f, 1.0f) * 255.0f));
+
+		u.in[0] = result[0];
+		u.in[1] = result[1];
+		u.in[2] = result[2];
+		u.in[3] = result[3];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint p)
+	{
+		union
+		{
+			uint in;
+			unsigned char out[4];
+		} u;
+
+		u.in = p;
+
+		return vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0039215686274509803921568627451f;
+	}
+
+	GLM_FUNC_QUALIFIER uint packSnorm4x8(vec4 const& v)
+	{
+		union
+		{
+			signed char in[4];
+			uint out;
+		} u;
+
+		vec<4, signed char, defaultp> result(round(clamp(v, -1.0f, 1.0f) * 127.0f));
+
+		u.in[0] = result[0];
+		u.in[1] = result[1];
+		u.in[2] = result[2];
+		u.in[3] = result[3];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint p)
+	{
+		union
+		{
+			uint in;
+			signed char out[4];
+		} u;
+
+		u.in = p;
+
+		return clamp(vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0078740157480315f, -1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER double packDouble2x32(uvec2 const& v)
+	{
+		union
+		{
+			uint   in[2];
+			double out;
+		} u;
+
+		u.in[0] = v[0];
+		u.in[1] = v[1];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double v)
+	{
+		union
+		{
+			double in;
+			uint   out[2];
+		} u;
+
+		u.in = v;
+
+		return uvec2(u.out[0], u.out[1]);
+	}
+
+	GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const& v)
+	{
+		union
+		{
+			signed short in[2];
+			uint out;
+		} u;
+
+		u.in[0] = detail::toFloat16(v.x);
+		u.in[1] = detail::toFloat16(v.y);
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint v)
+	{
+		union
+		{
+			uint in;
+			signed short out[2];
+		} u;
+
+		u.in = v;
+
+		return vec2(
+			detail::toFloat32(u.out[0]),
+			detail::toFloat32(u.out[1]));
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_packing_simd.inl"
+#endif
+

third_party/glm/detail/func_packing_simd.inl

@@ -0,0 +1,6 @@
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm

third_party/glm/detail/func_trigonometric.inl

@@ -0,0 +1,197 @@
+#include "_vectorize.hpp"
+#include <cmath>
+#include <limits>
+
+namespace glm
+{
+	// radians
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'radians' only accept floating-point input");
+
+		return degrees * static_cast<genType>(0.01745329251994329576923690768489);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> radians(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(radians, v);
+	}
+
+	// degrees
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'degrees' only accept floating-point input");
+
+		return radians * static_cast<genType>(57.295779513082320876798154814105);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> degrees(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(degrees, v);
+	}
+
+	// sin
+	using ::std::sin;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sin(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(sin, v);
+	}
+
+	// cos
+	using std::cos;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> cos(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(cos, v);
+	}
+
+	// tan
+	using std::tan;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> tan(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(tan, v);
+	}
+
+	// asin
+	using std::asin;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> asin(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(asin, v);
+	}
+
+	// acos
+	using std::acos;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acos(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(acos, v);
+	}
+
+	// atan
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType atan(genType y, genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");
+
+		return ::std::atan2(y, x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> atan(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::functor2<vec, L, T, Q>::call(::std::atan2, a, b);
+	}
+
+	using std::atan;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> atan(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(atan, v);
+	}
+
+	// sinh
+	using std::sinh;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sinh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(sinh, v);
+	}
+
+	// cosh
+	using std::cosh;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> cosh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(cosh, v);
+	}
+
+	// tanh
+	using std::tanh;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> tanh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(tanh, v);
+	}
+
+	// asinh
+#	if GLM_HAS_CXX11_STL
+		using std::asinh;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType asinh(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asinh' only accept floating-point input");
+
+			return (x < static_cast<genType>(0) ? static_cast<genType>(-1) : (x > static_cast<genType>(0) ? static_cast<genType>(1) : static_cast<genType>(0))) * log(std::abs(x) + sqrt(static_cast<genType>(1) + x * x));
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> asinh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(asinh, v);
+	}
+
+	// acosh
+#	if GLM_HAS_CXX11_STL
+		using std::acosh;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType acosh(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input");
+
+			if(x < static_cast<genType>(1))
+				return static_cast<genType>(0);
+			return log(x + sqrt(x * x - static_cast<genType>(1)));
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acosh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(acosh, v);
+	}
+
+	// atanh
+#	if GLM_HAS_CXX11_STL
+		using std::atanh;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType atanh(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input");
+
+			if(std::abs(x) >= static_cast<genType>(1))
+				return 0;
+			return static_cast<genType>(0.5) * log((static_cast<genType>(1) + x) / (static_cast<genType>(1) - x));
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> atanh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(atanh, v);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_trigonometric_simd.inl"
+#endif
+

third_party/glm/detail/func_vector_relational.inl

@@ -0,0 +1,87 @@
+namespace glm
+{
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> lessThan(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] < y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> lessThanEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] <= y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> greaterThan(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] > y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> greaterThanEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] >= y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] == y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] != y[i];
+		return Result;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool any(vec<L, bool, Q> const& v)
+	{
+		bool Result = false;
+		for(length_t i = 0; i < L; ++i)
+			Result = Result || v[i];
+		return Result;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool all(vec<L, bool, Q> const& v)
+	{
+		bool Result = true;
+		for(length_t i = 0; i < L; ++i)
+			Result = Result && v[i];
+		return Result;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> not_(vec<L, bool, Q> const& v)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = !v[i];
+		return Result;
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_vector_relational_simd.inl"
+#endif

third_party/glm/detail/func_vector_relational_simd.inl

@@ -0,0 +1,6 @@
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm

third_party/glm/detail/glm.cpp

@@ -0,0 +1,263 @@
+/// @ref core
+/// @file glm/glm.cpp
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#define GLM_ENABLE_EXPERIMENTAL
+#endif
+#include <glm/gtx/dual_quaternion.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/ext/scalar_int_sized.hpp>
+#include <glm/ext/scalar_uint_sized.hpp>
+#include <glm/glm.hpp>
+
+namespace glm
+{
+// tvec1 type explicit instantiation
+template struct vec<1, uint8, lowp>;
+template struct vec<1, uint16, lowp>;
+template struct vec<1, uint32, lowp>;
+template struct vec<1, uint64, lowp>;
+template struct vec<1, int8, lowp>;
+template struct vec<1, int16, lowp>;
+template struct vec<1, int32, lowp>;
+template struct vec<1, int64, lowp>;
+template struct vec<1, float32, lowp>;
+template struct vec<1, float64, lowp>;
+
+template struct vec<1, uint8, mediump>;
+template struct vec<1, uint16, mediump>;
+template struct vec<1, uint32, mediump>;
+template struct vec<1, uint64, mediump>;
+template struct vec<1, int8, mediump>;
+template struct vec<1, int16, mediump>;
+template struct vec<1, int32, mediump>;
+template struct vec<1, int64, mediump>;
+template struct vec<1, float32, mediump>;
+template struct vec<1, float64, mediump>;
+
+template struct vec<1, uint8, highp>;
+template struct vec<1, uint16, highp>;
+template struct vec<1, uint32, highp>;
+template struct vec<1, uint64, highp>;
+template struct vec<1, int8, highp>;
+template struct vec<1, int16, highp>;
+template struct vec<1, int32, highp>;
+template struct vec<1, int64, highp>;
+template struct vec<1, float32, highp>;
+template struct vec<1, float64, highp>;
+
+// tvec2 type explicit instantiation
+template struct vec<2, uint8, lowp>;
+template struct vec<2, uint16, lowp>;
+template struct vec<2, uint32, lowp>;
+template struct vec<2, uint64, lowp>;
+template struct vec<2, int8, lowp>;
+template struct vec<2, int16, lowp>;
+template struct vec<2, int32, lowp>;
+template struct vec<2, int64, lowp>;
+template struct vec<2, float32, lowp>;
+template struct vec<2, float64, lowp>;
+
+template struct vec<2, uint8, mediump>;
+template struct vec<2, uint16, mediump>;
+template struct vec<2, uint32, mediump>;
+template struct vec<2, uint64, mediump>;
+template struct vec<2, int8, mediump>;
+template struct vec<2, int16, mediump>;
+template struct vec<2, int32, mediump>;
+template struct vec<2, int64, mediump>;
+template struct vec<2, float32, mediump>;
+template struct vec<2, float64, mediump>;
+
+template struct vec<2, uint8, highp>;
+template struct vec<2, uint16, highp>;
+template struct vec<2, uint32, highp>;
+template struct vec<2, uint64, highp>;
+template struct vec<2, int8, highp>;
+template struct vec<2, int16, highp>;
+template struct vec<2, int32, highp>;
+template struct vec<2, int64, highp>;
+template struct vec<2, float32, highp>;
+template struct vec<2, float64, highp>;
+
+// tvec3 type explicit instantiation
+template struct vec<3, uint8, lowp>;
+template struct vec<3, uint16, lowp>;
+template struct vec<3, uint32, lowp>;
+template struct vec<3, uint64, lowp>;
+template struct vec<3, int8, lowp>;
+template struct vec<3, int16, lowp>;
+template struct vec<3, int32, lowp>;
+template struct vec<3, int64, lowp>;
+template struct vec<3, float32, lowp>;
+template struct vec<3, float64, lowp>;
+
+template struct vec<3, uint8, mediump>;
+template struct vec<3, uint16, mediump>;
+template struct vec<3, uint32, mediump>;
+template struct vec<3, uint64, mediump>;
+template struct vec<3, int8, mediump>;
+template struct vec<3, int16, mediump>;
+template struct vec<3, int32, mediump>;
+template struct vec<3, int64, mediump>;
+template struct vec<3, float32, mediump>;
+template struct vec<3, float64, mediump>;
+
+template struct vec<3, uint8, highp>;
+template struct vec<3, uint16, highp>;
+template struct vec<3, uint32, highp>;
+template struct vec<3, uint64, highp>;
+template struct vec<3, int8, highp>;
+template struct vec<3, int16, highp>;
+template struct vec<3, int32, highp>;
+template struct vec<3, int64, highp>;
+template struct vec<3, float32, highp>;
+template struct vec<3, float64, highp>;
+
+// tvec4 type explicit instantiation
+template struct vec<4, uint8, lowp>;
+template struct vec<4, uint16, lowp>;
+template struct vec<4, uint32, lowp>;
+template struct vec<4, uint64, lowp>;
+template struct vec<4, int8, lowp>;
+template struct vec<4, int16, lowp>;
+template struct vec<4, int32, lowp>;
+template struct vec<4, int64, lowp>;
+template struct vec<4, float32, lowp>;
+template struct vec<4, float64, lowp>;
+
+template struct vec<4, uint8, mediump>;
+template struct vec<4, uint16, mediump>;
+template struct vec<4, uint32, mediump>;
+template struct vec<4, uint64, mediump>;
+template struct vec<4, int8, mediump>;
+template struct vec<4, int16, mediump>;
+template struct vec<4, int32, mediump>;
+template struct vec<4, int64, mediump>;
+template struct vec<4, float32, mediump>;
+template struct vec<4, float64, mediump>;
+
+template struct vec<4, uint8, highp>;
+template struct vec<4, uint16, highp>;
+template struct vec<4, uint32, highp>;
+template struct vec<4, uint64, highp>;
+template struct vec<4, int8, highp>;
+template struct vec<4, int16, highp>;
+template struct vec<4, int32, highp>;
+template struct vec<4, int64, highp>;
+template struct vec<4, float32, highp>;
+template struct vec<4, float64, highp>;
+
+// tmat2x2 type explicit instantiation
+template struct mat<2, 2, float32, lowp>;
+template struct mat<2, 2, float64, lowp>;
+
+template struct mat<2, 2, float32, mediump>;
+template struct mat<2, 2, float64, mediump>;
+
+template struct mat<2, 2, float32, highp>;
+template struct mat<2, 2, float64, highp>;
+
+// tmat2x3 type explicit instantiation
+template struct mat<2, 3, float32, lowp>;
+template struct mat<2, 3, float64, lowp>;
+
+template struct mat<2, 3, float32, mediump>;
+template struct mat<2, 3, float64, mediump>;
+
+template struct mat<2, 3, float32, highp>;
+template struct mat<2, 3, float64, highp>;
+
+// tmat2x4 type explicit instantiation
+template struct mat<2, 4, float32, lowp>;
+template struct mat<2, 4, float64, lowp>;
+
+template struct mat<2, 4, float32, mediump>;
+template struct mat<2, 4, float64, mediump>;
+
+template struct mat<2, 4, float32, highp>;
+template struct mat<2, 4, float64, highp>;
+
+// tmat3x2 type explicit instantiation
+template struct mat<3, 2, float32, lowp>;
+template struct mat<3, 2, float64, lowp>;
+
+template struct mat<3, 2, float32, mediump>;
+template struct mat<3, 2, float64, mediump>;
+
+template struct mat<3, 2, float32, highp>;
+template struct mat<3, 2, float64, highp>;
+
+// tmat3x3 type explicit instantiation
+template struct mat<3, 3, float32, lowp>;
+template struct mat<3, 3, float64, lowp>;
+
+template struct mat<3, 3, float32, mediump>;
+template struct mat<3, 3, float64, mediump>;
+
+template struct mat<3, 3, float32, highp>;
+template struct mat<3, 3, float64, highp>;
+
+// tmat3x4 type explicit instantiation
+template struct mat<3, 4, float32, lowp>;
+template struct mat<3, 4, float64, lowp>;
+
+template struct mat<3, 4, float32, mediump>;
+template struct mat<3, 4, float64, mediump>;
+
+template struct mat<3, 4, float32, highp>;
+template struct mat<3, 4, float64, highp>;
+
+// tmat4x2 type explicit instantiation
+template struct mat<4, 2, float32, lowp>;
+template struct mat<4, 2, float64, lowp>;
+
+template struct mat<4, 2, float32, mediump>;
+template struct mat<4, 2, float64, mediump>;
+
+template struct mat<4, 2, float32, highp>;
+template struct mat<4, 2, float64, highp>;
+
+// tmat4x3 type explicit instantiation
+template struct mat<4, 3, float32, lowp>;
+template struct mat<4, 3, float64, lowp>;
+
+template struct mat<4, 3, float32, mediump>;
+template struct mat<4, 3, float64, mediump>;
+
+template struct mat<4, 3, float32, highp>;
+template struct mat<4, 3, float64, highp>;
+
+// tmat4x4 type explicit instantiation
+template struct mat<4, 4, float32, lowp>;
+template struct mat<4, 4, float64, lowp>;
+
+template struct mat<4, 4, float32, mediump>;
+template struct mat<4, 4, float64, mediump>;
+
+template struct mat<4, 4, float32, highp>;
+template struct mat<4, 4, float64, highp>;
+
+// tquat type explicit instantiation
+template struct qua<float32, lowp>;
+template struct qua<float64, lowp>;
+
+template struct qua<float32, mediump>;
+template struct qua<float64, mediump>;
+
+template struct qua<float32, highp>;
+template struct qua<float64, highp>;
+
+//tdualquat type explicit instantiation
+template struct tdualquat<float32, lowp>;
+template struct tdualquat<float64, lowp>;
+
+template struct tdualquat<float32, mediump>;
+template struct tdualquat<float64, mediump>;
+
+template struct tdualquat<float32, highp>;
+template struct tdualquat<float64, highp>;
+
+}//namespace glm
+

third_party/glm/detail/qualifier.hpp

@@ -0,0 +1,230 @@
+#pragma once
+
+#include "setup.hpp"
+
+namespace glm
+{
+	/// Qualify GLM types in term of alignment (packed, aligned) and precision in term of ULPs (lowp, mediump, highp)
+	enum qualifier
+	{
+		packed_highp, ///< Typed data is tightly packed in memory and operations are executed with high precision in term of ULPs
+		packed_mediump, ///< Typed data is tightly packed in memory  and operations are executed with medium precision in term of ULPs for higher performance
+		packed_lowp, ///< Typed data is tightly packed in memory  and operations are executed with low precision in term of ULPs to maximize performance
+
+#		if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+			aligned_highp, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs
+			aligned_mediump, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs for higher performance
+			aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance
+			aligned = aligned_highp, ///< By default aligned qualifier is also high precision
+#		endif
+
+		highp = packed_highp, ///< By default highp qualifier is also packed
+		mediump = packed_mediump, ///< By default mediump qualifier is also packed
+		lowp = packed_lowp, ///< By default lowp qualifier is also packed
+		packed = packed_highp, ///< By default packed qualifier is also high precision
+
+#		if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE && defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES)
+			defaultp = aligned_highp
+#		else
+			defaultp = highp
+#		endif
+	};
+
+	typedef qualifier precision;
+
+	template<length_t L, typename T, qualifier Q = defaultp> struct vec;
+	template<length_t C, length_t R, typename T, qualifier Q = defaultp> struct mat;
+	template<typename T, qualifier Q = defaultp> struct qua;
+
+#	if GLM_HAS_TEMPLATE_ALIASES
+		template <typename T, qualifier Q = defaultp> using tvec1 = vec<1, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tvec2 = vec<2, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tvec3 = vec<3, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tvec4 = vec<4, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat2x2 = mat<2, 2, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat2x3 = mat<2, 3, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat2x4 = mat<2, 4, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat3x2 = mat<3, 2, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat3x3 = mat<3, 3, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat3x4 = mat<3, 4, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat4x2 = mat<4, 2, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat4x3 = mat<4, 3, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat4x4 = mat<4, 4, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tquat = qua<T, Q>;
+#	endif
+
+namespace detail
+{
+	template<glm::qualifier P>
+	struct is_aligned
+	{
+		static const bool value = false;
+	};
+
+#	if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+		template<>
+		struct is_aligned<glm::aligned_lowp>
+		{
+			static const bool value = true;
+		};
+
+		template<>
+		struct is_aligned<glm::aligned_mediump>
+		{
+			static const bool value = true;
+		};
+
+		template<>
+		struct is_aligned<glm::aligned_highp>
+		{
+			static const bool value = true;
+		};
+#	endif
+
+	template<length_t L, typename T, bool is_aligned>
+	struct storage
+	{
+		typedef struct type {
+			T data[L];
+		} type;
+	};
+
+#	if GLM_HAS_ALIGNOF
+		template<length_t L, typename T>
+		struct storage<L, T, true>
+		{
+			typedef struct alignas(L * sizeof(T)) type {
+				T data[L];
+			} type;
+		};
+
+		template<typename T>
+		struct storage<3, T, true>
+		{
+			typedef struct alignas(4 * sizeof(T)) type {
+				T data[4];
+			} type;
+		};
+#	endif
+
+#	if GLM_ARCH & GLM_ARCH_SSE2_BIT
+	template<>
+	struct storage<4, float, true>
+	{
+		typedef glm_f32vec4 type;
+	};
+
+	template<>
+	struct storage<4, int, true>
+	{
+		typedef glm_i32vec4 type;
+	};
+
+	template<>
+	struct storage<4, unsigned int, true>
+	{
+		typedef glm_u32vec4 type;
+	};
+
+	template<>
+	struct storage<2, double, true>
+	{
+		typedef glm_f64vec2 type;
+	};
+
+	template<>
+	struct storage<2, detail::int64, true>
+	{
+		typedef glm_i64vec2 type;
+	};
+
+	template<>
+	struct storage<2, detail::uint64, true>
+	{
+		typedef glm_u64vec2 type;
+	};
+#	endif
+
+#	if (GLM_ARCH & GLM_ARCH_AVX_BIT)
+	template<>
+	struct storage<4, double, true>
+	{
+		typedef glm_f64vec4 type;
+	};
+#	endif
+
+#	if (GLM_ARCH & GLM_ARCH_AVX2_BIT)
+	template<>
+	struct storage<4, detail::int64, true>
+	{
+		typedef glm_i64vec4 type;
+	};
+
+	template<>
+	struct storage<4, detail::uint64, true>
+	{
+		typedef glm_u64vec4 type;
+	};
+#	endif
+
+#	if GLM_ARCH & GLM_ARCH_NEON_BIT
+	template<>
+	struct storage<4, float, true>
+	{
+		typedef glm_f32vec4 type;
+	};
+
+	template<>
+	struct storage<4, int, true>
+	{
+		typedef glm_i32vec4 type;
+	};
+
+	template<>
+	struct storage<4, unsigned int, true>
+	{
+		typedef glm_u32vec4 type;
+	};
+#	endif
+
+	enum genTypeEnum
+	{
+		GENTYPE_VEC,
+		GENTYPE_MAT,
+		GENTYPE_QUAT
+	};
+
+	template <typename genType>
+	struct genTypeTrait
+	{};
+
+	template <length_t C, length_t R, typename T>
+	struct genTypeTrait<mat<C, R, T> >
+	{
+		static const genTypeEnum GENTYPE = GENTYPE_MAT;
+	};
+
+	template<typename genType, genTypeEnum type>
+	struct init_gentype
+	{
+	};
+
+	template<typename genType>
+	struct init_gentype<genType, GENTYPE_QUAT>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
+		{
+			return genType(1, 0, 0, 0);
+		}
+	};
+
+	template<typename genType>
+	struct init_gentype<genType, GENTYPE_MAT>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
+		{
+			return genType(1);
+		}
+	};
+}//namespace detail
+}//namespace glm

third_party/glm/detail/type_float.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "setup.hpp"
+
+#if GLM_COMPILER == GLM_COMPILER_VC12
+#	pragma warning(push)
+#	pragma warning(disable: 4512) // assignment operator could not be generated
+#endif
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	union float_t
+	{};
+
+	// https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+	template <>
+	union float_t<float>
+	{
+		typedef int int_type;
+		typedef float float_type;
+
+		GLM_CONSTEXPR float_t(float_type Num = 0.0f) : f(Num) {}
+
+		GLM_CONSTEXPR float_t& operator=(float_t const& x)
+		{
+			f = x.f;
+			return *this;
+		}
+
+		// Portable extraction of components.
+		GLM_CONSTEXPR bool negative() const { return i < 0; }
+		GLM_CONSTEXPR int_type mantissa() const { return i & ((1 << 23) - 1); }
+		GLM_CONSTEXPR int_type exponent() const { return (i >> 23) & ((1 << 8) - 1); }
+
+		int_type i;
+		float_type f;
+	};
+
+	template <>
+	union float_t<double>
+	{
+		typedef detail::int64 int_type;
+		typedef double float_type;
+
+		GLM_CONSTEXPR float_t(float_type Num = static_cast<float_type>(0)) : f(Num) {}
+
+		GLM_CONSTEXPR float_t& operator=(float_t const& x)
+		{
+			f = x.f;
+			return *this;
+		}
+
+		// Portable extraction of components.
+		GLM_CONSTEXPR bool negative() const { return i < 0; }
+		GLM_CONSTEXPR int_type mantissa() const { return i & ((int_type(1) << 52) - 1); }
+		GLM_CONSTEXPR int_type exponent() const { return (i >> 52) & ((int_type(1) << 11) - 1); }
+
+		int_type i;
+		float_type f;
+	};
+}//namespace detail
+}//namespace glm
+
+#if GLM_COMPILER == GLM_COMPILER_VC12
+#	pragma warning(pop)
+#endif

third_party/glm/detail/type_half.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "setup.hpp"
+
+namespace glm{
+namespace detail
+{
+	typedef short hdata;
+
+	GLM_FUNC_DECL float toFloat32(hdata value);
+	GLM_FUNC_DECL hdata toFloat16(float const& value);
+
+}//namespace detail
+}//namespace glm
+
+#include "type_half.inl"

third_party/glm/detail/type_half.inl

@@ -0,0 +1,241 @@
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER float overflow()
+	{
+		volatile float f = 1e10;
+
+		for(int i = 0; i < 10; ++i)
+			f *= f; // this will overflow before the for loop terminates
+		return f;
+	}
+
+	union uif32
+	{
+		GLM_FUNC_QUALIFIER uif32() :
+			i(0)
+		{}
+
+		GLM_FUNC_QUALIFIER uif32(float f_) :
+			f(f_)
+		{}
+
+		GLM_FUNC_QUALIFIER uif32(unsigned int i_) :
+			i(i_)
+		{}
+
+		float f;
+		unsigned int i;
+	};
+
+	GLM_FUNC_QUALIFIER float toFloat32(hdata value)
+	{
+		int s = (value >> 15) & 0x00000001;
+		int e = (value >> 10) & 0x0000001f;
+		int m =  value        & 0x000003ff;
+
+		if(e == 0)
+		{
+			if(m == 0)
+			{
+				//
+				// Plus or minus zero
+				//
+
+				detail::uif32 result;
+				result.i = static_cast<unsigned int>(s << 31);
+				return result.f;
+			}
+			else
+			{
+				//
+				// Denormalized number -- renormalize it
+				//
+
+				while(!(m & 0x00000400))
+				{
+					m <<= 1;
+					e -=  1;
+				}
+
+				e += 1;
+				m &= ~0x00000400;
+			}
+		}
+		else if(e == 31)
+		{
+			if(m == 0)
+			{
+				//
+				// Positive or negative infinity
+				//
+
+				uif32 result;
+				result.i = static_cast<unsigned int>((s << 31) | 0x7f800000);
+				return result.f;
+			}
+			else
+			{
+				//
+				// Nan -- preserve sign and significand bits
+				//
+
+				uif32 result;
+				result.i = static_cast<unsigned int>((s << 31) | 0x7f800000 | (m << 13));
+				return result.f;
+			}
+		}
+
+		//
+		// Normalized number
+		//
+
+		e = e + (127 - 15);
+		m = m << 13;
+
+		//
+		// Assemble s, e and m.
+		//
+
+		uif32 Result;
+		Result.i = static_cast<unsigned int>((s << 31) | (e << 23) | m);
+		return Result.f;
+	}
+
+	GLM_FUNC_QUALIFIER hdata toFloat16(float const& f)
+	{
+		uif32 Entry;
+		Entry.f = f;
+		int i = static_cast<int>(Entry.i);
+
+		//
+		// Our floating point number, f, is represented by the bit
+		// pattern in integer i.  Disassemble that bit pattern into
+		// the sign, s, the exponent, e, and the significand, m.
+		// Shift s into the position where it will go in the
+		// resulting half number.
+		// Adjust e, accounting for the different exponent bias
+		// of float and half (127 versus 15).
+		//
+
+		int s =  (i >> 16) & 0x00008000;
+		int e = ((i >> 23) & 0x000000ff) - (127 - 15);
+		int m =   i        & 0x007fffff;
+
+		//
+		// Now reassemble s, e and m into a half:
+		//
+
+		if(e <= 0)
+		{
+			if(e < -10)
+			{
+				//
+				// E is less than -10.  The absolute value of f is
+				// less than half_MIN (f may be a small normalized
+				// float, a denormalized float or a zero).
+				//
+				// We convert f to a half zero.
+				//
+
+				return hdata(s);
+			}
+
+			//
+			// E is between -10 and 0.  F is a normalized float,
+			// whose magnitude is less than __half_NRM_MIN.
+			//
+			// We convert f to a denormalized half.
+			//
+
+			m = (m | 0x00800000) >> (1 - e);
+
+			//
+			// Round to nearest, round "0.5" up.
+			//
+			// Rounding may cause the significand to overflow and make
+			// our number normalized.  Because of the way a half's bits
+			// are laid out, we don't have to treat this case separately;
+			// the code below will handle it correctly.
+			//
+
+			if(m & 0x00001000)
+				m += 0x00002000;
+
+			//
+			// Assemble the half from s, e (zero) and m.
+			//
+
+			return hdata(s | (m >> 13));
+		}
+		else if(e == 0xff - (127 - 15))
+		{
+			if(m == 0)
+			{
+				//
+				// F is an infinity; convert f to a half
+				// infinity with the same sign as f.
+				//
+
+				return hdata(s | 0x7c00);
+			}
+			else
+			{
+				//
+				// F is a NAN; we produce a half NAN that preserves
+				// the sign bit and the 10 leftmost bits of the
+				// significand of f, with one exception: If the 10
+				// leftmost bits are all zero, the NAN would turn
+				// into an infinity, so we have to set at least one
+				// bit in the significand.
+				//
+
+				m >>= 13;
+
+				return hdata(s | 0x7c00 | m | (m == 0));
+			}
+		}
+		else
+		{
+			//
+			// E is greater than zero.  F is a normalized float.
+			// We try to convert f to a normalized half.
+			//
+
+			//
+			// Round to nearest, round "0.5" up
+			//
+
+			if(m &  0x00001000)
+			{
+				m += 0x00002000;
+
+				if(m & 0x00800000)
+				{
+					m =  0;     // overflow in significand,
+					e += 1;     // adjust exponent
+				}
+			}
+
+			//
+			// Handle exponent overflow
+			//
+
+			if (e > 30)
+			{
+				overflow();        // Cause a hardware floating point overflow;
+
+				return hdata(s | 0x7c00);
+				// if this returns, the half becomes an
+			}   // infinity with the same sign as f.
+
+			//
+			// Assemble the half from s, e and m.
+			//
+
+			return hdata(s | (e << 10) | (m >> 13));
+		}
+	}
+
+}//namespace detail
+}//namespace glm

third_party/glm/detail/type_mat2x2.hpp

@@ -0,0 +1,177 @@
+/// @ref core
+/// @file glm/detail/type_mat2x2.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<2, 2, T, Q>
+	{
+		typedef vec<2, T, Q> col_type;
+		typedef vec<2, T, Q> row_type;
+		typedef mat<2, 2, T, Q> type;
+		typedef mat<2, 2, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[2];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 2, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T const& x1, T const& y1,
+			T const& x2, T const& y2);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v1,
+			col_type const& v2);
+
+		// -- Conversions --
+
+		template<typename U, typename V, typename M, typename N>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			U const& x1, V const& y1,
+			M const& x2, N const& y2);
+
+		template<typename U, typename V>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<2, U, Q> const& v1,
+			vec<2, V, Q> const& v2);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator=(mat<2, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(mat<2, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(mat<2, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(mat<2, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(mat<2, 2, U, Q> const& m);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<2, 2, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<2, 2, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator*(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator*(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x2.inl"
+#endif

third_party/glm/detail/type_mat2x2.inl

@@ -0,0 +1,536 @@
+#include "../matrix.hpp"
+
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0), col_type(0, 1)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0);
+				this->value[1] = col_type(0, 1);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{m[0], m[1]}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(T scalar)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(scalar, 0), col_type(0, scalar)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(scalar, 0);
+			this->value[1] = col_type(0, scalar);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat
+	(
+		T const& x0, T const& y0,
+		T const& x1, T const& y1
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(col_type const& v0, col_type const& v1)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{v0, v1}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<typename X1, typename Y1, typename X2, typename Y2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat
+	(
+		X1 const& x1, Y1 const& y1,
+		X2 const& x2, Y2 const& y2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(static_cast<T>(x1), value_type(y1)), col_type(static_cast<T>(x2), value_type(y2)) }
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(static_cast<T>(x1), value_type(y1));
+			this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+#		endif
+	}
+
+	// -- mat2x2 matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 2, T, Q>::col_type const& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator=(mat<2, 2, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(U scalar)
+	{
+		this->value[0] += scalar;
+		this->value[1] += scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(mat<2, 2, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(U scalar)
+	{
+		this->value[0] -= scalar;
+		this->value[1] -= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(mat<2, 2, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(U scalar)
+	{
+		this->value[0] *= scalar;
+		this->value[1] *= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(mat<2, 2, U, Q> const& m)
+	{
+		return (*this = *this * m);
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(U scalar)
+	{
+		this->value[0] /= scalar;
+		this->value[1] /= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(mat<2, 2, U, Q> const& m)
+	{
+		return *this *= inverse(m);
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator++(int)
+	{
+		mat<2, 2, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator--(int)
+	{
+		mat<2, 2, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			-m[0],
+			-m[1]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 2, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			scalar - m[0],
+			scalar - m[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 2, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator*
+	(
+		mat<2, 2, T, Q> const& m,
+		typename mat<2, 2, T, Q>::row_type const& v
+	)
+	{
+		return vec<2, T, Q>(
+			m[0][0] * v.x + m[1][0] * v.y,
+			m[0][1] * v.x + m[1][1] * v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator*
+	(
+		typename mat<2, 2, T, Q>::col_type const& v,
+		mat<2, 2, T, Q> const& m
+	)
+	{
+		return vec<2, T, Q>(
+			v.x * m[0][0] + v.y * m[0][1],
+			v.x * m[1][0] + v.y * m[1][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			scalar / m[0],
+			scalar / m[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v)
+	{
+		return inverse(m) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m)
+	{
+		return v *  inverse(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		mat<2, 2, T, Q> m1_copy(m1);
+		return m1_copy /= m2;
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+} //namespace glm

third_party/glm/detail/type_mat2x3.hpp

@@ -0,0 +1,159 @@
+/// @ref core
+/// @file glm/detail/type_mat2x3.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<2, 3, T, Q>
+	{
+		typedef vec<3, T, Q> col_type;
+		typedef vec<2, T, Q> row_type;
+		typedef mat<2, 3, T, Q> type;
+		typedef mat<3, 2, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[2];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 3, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0, T z0,
+			T x1, T y1, T z1);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1);
+
+		// -- Conversions --
+
+		template<typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1, Z1 z1,
+			X2 x2, Y2 y2, Z2 z2);
+
+		template<typename U, typename V>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<3, U, Q> const& v1,
+			vec<3, V, Q> const& v2);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator=(mat<2, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(mat<2, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(mat<2, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<2, 3, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<2, 3, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 3, T, Q>::col_type operator*(mat<2, 3, T, Q> const& m, typename mat<2, 3, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 3, T, Q>::row_type operator*(typename mat<2, 3, T, Q>::col_type const& v, mat<2, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x3.inl"
+#endif

third_party/glm/detail/type_mat2x3.inl

@@ -0,0 +1,510 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0), col_type(0, 1, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0);
+				this->value[1] = col_type(0, 1, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{m.value[0], m.value[1]}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m.value[0];
+			this->value[1] = m.value[1];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(T scalar)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(scalar, 0, 0), col_type(0, scalar, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(scalar, 0, 0);
+			this->value[1] = col_type(0, scalar, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat
+	(
+		T x0, T y0, T z0,
+		T x1, T y1, T z1
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0), col_type(x1, y1, z1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0);
+			this->value[1] = col_type(x1, y1, z1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(col_type const& v0, col_type const& v1)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X1, typename Y1, typename Z1,
+		typename X2, typename Y2, typename Z2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat
+	(
+		X1 x1, Y1 y1, Z1 z1,
+		X2 x2, Y2 y2, Z2 z2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x1, y1, z1), col_type(x2, y2, z2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x1, y1, z1);
+			this->value[1] = col_type(x2, y2, z2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR  mat<2, 3, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+		: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type & mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 3, T, Q>::col_type const& mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator=(mat<2, 3, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator+=(mat<2, 3, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(mat<2, 3, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator++(int)
+	{
+		mat<2, 3, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator--(int)
+	{
+		mat<2, 3, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m)
+	{
+		return mat<2, 3, T, Q>(
+			-m[0],
+			-m[1]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type operator*
+	(
+		mat<2, 3, T, Q> const& m,
+		typename mat<2, 3, T, Q>::row_type const& v)
+	{
+		return typename mat<2, 3, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y,
+			m[0][1] * v.x + m[1][1] * v.y,
+			m[0][2] * v.x + m[1][2] * v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::row_type operator*
+	(
+		typename mat<2, 3, T, Q>::col_type const& v,
+		mat<2, 3, T, Q> const& m)
+	{
+		return typename mat<2, 3, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
+			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		T SrcA00 = m1[0][0];
+		T SrcA01 = m1[0][1];
+		T SrcA02 = m1[0][2];
+		T SrcA10 = m1[1][0];
+		T SrcA11 = m1[1][1];
+		T SrcA12 = m1[1][2];
+
+		T SrcB00 = m2[0][0];
+		T SrcB01 = m2[0][1];
+		T SrcB10 = m2[1][0];
+		T SrcB11 = m2[1][1];
+		T SrcB20 = m2[2][0];
+		T SrcB21 = m2[2][1];
+
+		mat<3, 3, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1],
+			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m)
+	{
+		return mat<2, 3, T, Q>(
+			scalar / m[0],
+			scalar / m[1]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+} //namespace glm

third_party/glm/detail/type_mat2x4.hpp

@@ -0,0 +1,161 @@
+/// @ref core
+/// @file glm/detail/type_mat2x4.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<2, 4, T, Q>
+	{
+		typedef vec<4, T, Q> col_type;
+		typedef vec<2, T, Q> row_type;
+		typedef mat<2, 4, T, Q> type;
+		typedef mat<4, 2, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[2];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 4, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0, T z0, T w0,
+			T x1, T y1, T z1, T w1);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1, typename W1,
+			typename X2, typename Y2, typename Z2, typename W2>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1, Z1 z1, W1 w1,
+			X2 x2, Y2 y2, Z2 z2, W2 w2);
+
+		template<typename U, typename V>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<4, U, Q> const& v1,
+			vec<4, V, Q> const& v2);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator=(mat<2, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(mat<2, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(mat<2, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<2, 4, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<2, 4, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x4.inl"
+#endif

third_party/glm/detail/type_mat2x4.inl

@@ -0,0 +1,520 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0, 0);
+				this->value[1] = col_type(0, 1, 0, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{m[0], m[1]}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0, 0);
+			this->value[1] = col_type(0, s, 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat
+	(
+		T x0, T y0, T z0, T w0,
+		T x1, T y1, T z1, T w1
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0, w0), col_type(x1, y1, z1, w1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0, w0);
+			this->value[1] = col_type(x1, y1, z1, w1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(col_type const& v0, col_type const& v1)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X1, typename Y1, typename Z1, typename W1,
+		typename X2, typename Y2, typename Z2, typename W2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat
+	(
+		X1 x1, Y1 y1, Z1 z1, W1 w1,
+		X2 x2, Y2 y2, Z2 z2, W2 w2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{
+				col_type(x1, y1, z1, w1),
+				col_type(x2, y2, z2, w2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x1, y1, z1, w1);
+			this->value[1] = col_type(x2, y2, z2, w2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type & mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 4, T, Q>::col_type const& mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator=(mat<2, 4, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(mat<2, 4, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(mat<2, 4, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> & mat<2, 4, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator++(int)
+	{
+		mat<2, 4, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator--(int)
+	{
+		mat<2, 4, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m)
+	{
+		return mat<2, 4, T, Q>(
+			-m[0],
+			-m[1]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v)
+	{
+		return typename mat<2, 4, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y,
+			m[0][1] * v.x + m[1][1] * v.y,
+			m[0][2] * v.x + m[1][2] * v.y,
+			m[0][3] * v.x + m[1][3] * v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m)
+	{
+		return typename mat<2, 4, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
+			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		T SrcA00 = m1[0][0];
+		T SrcA01 = m1[0][1];
+		T SrcA02 = m1[0][2];
+		T SrcA03 = m1[0][3];
+		T SrcA10 = m1[1][0];
+		T SrcA11 = m1[1][1];
+		T SrcA12 = m1[1][2];
+		T SrcA13 = m1[1][3];
+
+		T SrcB00 = m2[0][0];
+		T SrcB01 = m2[0][1];
+		T SrcB10 = m2[1][0];
+		T SrcB11 = m2[1][1];
+		T SrcB20 = m2[2][0];
+		T SrcB21 = m2[2][1];
+		T SrcB30 = m2[3][0];
+		T SrcB31 = m2[3][1];
+
+		mat<4, 4, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
+		Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
+		Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
+		Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
+		Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
+		Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
+		Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
+		Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
+			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m)
+	{
+		return mat<2, 4, T, Q>(
+			scalar / m[0],
+			scalar / m[1]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+} //namespace glm

third_party/glm/detail/type_mat3x2.hpp

@@ -0,0 +1,167 @@
+/// @ref core
+/// @file glm/detail/type_mat3x2.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<3, 2, T, Q>
+	{
+		typedef vec<2, T, Q> col_type;
+		typedef vec<3, T, Q> row_type;
+		typedef mat<3, 2, T, Q> type;
+		typedef mat<2, 3, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[3];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 2, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0,
+			T x1, T y1,
+			T x2, T y2);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1,
+			typename X2, typename Y2,
+			typename X3, typename Y3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1,
+			X2 x2, Y2 y2,
+			X3 x3, Y3 y3);
+
+		template<typename V1, typename V2, typename V3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<2, V1, Q> const& v1,
+			vec<2, V2, Q> const& v2,
+			vec<2, V3, Q> const& v3);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator=(mat<3, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(mat<3, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(mat<3, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<3, 2, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<3, 2, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x2.inl"
+#endif

third_party/glm/detail/type_mat3x2.inl

@@ -0,0 +1,532 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0), col_type(0, 1), col_type(0, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0);
+				this->value[1] = col_type(0, 1);
+				this->value[2] = col_type(0, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0), col_type(0, s), col_type(0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0);
+			this->value[1] = col_type(0, s);
+			this->value[2] = col_type(0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat
+	(
+		T x0, T y0,
+		T x1, T y1,
+		T x2, T y2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+			this->value[2] = col_type(x2, y2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X0, typename Y0,
+		typename X1, typename Y1,
+		typename X2, typename Y2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat
+	(
+		X0 x0, Y0 y0,
+		X1 x1, Y1 y1,
+		X2 x2, Y2 y2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+			this->value[2] = col_type(x2, y2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V0, typename V1, typename V2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+			this->value[2] = col_type(v2);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type & mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 2, T, Q>::col_type const& mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator=(mat<3, 2, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(mat<3, 2, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(mat<3, 2, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> & mat<3, 2, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator++(int)
+	{
+		mat<3, 2, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator--(int)
+	{
+		mat<3, 2, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m)
+	{
+		return mat<3, 2, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar,
+			m[2] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v)
+	{
+		return typename mat<3, 2, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m)
+	{
+		return typename mat<3, 2, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1],
+			v.x * m[1][0] + v.y * m[1][1],
+			v.x * m[2][0] + v.y * m[2][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		const T SrcA00 = m1[0][0];
+		const T SrcA01 = m1[0][1];
+		const T SrcA10 = m1[1][0];
+		const T SrcA11 = m1[1][1];
+		const T SrcA20 = m1[2][0];
+		const T SrcA21 = m1[2][1];
+
+		const T SrcB00 = m2[0][0];
+		const T SrcB01 = m2[0][1];
+		const T SrcB02 = m2[0][2];
+		const T SrcB10 = m2[1][0];
+		const T SrcB11 = m2[1][1];
+		const T SrcB12 = m2[1][2];
+
+		mat<2, 2, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar,
+			m[2] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m)
+	{
+		return mat<3, 2, T, Q>(
+			scalar / m[0],
+			scalar / m[1],
+			scalar / m[2]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+} //namespace glm

third_party/glm/detail/type_mat3x3.hpp

@@ -0,0 +1,184 @@
+/// @ref core
+/// @file glm/detail/type_mat3x3.hpp
+
+#pragma once
+
+#include "type_vec3.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<3, 3, T, Q>
+	{
+		typedef vec<3, T, Q> col_type;
+		typedef vec<3, T, Q> row_type;
+		typedef mat<3, 3, T, Q> type;
+		typedef mat<3, 3, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[3];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 3, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0, T z0,
+			T x1, T y1, T z1,
+			T x2, T y2, T z2);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1,
+			typename X2, typename Y2, typename Z2,
+			typename X3, typename Y3, typename Z3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1, Z1 z1,
+			X2 x2, Y2 y2, Z2 z2,
+			X3 x3, Y3 y3, Z3 z3);
+
+		template<typename V1, typename V2, typename V3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<3, V1, Q> const& v1,
+			vec<3, V2, Q> const& v2,
+			vec<3, V3, Q> const& v3);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator=(mat<3, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(mat<3, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(mat<3, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(mat<3, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(mat<3, 3, U, Q> const& m);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator++();
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator--();
+		GLM_FUNC_DECL mat<3, 3, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<3, 3, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x3.inl"
+#endif

third_party/glm/detail/type_mat3x3.inl

@@ -0,0 +1,601 @@
+#include "../matrix.hpp"
+
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+			this->value[0] = col_type(1, 0, 0);
+				this->value[1] = col_type(0, 1, 0);
+				this->value[2] = col_type(0, 0, 1);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0);
+			this->value[1] = col_type(0, s, 0);
+			this->value[2] = col_type(0, 0, s);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat
+	(
+		T x0, T y0, T z0,
+		T x1, T y1, T z1,
+		T x2, T y2, T z2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0);
+			this->value[1] = col_type(x1, y1, z1);
+			this->value[2] = col_type(x2, y2, z2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+			this->value[2] = col_type(v2);
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X1, typename Y1, typename Z1,
+		typename X2, typename Y2, typename Z2,
+		typename X3, typename Y3, typename Z3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat
+	(
+		X1 x1, Y1 y1, Z1 z1,
+		X2 x2, Y2 y2, Z2 z2,
+		X3 x3, Y3 y3, Z3 z3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x1, y1, z1);
+			this->value[1] = col_type(x2, y2, z2);
+			this->value[2] = col_type(x3, y3, z3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2, typename V3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+			this->value[2] = col_type(v3);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type & mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 3, T, Q>::col_type const& mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator=(mat<3, 3, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(mat<3, 3, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(mat<3, 3, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(mat<3, 3, U, Q> const& m)
+	{
+		return (*this = *this * m);
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(mat<3, 3, U, Q> const& m)
+	{
+		return *this *= inverse(m);
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator++(int)
+	{
+		mat<3, 3, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator--(int)
+	{
+		mat<3, 3, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return mat<3, 3, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar,
+			m[2] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			scalar - m[0],
+			scalar - m[1],
+			scalar - m[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return mat<3, 3, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v)
+	{
+		return typename mat<3, 3, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
+			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m)
+	{
+		return typename mat<3, 3, T, Q>::row_type(
+			m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
+			m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
+			m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		T const SrcA00 = m1[0][0];
+		T const SrcA01 = m1[0][1];
+		T const SrcA02 = m1[0][2];
+		T const SrcA10 = m1[1][0];
+		T const SrcA11 = m1[1][1];
+		T const SrcA12 = m1[1][2];
+		T const SrcA20 = m1[2][0];
+		T const SrcA21 = m1[2][1];
+		T const SrcA22 = m1[2][2];
+
+		T const SrcB00 = m2[0][0];
+		T const SrcB01 = m2[0][1];
+		T const SrcB02 = m2[0][2];
+		T const SrcB10 = m2[1][0];
+		T const SrcB11 = m2[1][1];
+		T const SrcB12 = m2[1][2];
+		T const SrcB20 = m2[2][0];
+		T const SrcB21 = m2[2][1];
+		T const SrcB22 = m2[2][2];
+
+		mat<3, 3, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2],
+			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m,	T scalar)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar,
+			m[2] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			scalar / m[0],
+			scalar / m[1],
+			scalar / m[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v)
+	{
+		return  inverse(m) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m)
+	{
+		return v * inverse(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		mat<3, 3, T, Q> m1_copy(m1);
+		return m1_copy /= m2;
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+} //namespace glm

third_party/glm/detail/type_mat3x4.hpp

@@ -0,0 +1,166 @@
+/// @ref core
+/// @file glm/detail/type_mat3x4.hpp
+
+#pragma once
+
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<3, 4, T, Q>
+	{
+		typedef vec<4, T, Q> col_type;
+		typedef vec<3, T, Q> row_type;
+		typedef mat<3, 4, T, Q> type;
+		typedef mat<4, 3, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[3];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 4, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0, T z0, T w0,
+			T x1, T y1, T z1, T w1,
+			T x2, T y2, T z2, T w2);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1, typename W1,
+			typename X2, typename Y2, typename Z2, typename W2,
+			typename X3, typename Y3, typename Z3, typename W3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1, Z1 z1, W1 w1,
+			X2 x2, Y2 y2, Z2 z2, W2 w2,
+			X3 x3, Y3 y3, Z3 z3, W3 w3);
+
+		template<typename V1, typename V2, typename V3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<4, V1, Q> const& v1,
+			vec<4, V2, Q> const& v2,
+			vec<4, V3, Q> const& v3);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator=(mat<3, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(mat<3, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(mat<3, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator++();
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator--();
+		GLM_FUNC_DECL mat<3, 4, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<3, 4, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 4, T, Q>::col_type operator*(mat<3, 4, T, Q> const& m, typename mat<3, 4, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 4, T, Q>::row_type operator*(typename mat<3, 4, T, Q>::col_type const& v, mat<3, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1,	mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1,	mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x4.inl"
+#endif

third_party/glm/detail/type_mat3x4.inl

@@ -0,0 +1,578 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0, 0);
+				this->value[1] = col_type(0, 1, 0, 0);
+				this->value[2] = col_type(0, 0, 1, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0, 0);
+			this->value[1] = col_type(0, s, 0, 0);
+			this->value[2] = col_type(0, 0, s, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat
+	(
+		T x0, T y0, T z0, T w0,
+		T x1, T y1, T z1, T w1,
+		T x2, T y2, T z2, T w2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{
+				col_type(x0, y0, z0, w0),
+				col_type(x1, y1, z1, w1),
+				col_type(x2, y2, z2, w2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0, w0);
+			this->value[1] = col_type(x1, y1, z1, w1);
+			this->value[2] = col_type(x2, y2, z2, w2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X0, typename Y0, typename Z0, typename W0,
+		typename X1, typename Y1, typename Z1, typename W1,
+		typename X2, typename Y2, typename Z2, typename W2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat
+	(
+		X0 x0, Y0 y0, Z0 z0, W0 w0,
+		X1 x1, Y1 y1, Z1 z1, W1 w1,
+		X2 x2, Y2 y2, Z2 z2, W2 w2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{
+				col_type(x0, y0, z0, w0),
+				col_type(x1, y1, z1, w1),
+				col_type(x2, y2, z2, w2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0, w0);
+			this->value[1] = col_type(x1, y1, z1, w1);
+			this->value[2] = col_type(x2, y2, z2, w2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2, typename V3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(vec<4, V1, Q> const& v0, vec<4, V2, Q> const& v1, vec<4, V3, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+			this->value[2] = col_type(v2);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(m[2], 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(m[2], 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 0);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type & mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 4, T, Q>::col_type const& mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator=(mat<3, 4, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(mat<3, 4, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(mat<3, 4, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> & mat<3, 4, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator++(int)
+	{
+		mat<3, 4, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator--(int)
+	{
+		mat<3, 4, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m)
+	{
+		return mat<3, 4, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m,	T scalar)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar,
+			m[2] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type operator*
+	(
+		mat<3, 4, T, Q> const& m,
+		typename mat<3, 4, T, Q>::row_type const& v
+	)
+	{
+		return typename mat<3, 4, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
+			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
+			m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::row_type operator*
+	(
+		typename mat<3, 4, T, Q>::col_type const& v,
+		mat<3, 4, T, Q> const& m
+	)
+	{
+		return typename mat<3, 4, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
+			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3],
+			v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		const T SrcA00 = m1[0][0];
+		const T SrcA01 = m1[0][1];
+		const T SrcA02 = m1[0][2];
+		const T SrcA03 = m1[0][3];
+		const T SrcA10 = m1[1][0];
+		const T SrcA11 = m1[1][1];
+		const T SrcA12 = m1[1][2];
+		const T SrcA13 = m1[1][3];
+		const T SrcA20 = m1[2][0];
+		const T SrcA21 = m1[2][1];
+		const T SrcA22 = m1[2][2];
+		const T SrcA23 = m1[2][3];
+
+		const T SrcB00 = m2[0][0];
+		const T SrcB01 = m2[0][1];
+		const T SrcB02 = m2[0][2];
+		const T SrcB10 = m2[1][0];
+		const T SrcB11 = m2[1][1];
+		const T SrcB12 = m2[1][2];
+		const T SrcB20 = m2[2][0];
+		const T SrcB21 = m2[2][1];
+		const T SrcB22 = m2[2][2];
+		const T SrcB30 = m2[3][0];
+		const T SrcB31 = m2[3][1];
+		const T SrcB32 = m2[3][2];
+
+		mat<4, 4, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
+		Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
+		Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
+		Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22;
+		Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32;
+		Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32;
+		Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32;
+		Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
+			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m,	T scalar)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar,
+			m[2] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m)
+	{
+		return mat<3, 4, T, Q>(
+			scalar / m[0],
+			scalar / m[1],
+			scalar / m[2]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+} //namespace glm

third_party/glm/detail/type_mat4x2.hpp

@@ -0,0 +1,171 @@
+/// @ref core
+/// @file glm/detail/type_mat4x2.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<4, 2, T, Q>
+	{
+		typedef vec<2, T, Q> col_type;
+		typedef vec<4, T, Q> row_type;
+		typedef mat<4, 2, T, Q> type;
+		typedef mat<2, 4, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[4];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 2, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0,
+			T x1, T y1,
+			T x2, T y2,
+			T x3, T y3);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2,
+			col_type const& v3);
+
+		// -- Conversions --
+
+		template<
+			typename X0, typename Y0,
+			typename X1, typename Y1,
+			typename X2, typename Y2,
+			typename X3, typename Y3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X0 x0, Y0 y0,
+			X1 x1, Y1 y1,
+			X2 x2, Y2 y2,
+			X3 x3, Y3 y3);
+
+		template<typename V1, typename V2, typename V3, typename V4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<2, V1, Q> const& v1,
+			vec<2, V2, Q> const& v2,
+			vec<2, V3, Q> const& v3,
+			vec<2, V4, Q> const& v4);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator=(mat<4, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(mat<4, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(mat<4, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<4, 2, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<4, 2, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1,	mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x2.inl"
+#endif

third_party/glm/detail/type_mat4x2.inl

@@ -0,0 +1,574 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0), col_type(0, 1), col_type(0, 0), col_type(0, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0);
+				this->value[1] = col_type(0, 1);
+				this->value[2] = col_type(0, 0);
+				this->value[3] = col_type(0, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+			this->value[3] = m[3];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0), col_type(0, s), col_type(0, 0), col_type(0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0);
+			this->value[1] = col_type(0, s);
+			this->value[2] = col_type(0, 0);
+			this->value[3] = col_type(0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat
+	(
+		T x0, T y0,
+		T x1, T y1,
+		T x2, T y2,
+		T x3, T y3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+			this->value[2] = col_type(x2, y2);
+			this->value[3] = col_type(x3, y3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+			this->value[3] = v3;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X0, typename Y0,
+		typename X1, typename Y1,
+		typename X2, typename Y2,
+		typename X3, typename Y3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat
+	(
+		X0 x0, Y0 y0,
+		X1 x1, Y1 y1,
+		X2 x2, Y2 y2,
+		X3 x3, Y3 y3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+			this->value[2] = col_type(x2, y2);
+			this->value[3] = col_type(x3, y3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V0, typename V1, typename V2, typename V3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+			this->value[2] = col_type(v2);
+			this->value[3] = col_type(v3);
+#		endif
+	}
+
+	// -- Conversion --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+				this->value[0] = col_type(m[0]);
+				this->value[1] = col_type(m[1]);
+				this->value[2] = col_type(m[2]);
+				this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type & mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 2, T, Q>::col_type const& mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q>& mat<4, 2, T, Q>::operator=(mat<4, 2, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		this->value[3] = m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		this->value[3] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(mat<4, 2, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		this->value[3] += m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		this->value[3] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(mat<4, 2, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		this->value[3] -= m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		this->value[3] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		this->value[3] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		++this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		--this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator++(int)
+	{
+		mat<4, 2, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator--(int)
+	{
+		mat<4, 2, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m)
+	{
+		return mat<4, 2, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2],
+			-m[3]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar,
+			m[3] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2],
+			m1[3] + m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar,
+			m[2] - scalar,
+			m[3] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2],
+			m1[3] - m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar,
+			m[3] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar,
+			m[3] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v)
+	{
+		return typename mat<4, 2, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m)
+	{
+		return typename mat<4, 2, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1],
+			v.x * m[1][0] + v.y * m[1][1],
+			v.x * m[2][0] + v.y * m[2][1],
+			v.x * m[3][0] + v.y * m[3][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		T const SrcA00 = m1[0][0];
+		T const SrcA01 = m1[0][1];
+		T const SrcA10 = m1[1][0];
+		T const SrcA11 = m1[1][1];
+		T const SrcA20 = m1[2][0];
+		T const SrcA21 = m1[2][1];
+		T const SrcA30 = m1[3][0];
+		T const SrcA31 = m1[3][1];
+
+		T const SrcB00 = m2[0][0];
+		T const SrcB01 = m2[0][1];
+		T const SrcB02 = m2[0][2];
+		T const SrcB03 = m2[0][3];
+		T const SrcB10 = m2[1][0];
+		T const SrcB11 = m2[1][1];
+		T const SrcB12 = m2[1][2];
+		T const SrcB13 = m2[1][3];
+
+		mat<2, 2, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar,
+			m[2] / scalar,
+			m[3] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m)
+	{
+		return mat<4, 2, T, Q>(
+			scalar / m[0],
+			scalar / m[1],
+			scalar / m[2],
+			scalar / m[3]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+} //namespace glm

third_party/glm/detail/type_mat4x3.hpp

@@ -0,0 +1,171 @@
+/// @ref core
+/// @file glm/detail/type_mat4x3.hpp
+
+#pragma once
+
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<4, 3, T, Q>
+	{
+		typedef vec<3, T, Q> col_type;
+		typedef vec<4, T, Q> row_type;
+		typedef mat<4, 3, T, Q> type;
+		typedef mat<3, 4, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[4];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 3, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T const& x);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T const& x0, T const& y0, T const& z0,
+			T const& x1, T const& y1, T const& z1,
+			T const& x2, T const& y2, T const& z2,
+			T const& x3, T const& y3, T const& z3);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2,
+			col_type const& v3);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1,
+			typename X2, typename Y2, typename Z2,
+			typename X3, typename Y3, typename Z3,
+			typename X4, typename Y4, typename Z4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 const& x1, Y1 const& y1, Z1 const& z1,
+			X2 const& x2, Y2 const& y2, Z2 const& z2,
+			X3 const& x3, Y3 const& y3, Z3 const& z3,
+			X4 const& x4, Y4 const& y4, Z4 const& z4);
+
+		template<typename V1, typename V2, typename V3, typename V4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<3, V1, Q> const& v1,
+			vec<3, V2, Q> const& v2,
+			vec<3, V3, Q> const& v3,
+			vec<3, V4, Q> const& v4);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator=(mat<4, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(mat<4, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(mat<4, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<4, 3, T, Q>& operator++();
+		GLM_FUNC_DECL mat<4, 3, T, Q>& operator--();
+		GLM_FUNC_DECL mat<4, 3, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<4, 3, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 3, T, Q>::col_type operator*(mat<4, 3, T, Q> const& m, typename mat<4, 3, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 3, T, Q>::row_type operator*(typename mat<4, 3, T, Q>::col_type const& v, mat<4, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1,	mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x3.inl"
+#endif //GLM_EXTERNAL_TEMPLATE

third_party/glm/detail/type_mat4x3.inl

@@ -0,0 +1,598 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1), col_type(0, 0, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0);
+				this->value[1] = col_type(0, 1, 0);
+				this->value[2] = col_type(0, 0, 1);
+				this->value[3] = col_type(0, 0, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+			this->value[3] = m[3];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(T const& s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s), col_type(0, 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0);
+			this->value[1] = col_type(0, s, 0);
+			this->value[2] = col_type(0, 0, s);
+			this->value[3] = col_type(0, 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat
+	(
+		T const& x0, T const& y0, T const& z0,
+		T const& x1, T const& y1, T const& z1,
+		T const& x2, T const& y2, T const& z2,
+		T const& x3, T const& y3, T const& z3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0);
+			this->value[1] = col_type(x1, y1, z1);
+			this->value[2] = col_type(x2, y2, z2);
+			this->value[3] = col_type(x3, y3, z3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+			this->value[3] = v3;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X0, typename Y0, typename Z0,
+		typename X1, typename Y1, typename Z1,
+		typename X2, typename Y2, typename Z2,
+		typename X3, typename Y3, typename Z3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat
+	(
+		X0 const& x0, Y0 const& y0, Z0 const& z0,
+		X1 const& x1, Y1 const& y1, Z1 const& z1,
+		X2 const& x2, Y2 const& y2, Z2 const& z2,
+		X3 const& x3, Y3 const& y3, Z3 const& z3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0);
+			this->value[1] = col_type(x1, y1, z1);
+			this->value[2] = col_type(x2, y2, z2);
+			this->value[3] = col_type(x3, y3, z3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2, typename V3, typename V4>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3, vec<3, V4, Q> const& v4)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+			this->value[2] = col_type(v3);
+			this->value[3] = col_type(v4);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(0, 0, 1);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 1);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(m[3], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 1);
+			this->value[3] = col_type(m[3], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type & mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 3, T, Q>::col_type const& mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q>& mat<4, 3, T, Q>::operator=(mat<4, 3, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		this->value[3] = m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		this->value[3] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(mat<4, 3, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		this->value[3] += m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		this->value[3] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(mat<4, 3, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		this->value[3] -= m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		this->value[3] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		this->value[3] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		++this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		--this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator++(int)
+	{
+		mat<4, 3, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator--(int)
+	{
+		mat<4, 3, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m)
+	{
+		return mat<4, 3, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2],
+			-m[3]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] + s,
+			m[1] + s,
+			m[2] + s,
+			m[3] + s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2],
+			m1[3] + m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] - s,
+			m[1] - s,
+			m[2] - s,
+			m[3] - s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2],
+			m1[3] - m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s,
+			m[3] * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s,
+			m[3] * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type operator*
+	(
+		mat<4, 3, T, Q> const& m,
+		typename mat<4, 3, T, Q>::row_type const& v)
+	{
+		return typename mat<4, 3, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
+			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::row_type operator*
+	(
+		typename mat<4, 3, T, Q>::col_type const& v,
+		mat<4, 3, T, Q> const& m)
+	{
+		return typename mat<4, 3, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
+			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2],
+			v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2],
+			v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		T const SrcA00 = m1[0][0];
+		T const SrcA01 = m1[0][1];
+		T const SrcA02 = m1[0][2];
+		T const SrcA10 = m1[1][0];
+		T const SrcA11 = m1[1][1];
+		T const SrcA12 = m1[1][2];
+		T const SrcA20 = m1[2][0];
+		T const SrcA21 = m1[2][1];
+		T const SrcA22 = m1[2][2];
+		T const SrcA30 = m1[3][0];
+		T const SrcA31 = m1[3][1];
+		T const SrcA32 = m1[3][2];
+
+		T const SrcB00 = m2[0][0];
+		T const SrcB01 = m2[0][1];
+		T const SrcB02 = m2[0][2];
+		T const SrcB03 = m2[0][3];
+		T const SrcB10 = m2[1][0];
+		T const SrcB11 = m2[1][1];
+		T const SrcB12 = m2[1][2];
+		T const SrcB13 = m2[1][3];
+		T const SrcB20 = m2[2][0];
+		T const SrcB21 = m2[2][1];
+		T const SrcB22 = m2[2][2];
+		T const SrcB23 = m2[2][3];
+
+		mat<3, 3, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12 + SrcA32 * SrcB13;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22 + SrcA30 * SrcB23;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22 + SrcA31 * SrcB23;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22 + SrcA32 * SrcB23;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3],
+			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] / s,
+			m[1] / s,
+			m[2] / s,
+			m[3] / s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m)
+	{
+		return mat<4, 3, T, Q>(
+			s / m[0],
+			s / m[1],
+			s / m[2],
+			s / m[3]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+} //namespace glm

third_party/glm/detail/type_mat4x4.hpp

@@ -0,0 +1,189 @@
+/// @ref core
+/// @file glm/detail/type_mat4x4.hpp
+
+#pragma once
+
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<4, 4, T, Q>
+	{
+		typedef vec<4, T, Q> col_type;
+		typedef vec<4, T, Q> row_type;
+		typedef mat<4, 4, T, Q> type;
+		typedef mat<4, 4, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[4];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 4, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T const& x);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T const& x0, T const& y0, T const& z0, T const& w0,
+			T const& x1, T const& y1, T const& z1, T const& w1,
+			T const& x2, T const& y2, T const& z2, T const& w2,
+			T const& x3, T const& y3, T const& z3, T const& w3);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2,
+			col_type const& v3);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1, typename W1,
+			typename X2, typename Y2, typename Z2, typename W2,
+			typename X3, typename Y3, typename Z3, typename W3,
+			typename X4, typename Y4, typename Z4, typename W4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1,
+			X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2,
+			X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3,
+			X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4);
+
+		template<typename V1, typename V2, typename V3, typename V4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<4, V1, Q> const& v1,
+			vec<4, V2, Q> const& v2,
+			vec<4, V3, Q> const& v3,
+			vec<4, V4, Q> const& v4);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator=(mat<4, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(mat<4, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(mat<4, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(mat<4, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(mat<4, 4, U, Q> const& m);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator++();
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator--();
+		GLM_FUNC_DECL mat<4, 4, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<4, 4, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1,	mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator*(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator*(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator/(T const& s, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1,	mat<4, 4, T, Q> const& m2);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x4.inl"
+#endif//GLM_EXTERNAL_TEMPLATE

third_party/glm/detail/type_mat4x4.inl

@@ -0,0 +1,706 @@
+#include "../matrix.hpp"
+
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0, 0);
+				this->value[1] = col_type(0, 1, 0, 0);
+				this->value[2] = col_type(0, 0, 1, 0);
+				this->value[3] = col_type(0, 0, 0, 1);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+			this->value[3] = m[3];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(T const& s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0), col_type(0, 0, 0, s)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0, 0);
+			this->value[1] = col_type(0, s, 0, 0);
+			this->value[2] = col_type(0, 0, s, 0);
+			this->value[3] = col_type(0, 0, 0, s);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat
+	(
+		T const& x0, T const& y0, T const& z0, T const& w0,
+		T const& x1, T const& y1, T const& z1, T const& w1,
+		T const& x2, T const& y2, T const& z2, T const& w2,
+		T const& x3, T const& y3, T const& z3, T const& w3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{
+				col_type(x0, y0, z0, w0),
+				col_type(x1, y1, z1, w1),
+				col_type(x2, y2, z2, w2),
+				col_type(x3, y3, z3, w3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0, w0);
+			this->value[1] = col_type(x1, y1, z1, w1);
+			this->value[2] = col_type(x2, y2, z2, w2);
+			this->value[3] = col_type(x3, y3, z3, w3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+			this->value[3] = v3;
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	// -- Conversions --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X1, typename Y1, typename Z1, typename W1,
+		typename X2, typename Y2, typename Z2, typename W2,
+		typename X3, typename Y3, typename Z3, typename W3,
+		typename X4, typename Y4, typename Z4, typename W4>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat
+	(
+		X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1,
+		X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2,
+		X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3,
+		X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2), col_type(x3, y3, z3, w3), col_type(x4, y4, z4, w4)}
+#		endif
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<X1>::is_iec559 || std::numeric_limits<X1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Y1>::is_iec559 || std::numeric_limits<Y1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Z1>::is_iec559 || std::numeric_limits<Z1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<W1>::is_iec559 || std::numeric_limits<W1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
+
+		GLM_STATIC_ASSERT(std::numeric_limits<X2>::is_iec559 || std::numeric_limits<X2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Y2>::is_iec559 || std::numeric_limits<Y2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Z2>::is_iec559 || std::numeric_limits<Z2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<W2>::is_iec559 || std::numeric_limits<W2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid.");
+
+		GLM_STATIC_ASSERT(std::numeric_limits<X3>::is_iec559 || std::numeric_limits<X3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Y3>::is_iec559 || std::numeric_limits<Y3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Z3>::is_iec559 || std::numeric_limits<Z3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<W3>::is_iec559 || std::numeric_limits<W3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid.");
+
+		GLM_STATIC_ASSERT(std::numeric_limits<X4>::is_iec559 || std::numeric_limits<X4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Y4>::is_iec559 || std::numeric_limits<Y4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Z4>::is_iec559 || std::numeric_limits<Z4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<W4>::is_iec559 || std::numeric_limits<W4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid.");
+
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x1, y1, z1, w1);
+			this->value[1] = col_type(x2, y2, z2, w2);
+			this->value[2] = col_type(x3, y3, z3, w3);
+			this->value[3] = col_type(x4, y4, z4, w4);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2, typename V3, typename V4>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3, vec<4, V4, Q> const& v4)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)}
+#		endif
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<V1>::is_iec559 || std::numeric_limits<V1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<V2>::is_iec559 || std::numeric_limits<V2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<V3>::is_iec559 || std::numeric_limits<V3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<V4>::is_iec559 || std::numeric_limits<V4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
+
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+			this->value[2] = col_type(v3);
+			this->value[3] = col_type(v4);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(m[2], 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = col_type(0, 0, 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(m[3], 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 0);
+			this->value[3] = col_type(m[3], 1);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type & mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 4, T, Q>::col_type const& mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator=(mat<4, 4, U, Q> const& m)
+	{
+		//memcpy could be faster
+		//memcpy(&this->value, &m.value, 16 * sizeof(valType));
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		this->value[3] = m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		this->value[3] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(mat<4, 4, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		this->value[3] += m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		this->value[3] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(mat<4, 4, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		this->value[3] -= m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		this->value[3] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(mat<4, 4, U, Q> const& m)
+	{
+		return (*this = *this * m);
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		this->value[3] /= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(mat<4, 4, U, Q> const& m)
+	{
+		return *this *= inverse(m);
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		++this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		--this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator++(int)
+	{
+		mat<4, 4, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator--(int)
+	{
+		mat<4, 4, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary constant operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2],
+			-m[3]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] + s,
+			m[1] + s,
+			m[2] + s,
+			m[3] + s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] + s,
+			m[1] + s,
+			m[2] + s,
+			m[3] + s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return mat<4, 4, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2],
+			m1[3] + m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] - s,
+			m[1] - s,
+			m[2] - s,
+			m[3] - s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			s - m[0],
+			s - m[1],
+			s - m[2],
+			s - m[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return mat<4, 4, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2],
+			m1[3] - m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const  & s)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s,
+			m[3] * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s,
+			m[3] * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator*
+	(
+		mat<4, 4, T, Q> const& m,
+		typename mat<4, 4, T, Q>::row_type const& v
+	)
+	{
+/*
+		__m128 v0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 v1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 v2 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 v3 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(m[0].data, v0);
+		__m128 m1 = _mm_mul_ps(m[1].data, v1);
+		__m128 a0 = _mm_add_ps(m0, m1);
+
+		__m128 m2 = _mm_mul_ps(m[2].data, v2);
+		__m128 m3 = _mm_mul_ps(m[3].data, v3);
+		__m128 a1 = _mm_add_ps(m2, m3);
+
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		return typename mat<4, 4, T, Q>::col_type(a2);
+*/
+
+		typename mat<4, 4, T, Q>::col_type const Mov0(v[0]);
+		typename mat<4, 4, T, Q>::col_type const Mov1(v[1]);
+		typename mat<4, 4, T, Q>::col_type const Mul0 = m[0] * Mov0;
+		typename mat<4, 4, T, Q>::col_type const Mul1 = m[1] * Mov1;
+		typename mat<4, 4, T, Q>::col_type const Add0 = Mul0 + Mul1;
+		typename mat<4, 4, T, Q>::col_type const Mov2(v[2]);
+		typename mat<4, 4, T, Q>::col_type const Mov3(v[3]);
+		typename mat<4, 4, T, Q>::col_type const Mul2 = m[2] * Mov2;
+		typename mat<4, 4, T, Q>::col_type const Mul3 = m[3] * Mov3;
+		typename mat<4, 4, T, Q>::col_type const Add1 = Mul2 + Mul3;
+		typename mat<4, 4, T, Q>::col_type const Add2 = Add0 + Add1;
+		return Add2;
+
+/*
+		return typename mat<4, 4, T, Q>::col_type(
+			m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0] * v[3],
+			m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1] * v[3],
+			m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2] * v[3],
+			m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3] * v[3]);
+*/
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator*
+	(
+		typename mat<4, 4, T, Q>::col_type const& v,
+		mat<4, 4, T, Q> const& m
+	)
+	{
+		return typename mat<4, 4, T, Q>::row_type(
+			m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3] * v[3],
+			m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3] * v[3],
+			m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3] * v[3],
+			m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
+			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		typename mat<4, 4, T, Q>::col_type const SrcA0 = m1[0];
+		typename mat<4, 4, T, Q>::col_type const SrcA1 = m1[1];
+		typename mat<4, 4, T, Q>::col_type const SrcA2 = m1[2];
+		typename mat<4, 4, T, Q>::col_type const SrcA3 = m1[3];
+
+		typename mat<4, 4, T, Q>::col_type const SrcB0 = m2[0];
+		typename mat<4, 4, T, Q>::col_type const SrcB1 = m2[1];
+		typename mat<4, 4, T, Q>::col_type const SrcB2 = m2[2];
+		typename mat<4, 4, T, Q>::col_type const SrcB3 = m2[3];
+
+		mat<4, 4, T, Q> Result;
+		Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3];
+		Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3];
+		Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3];
+		Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] + SrcA3 * SrcB3[3];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] / s,
+			m[1] / s,
+			m[2] / s,
+			m[3] / s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(T const& s,	mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			s / m[0],
+			s / m[1],
+			s / m[2],
+			s / m[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v)
+	{
+		return inverse(m) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m)
+	{
+		return v * inverse(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		mat<4, 4, T, Q> m1_copy(m1);
+		return m1_copy /= m2;
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "type_mat4x4_simd.inl"
+#endif

third_party/glm/detail/type_mat4x4_simd.inl

@@ -0,0 +1,6 @@
+/// @ref core
+
+namespace glm
+{
+
+}//namespace glm

third_party/glm/detail/type_quat.hpp

@@ -0,0 +1,186 @@
+/// @ref core
+/// @file glm/detail/type_quat.hpp
+
+#pragma once
+
+// Dependency:
+#include "../detail/type_mat3x3.hpp"
+#include "../detail/type_mat4x4.hpp"
+#include "../detail/type_vec3.hpp"
+#include "../detail/type_vec4.hpp"
+#include "../ext/vector_relational.hpp"
+#include "../ext/quaternion_relational.hpp"
+#include "../gtc/constants.hpp"
+#include "../gtc/matrix_transform.hpp"
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct qua
+	{
+		// -- Implementation detail --
+
+		typedef qua<T, Q> type;
+		typedef T value_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#			endif
+#		endif
+
+#		if GLM_LANG & GLM_LANG_CXXMS_FLAG
+			union
+			{
+#				ifdef GLM_FORCE_QUAT_DATA_WXYZ
+					struct { T w, x, y, z; };
+#				else
+					struct { T x, y, z, w; };
+#				endif
+
+				typename detail::storage<4, T, detail::is_aligned<Q>::value>::type data;
+			};
+#		else
+#			ifdef GLM_FORCE_QUAT_DATA_WXYZ
+				T w, x, y, z;
+#			else
+				T x, y, z, w;
+#			endif
+#		endif
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		typedef length_t length_type;
+
+		/// Return the count of components of a quaternion
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR qua() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR qua(qua<T, Q> const& q) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR qua(qua<T, P> const& q);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR qua(T s, vec<3, T, Q> const& v);
+		GLM_FUNC_DECL GLM_CONSTEXPR qua(T w, T x, T y, T z);
+
+		// -- Conversion constructors --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT qua(qua<U, P> const& q);
+
+		/// Explicit conversion operators
+#		if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
+			GLM_FUNC_DECL explicit operator mat<3, 3, T, Q>() const;
+			GLM_FUNC_DECL explicit operator mat<4, 4, T, Q>() const;
+#		endif
+
+		/// Create a quaternion from two normalized axis
+		///
+		/// @param u A first normalized axis
+		/// @param v A second normalized axis
+		/// @see gtc_quaternion
+		/// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
+		GLM_FUNC_DECL qua(vec<3, T, Q> const& u, vec<3, T, Q> const& v);
+
+		/// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT qua(vec<3, T, Q> const& eulerAngles);
+		GLM_FUNC_DECL GLM_EXPLICIT qua(mat<3, 3, T, Q> const& q);
+		GLM_FUNC_DECL GLM_EXPLICIT qua(mat<4, 4, T, Q> const& q);
+
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator=(qua<T, Q> const& q) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator=(qua<U, Q> const& q);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator+=(qua<U, Q> const& q);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator-=(qua<U, Q> const& q);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator*=(qua<U, Q> const& q);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator/=(U s);
+	};
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator+(qua<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator-(qua<T, Q> const& q);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator+(qua<T, Q> const& q, qua<T, Q> const& p);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator-(qua<T, Q> const& q, qua<T, Q> const& p);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator*(qua<T, Q> const& q, qua<T, Q> const& p);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(qua<T, Q> const& q, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, qua<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(qua<T, Q> const& q, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, qua<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator*(qua<T, Q> const& q, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator*(T const& s, qua<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator/(qua<T, Q> const& q, T const& s);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(qua<T, Q> const& q1, qua<T, Q> const& q2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(qua<T, Q> const& q1, qua<T, Q> const& q2);
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_quat.inl"
+#endif//GLM_EXTERNAL_TEMPLATE

third_party/glm/detail/type_quat.inl

@@ -0,0 +1,408 @@
+#include "../trigonometric.hpp"
+#include "../exponential.hpp"
+#include "../ext/quaternion_geometric.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	struct genTypeTrait<qua<T> >
+	{
+		static const genTypeEnum GENTYPE = GENTYPE_QUAT;
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<qua<T, Q>, T, Aligned>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(qua<T, Q> const& a, qua<T, Q> const& b)
+		{
+			vec<4, T, Q> tmp(a.w * b.w, a.x * b.x, a.y * b.y, a.z * b.z);
+			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_add
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua<T, Q> call(qua<T, Q> const& q, qua<T, Q> const& p)
+		{
+			return qua<T, Q>(q.w + p.w, q.x + p.x, q.y + p.y, q.z + p.z);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_sub
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua<T, Q> call(qua<T, Q> const& q, qua<T, Q> const& p)
+		{
+			return qua<T, Q>(q.w - p.w, q.x - p.x, q.y - p.y, q.z - p.z);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_mul_scalar
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua<T, Q> call(qua<T, Q> const& q, T s)
+		{
+			return qua<T, Q>(q.w * s, q.x * s, q.y * s, q.z * s);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_div_scalar
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua<T, Q> call(qua<T, Q> const& q, T s)
+		{
+			return qua<T, Q>(q.w / s, q.x / s, q.y / s, q.z / s);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_mul_vec4
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(qua<T, Q> const& q, vec<4, T, Q> const& v)
+		{
+			return vec<4, T, Q>(q * vec<3, T, Q>(v), v.w);
+		}
+	};
+}//namespace detail
+
+	// -- Component accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & qua<T, Q>::operator[](typename qua<T, Q>::length_type i)
+	{
+		assert(i >= 0 && i < this->length());
+#		ifdef GLM_FORCE_QUAT_DATA_WXYZ
+			return (&w)[i];
+#		else
+			return (&x)[i];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& qua<T, Q>::operator[](typename qua<T, Q>::length_type i) const
+	{
+		assert(i >= 0 && i < this->length());
+#		ifdef GLM_FORCE_QUAT_DATA_WXYZ
+			return (&w)[i];
+#		else
+			return (&x)[i];
+#		endif
+	}
+
+	// -- Implicit basic constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua()
+#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+#				ifdef GLM_FORCE_QUAT_DATA_WXYZ
+					: w(1), x(0), y(0), z(0)
+#				else
+					: x(0), y(0), z(0), w(1)
+#				endif
+#			endif
+		{}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<T, Q> const& q)
+#			ifdef GLM_FORCE_QUAT_DATA_WXYZ
+				: w(q.w), x(q.x), y(q.y), z(q.z)
+#			else
+				: x(q.x), y(q.y), z(q.z), w(q.w)
+#			endif
+		{}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<T, P> const& q)
+#		ifdef GLM_FORCE_QUAT_DATA_WXYZ
+			: w(q.w), x(q.x), y(q.y), z(q.z)
+#		else
+			: x(q.x), y(q.y), z(q.z), w(q.w)
+#		endif
+	{}
+
+	// -- Explicit basic constructors --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(T s, vec<3, T, Q> const& v)
+#		ifdef GLM_FORCE_QUAT_DATA_WXYZ
+			: w(s), x(v.x), y(v.y), z(v.z)
+#		else
+			: x(v.x), y(v.y), z(v.z), w(s)
+#		endif
+	{}
+
+	template <typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(T _w, T _x, T _y, T _z)
+#		ifdef GLM_FORCE_QUAT_DATA_WXYZ
+			: w(_w), x(_x), y(_y), z(_z)
+#		else
+			: x(_x), y(_y), z(_z), w(_w)
+#		endif
+	{}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<U, P> const& q)
+#		ifdef GLM_FORCE_QUAT_DATA_WXYZ
+			: w(static_cast<T>(q.w)), x(static_cast<T>(q.x)), y(static_cast<T>(q.y)), z(static_cast<T>(q.z))
+#		else
+			: x(static_cast<T>(q.x)), y(static_cast<T>(q.y)), z(static_cast<T>(q.z)), w(static_cast<T>(q.w))
+#		endif
+	{}
+
+	//template<typename valType>
+	//GLM_FUNC_QUALIFIER qua<valType>::qua
+	//(
+	//	valType const& pitch,
+	//	valType const& yaw,
+	//	valType const& roll
+	//)
+	//{
+	//	vec<3, valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5));
+	//	vec<3, valType> c = glm::cos(eulerAngle * valType(0.5));
+	//	vec<3, valType> s = glm::sin(eulerAngle * valType(0.5));
+	//
+	//	this->w = c.x * c.y * c.z + s.x * s.y * s.z;
+	//	this->x = s.x * c.y * c.z - c.x * s.y * s.z;
+	//	this->y = c.x * s.y * c.z + s.x * c.y * s.z;
+	//	this->z = c.x * c.y * s.z - s.x * s.y * c.z;
+	//}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::qua(vec<3, T, Q> const& u, vec<3, T, Q> const& v)
+	{
+		T norm_u_norm_v = sqrt(dot(u, u) * dot(v, v));
+		T real_part = norm_u_norm_v + dot(u, v);
+		vec<3, T, Q> t;
+
+		if(real_part < static_cast<T>(1.e-6f) * norm_u_norm_v)
+		{
+			// If u and v are exactly opposite, rotate 180 degrees
+			// around an arbitrary orthogonal axis. Axis normalisation
+			// can happen later, when we normalise the quaternion.
+			real_part = static_cast<T>(0);
+			t = abs(u.x) > abs(u.z) ? vec<3, T, Q>(-u.y, u.x, static_cast<T>(0)) : vec<3, T, Q>(static_cast<T>(0), -u.z, u.y);
+		}
+		else
+		{
+			// Otherwise, build quaternion the standard way.
+			t = cross(u, v);
+		}
+
+		*this = normalize(qua<T, Q>(real_part, t.x, t.y, t.z));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(vec<3, T, Q> const& eulerAngle)
+	{
+		vec<3, T, Q> c = glm::cos(eulerAngle * T(0.5));
+		vec<3, T, Q> s = glm::sin(eulerAngle * T(0.5));
+
+		this->w = c.x * c.y * c.z + s.x * s.y * s.z;
+		this->x = s.x * c.y * c.z - c.x * s.y * s.z;
+		this->y = c.x * s.y * c.z + s.x * c.y * s.z;
+		this->z = c.x * c.y * s.z - s.x * s.y * c.z;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::qua(mat<3, 3, T, Q> const& m)
+	{
+		*this = quat_cast(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::qua(mat<4, 4, T, Q> const& m)
+	{
+		*this = quat_cast(m);
+	}
+
+#	if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::operator mat<3, 3, T, Q>() const
+	{
+		return mat3_cast(*this);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::operator mat<4, 4, T, Q>() const
+	{
+		return mat4_cast(*this);
+	}
+#	endif//GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
+
+	// -- Unary arithmetic operators --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator=(qua<T, Q> const& q)
+		{
+			this->w = q.w;
+			this->x = q.x;
+			this->y = q.y;
+			this->z = q.z;
+			return *this;
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator=(qua<U, Q> const& q)
+	{
+		this->w = static_cast<T>(q.w);
+		this->x = static_cast<T>(q.x);
+		this->y = static_cast<T>(q.y);
+		this->z = static_cast<T>(q.z);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator+=(qua<U, Q> const& q)
+	{
+		return (*this = detail::compute_quat_add<T, Q, detail::is_aligned<Q>::value>::call(*this, qua<T, Q>(q)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator-=(qua<U, Q> const& q)
+	{
+		return (*this = detail::compute_quat_sub<T, Q, detail::is_aligned<Q>::value>::call(*this, qua<T, Q>(q)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator*=(qua<U, Q> const& r)
+	{
+		qua<T, Q> const p(*this);
+		qua<T, Q> const q(r);
+
+		this->w = p.w * q.w - p.x * q.x - p.y * q.y - p.z * q.z;
+		this->x = p.w * q.x + p.x * q.w + p.y * q.z - p.z * q.y;
+		this->y = p.w * q.y + p.y * q.w + p.z * q.x - p.x * q.z;
+		this->z = p.w * q.z + p.z * q.w + p.x * q.y - p.y * q.x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator*=(U s)
+	{
+		return (*this = detail::compute_quat_mul_scalar<T, Q, detail::is_aligned<Q>::value>::call(*this, static_cast<U>(s)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator/=(U s)
+	{
+		return (*this = detail::compute_quat_div_scalar<T, Q, detail::is_aligned<Q>::value>::call(*this, static_cast<U>(s)));
+	}
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator+(qua<T, Q> const& q)
+	{
+		return q;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator-(qua<T, Q> const& q)
+	{
+		return qua<T, Q>(-q.w, -q.x, -q.y, -q.z);
+	}
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator+(qua<T, Q> const& q, qua<T, Q> const& p)
+	{
+		return qua<T, Q>(q) += p;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator-(qua<T, Q> const& q, qua<T, Q> const& p)
+	{
+		return qua<T, Q>(q) -= p;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator*(qua<T, Q> const& q, qua<T, Q> const& p)
+	{
+		return qua<T, Q>(q) *= p;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(qua<T, Q> const& q, vec<3, T, Q> const& v)
+	{
+		vec<3, T, Q> const QuatVector(q.x, q.y, q.z);
+		vec<3, T, Q> const uv(glm::cross(QuatVector, v));
+		vec<3, T, Q> const uuv(glm::cross(QuatVector, uv));
+
+		return v + ((uv * q.w) + uuv) * static_cast<T>(2);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, qua<T, Q> const& q)
+	{
+		return glm::inverse(q) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(qua<T, Q> const& q, vec<4, T, Q> const& v)
+	{
+		return detail::compute_quat_mul_vec4<T, Q, detail::is_aligned<Q>::value>::call(q, v);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, qua<T, Q> const& q)
+	{
+		return glm::inverse(q) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator*(qua<T, Q> const& q, T const& s)
+	{
+		return qua<T, Q>(
+			q.w * s, q.x * s, q.y * s, q.z * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator*(T const& s, qua<T, Q> const& q)
+	{
+		return q * s;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator/(qua<T, Q> const& q, T const& s)
+	{
+		return qua<T, Q>(
+			q.w / s, q.x / s, q.y / s, q.z / s);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(qua<T, Q> const& q1, qua<T, Q> const& q2)
+	{
+		return q1.x == q2.x && q1.y == q2.y && q1.z == q2.z && q1.w == q2.w;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(qua<T, Q> const& q1, qua<T, Q> const& q2)
+	{
+		return q1.x != q2.x || q1.y != q2.y || q1.z != q2.z || q1.w != q2.w;
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "type_quat_simd.inl"
+#endif
+

third_party/glm/detail/type_quat_simd.inl

@@ -0,0 +1,188 @@
+/// @ref core
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+/*
+	template<qualifier Q>
+	struct compute_quat_mul<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q1, qua<float, Q> const& q2)
+		{
+			// SSE2 STATS: 11 shuffle, 8 mul, 8 add
+			// SSE4 STATS: 3 shuffle, 4 mul, 4 dpps
+
+			__m128 const mul0 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(0, 1, 2, 3)));
+			__m128 const mul1 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(1, 0, 3, 2)));
+			__m128 const mul2 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(2, 3, 0, 1)));
+			__m128 const mul3 = _mm_mul_ps(q1.Data, q2.Data);
+
+#			if GLM_ARCH & GLM_ARCH_SSE41_BIT
+				__m128 const add0 = _mm_dp_ps(mul0, _mm_set_ps(1.0f, -1.0f,  1.0f,  1.0f), 0xff);
+				__m128 const add1 = _mm_dp_ps(mul1, _mm_set_ps(1.0f,  1.0f,  1.0f, -1.0f), 0xff);
+				__m128 const add2 = _mm_dp_ps(mul2, _mm_set_ps(1.0f,  1.0f, -1.0f,  1.0f), 0xff);
+				__m128 const add3 = _mm_dp_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f), 0xff);
+#			else
+				__m128 const mul4 = _mm_mul_ps(mul0, _mm_set_ps(1.0f, -1.0f,  1.0f,  1.0f));
+				__m128 const add0 = _mm_add_ps(mul0, _mm_movehl_ps(mul4, mul4));
+				__m128 const add4 = _mm_add_ss(add0, _mm_shuffle_ps(add0, add0, 1));
+
+				__m128 const mul5 = _mm_mul_ps(mul1, _mm_set_ps(1.0f,  1.0f,  1.0f, -1.0f));
+				__m128 const add1 = _mm_add_ps(mul1, _mm_movehl_ps(mul5, mul5));
+				__m128 const add5 = _mm_add_ss(add1, _mm_shuffle_ps(add1, add1, 1));
+
+				__m128 const mul6 = _mm_mul_ps(mul2, _mm_set_ps(1.0f,  1.0f, -1.0f,  1.0f));
+				__m128 const add2 = _mm_add_ps(mul6, _mm_movehl_ps(mul6, mul6));
+				__m128 const add6 = _mm_add_ss(add2, _mm_shuffle_ps(add2, add2, 1));
+
+				__m128 const mul7 = _mm_mul_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f));
+				__m128 const add3 = _mm_add_ps(mul3, _mm_movehl_ps(mul7, mul7));
+				__m128 const add7 = _mm_add_ss(add3, _mm_shuffle_ps(add3, add3, 1));
+		#endif
+
+			// This SIMD code is a politically correct way of doing this, but in every test I've tried it has been slower than
+			// the final code below. I'll keep this here for reference - maybe somebody else can do something better...
+			//
+			//__m128 xxyy = _mm_shuffle_ps(add4, add5, _MM_SHUFFLE(0, 0, 0, 0));
+			//__m128 zzww = _mm_shuffle_ps(add6, add7, _MM_SHUFFLE(0, 0, 0, 0));
+			//
+			//return _mm_shuffle_ps(xxyy, zzww, _MM_SHUFFLE(2, 0, 2, 0));
+
+			qua<float, Q> Result;
+			_mm_store_ss(&Result.x, add4);
+			_mm_store_ss(&Result.y, add5);
+			_mm_store_ss(&Result.z, add6);
+			_mm_store_ss(&Result.w, add7);
+			return Result;
+		}
+	};
+*/
+
+	template<qualifier Q>
+	struct compute_quat_add<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q, qua<float, Q> const& p)
+		{
+			qua<float, Q> Result;
+			Result.data = _mm_add_ps(q.data, p.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_quat_add<double, Q, true>
+	{
+		static qua<double, Q> call(qua<double, Q> const& a, qua<double, Q> const& b)
+		{
+			qua<double, Q> Result;
+			Result.data = _mm256_add_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_quat_sub<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q, qua<float, Q> const& p)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_sub_ps(q.data, p.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_quat_sub<double, Q, true>
+	{
+		static qua<double, Q> call(qua<double, Q> const& a, qua<double, Q> const& b)
+		{
+			qua<double, Q> Result;
+			Result.data = _mm256_sub_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_quat_mul_scalar<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q, float s)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_mul_ps(q.data, _mm_set_ps1(s));
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_quat_mul_scalar<double, Q, true>
+	{
+		static qua<double, Q> call(qua<double, Q> const& q, double s)
+		{
+			qua<double, Q> Result;
+			Result.data = _mm256_mul_pd(q.data, _mm_set_ps1(s));
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_quat_div_scalar<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q, float s)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_div_ps(q.data, _mm_set_ps1(s));
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_quat_div_scalar<double, Q, true>
+	{
+		static qua<double, Q> call(qua<double, Q> const& q, double s)
+		{
+			qua<double, Q> Result;
+			Result.data = _mm256_div_pd(q.data, _mm_set_ps1(s));
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_quat_mul_vec4<float, Q, true>
+	{
+		static vec<4, float, Q> call(qua<float, Q> const& q, vec<4, float, Q> const& v)
+		{
+			__m128 const q_wwww = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 const q_swp0 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 0, 2, 1));
+			__m128 const q_swp1 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 1, 0, 2));
+			__m128 const v_swp0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 0, 2, 1));
+			__m128 const v_swp1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 1, 0, 2));
+
+			__m128 uv      = _mm_sub_ps(_mm_mul_ps(q_swp0, v_swp1), _mm_mul_ps(q_swp1, v_swp0));
+			__m128 uv_swp0 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 0, 2, 1));
+			__m128 uv_swp1 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 1, 0, 2));
+			__m128 uuv     = _mm_sub_ps(_mm_mul_ps(q_swp0, uv_swp1), _mm_mul_ps(q_swp1, uv_swp0));
+
+			__m128 const two = _mm_set1_ps(2.0f);
+			uv  = _mm_mul_ps(uv, _mm_mul_ps(q_wwww, two));
+			uuv = _mm_mul_ps(uuv, two);
+
+			vec<4, float, Q> Result;
+			Result.data = _mm_add_ps(v.Data, _mm_add_ps(uv, uuv));
+			return Result;
+		}
+	};
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+

third_party/glm/detail/type_vec1.hpp

@@ -0,0 +1,308 @@
+/// @ref core
+/// @file glm/detail/type_vec1.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+#	include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+#	include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct vec<1, T, Q>
+	{
+		// -- Implementation detail --
+
+		typedef T value_type;
+		typedef vec<1, T, Q> type;
+		typedef vec<1, bool, Q> bool_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#			endif
+#		endif
+
+#		if GLM_CONFIG_XYZW_ONLY
+			T x;
+#		elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+			union
+			{
+				T x;
+				T r;
+				T s;
+
+				typename detail::storage<1, T, detail::is_aligned<Q>::value>::type data;
+/*
+#				if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+					_GLM_SWIZZLE1_2_MEMBERS(T, Q, x)
+					_GLM_SWIZZLE1_2_MEMBERS(T, Q, r)
+					_GLM_SWIZZLE1_2_MEMBERS(T, Q, s)
+					_GLM_SWIZZLE1_3_MEMBERS(T, Q, x)
+					_GLM_SWIZZLE1_3_MEMBERS(T, Q, r)
+					_GLM_SWIZZLE1_3_MEMBERS(T, Q, s)
+					_GLM_SWIZZLE1_4_MEMBERS(T, Q, x)
+					_GLM_SWIZZLE1_4_MEMBERS(T, Q, r)
+					_GLM_SWIZZLE1_4_MEMBERS(T, Q, s)
+#				endif
+*/
+			};
+#		else
+			union {T x, r, s;};
+/*
+#			if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, Q)
+#			endif
+*/
+#		endif
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		/// Return the count of components of the vector
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 1;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, T, P> const& v);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+
+		// -- Conversion vector constructors --
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, P> const& v);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<1, U, P> const& v);
+
+		// -- Swizzle constructors --
+/*
+#		if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+			template<int E0>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<1, T, Q, E0, -1,-2,-3> const& that)
+			{
+				*this = that();
+			}
+#		endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+*/
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec const& v) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator+=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator-=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator*=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator/=(vec<1, U, Q> const& v);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator++();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator--();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator++(int);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator--(int);
+
+		// -- Unary bit operators --
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator%=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator&=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator|=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator^=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator<<=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator>>=(vec<1, U, Q> const& v);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator~(vec<1, T, Q> const& v);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec1.inl"
+#endif//GLM_EXTERNAL_TEMPLATE

third_party/glm/detail/type_vec1.inl

@@ -0,0 +1,551 @@
+/// @ref core
+
+#include "./compute_vector_relational.hpp"
+
+namespace glm
+{
+	// -- Implicit basic constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec()
+#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+				: x(0)
+#			endif
+		{}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, Q> const& v)
+			: x(v.x)
+		{}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, P> const& v)
+		: x(v.x)
+	{}
+
+	// -- Explicit basic constructors --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(T scalar)
+		: x(scalar)
+	{}
+
+	// -- Conversion vector constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, U, P> const& v)
+		: x(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<2, U, P> const& v)
+		: x(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<3, U, P> const& v)
+		: x(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<4, U, P> const& v)
+		: x(static_cast<T>(v.x))
+	{}
+
+	// -- Component accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type)
+	{
+		return x;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type) const
+	{
+		return x;
+	}
+
+	// -- Unary arithmetic operators --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, T, Q> const& v)
+		{
+			this->x = v.x;
+			return *this;
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, U, Q> const& v)
+	{
+		this->x = static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator+=(U scalar)
+	{
+		this->x += static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator+=(vec<1, U, Q> const& v)
+	{
+		this->x += static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator-=(U scalar)
+	{
+		this->x -= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator-=(vec<1, U, Q> const& v)
+	{
+		this->x -= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator*=(U scalar)
+	{
+		this->x *= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator*=(vec<1, U, Q> const& v)
+	{
+		this->x *= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator/=(U scalar)
+	{
+		this->x /= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator/=(vec<1, U, Q> const& v)
+	{
+		this->x /= static_cast<T>(v.x);
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator++()
+	{
+		++this->x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator--()
+	{
+		--this->x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> vec<1, T, Q>::operator++(int)
+	{
+		vec<1, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> vec<1, T, Q>::operator--(int)
+	{
+		vec<1, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator%=(U scalar)
+	{
+		this->x %= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator%=(vec<1, U, Q> const& v)
+	{
+		this->x %= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator&=(U scalar)
+	{
+		this->x &= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator&=(vec<1, U, Q> const& v)
+	{
+		this->x &= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator|=(U scalar)
+	{
+		this->x |= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator|=(vec<1, U, Q> const& v)
+	{
+		this->x |= U(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator^=(U scalar)
+	{
+		this->x ^= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator^=(vec<1, U, Q> const& v)
+	{
+		this->x ^= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator<<=(U scalar)
+	{
+		this->x <<= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator<<=(vec<1, U, Q> const& v)
+	{
+		this->x <<= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator>>=(U scalar)
+	{
+		this->x >>= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator>>=(vec<1, U, Q> const& v)
+	{
+		this->x >>= static_cast<T>(v.x);
+		return *this;
+	}
+
+	// -- Unary constant operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			-v.x);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar + v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x + v2.x);
+	}
+
+	//operator-
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar - v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x - v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar * v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x * v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar / v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x / v2.x);
+	}
+
+	// -- Binary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x % scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar % v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x % v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x & scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar & v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x & v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x | scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar | v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x | v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x ^ scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar ^ v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x ^ v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			static_cast<T>(v.x << scalar));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar << v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x << v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x >> scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar >> v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x >> v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator~(vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			~v.x);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return !(v1 == v2);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2)
+	{
+		return vec<1, bool, Q>(v1.x && v2.x);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2)
+	{
+		return vec<1, bool, Q>(v1.x || v2.x);
+	}
+}//namespace glm

third_party/glm/detail/type_vec2.hpp

@@ -0,0 +1,399 @@
+/// @ref core
+/// @file glm/detail/type_vec2.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+#	include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+#	include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct vec<2, T, Q>
+	{
+		// -- Implementation detail --
+
+		typedef T value_type;
+		typedef vec<2, T, Q> type;
+		typedef vec<2, bool, Q> bool_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#			endif
+#		endif
+
+#		if GLM_CONFIG_XYZW_ONLY
+			T x, y;
+#		elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+			union
+			{
+				struct{ T x, y; };
+				struct{ T r, g; };
+				struct{ T s, t; };
+
+				typename detail::storage<2, T, detail::is_aligned<Q>::value>::type data;
+
+#				if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+					GLM_SWIZZLE2_2_MEMBERS(T, Q, x, y)
+					GLM_SWIZZLE2_2_MEMBERS(T, Q, r, g)
+					GLM_SWIZZLE2_2_MEMBERS(T, Q, s, t)
+					GLM_SWIZZLE2_3_MEMBERS(T, Q, x, y)
+					GLM_SWIZZLE2_3_MEMBERS(T, Q, r, g)
+					GLM_SWIZZLE2_3_MEMBERS(T, Q, s, t)
+					GLM_SWIZZLE2_4_MEMBERS(T, Q, x, y)
+					GLM_SWIZZLE2_4_MEMBERS(T, Q, r, g)
+					GLM_SWIZZLE2_4_MEMBERS(T, Q, s, t)
+#				endif
+			};
+#		else
+			union {T x, r, s;};
+			union {T y, g, t;};
+
+#			if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, Q)
+#			endif//GLM_CONFIG_SWIZZLE
+#		endif
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		/// Return the count of components of the vector
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T& operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, T, P> const& v);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(T x, T y);
+
+		// -- Conversion constructors --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, B y);
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const& x, B y);
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, vec<1, B, Q> const& y);
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const& x, vec<1, B, Q> const& y);
+
+		// -- Conversion vector constructors --
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, P> const& v);
+
+		// -- Swizzle constructors --
+#		if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1,-1,-2> const& that)
+			{
+				*this = that();
+			}
+#		endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec const& v) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(vec<2, U, Q> const& v);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator++();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator--();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator++(int);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator--(int);
+
+		// -- Unary bit operators --
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(vec<2, U, Q> const& v);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator~(vec<2, T, Q> const& v);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec2.inl"
+#endif//GLM_EXTERNAL_TEMPLATE

third_party/glm/detail/type_vec2.inl

@@ -0,0 +1,913 @@
+/// @ref core
+
+#include "./compute_vector_relational.hpp"
+
+namespace glm
+{
+	// -- Implicit basic constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec()
+#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+				: x(0), y(0)
+#			endif
+		{}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, T, Q> const& v)
+			: x(v.x), y(v.y)
+		{}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, T, P> const& v)
+		: x(v.x), y(v.y)
+	{}
+
+	// -- Explicit basic constructors --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(T scalar)
+		: x(scalar), y(scalar)
+	{}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(T _x, T _y)
+		: x(_x), y(_y)
+	{}
+
+	// -- Conversion scalar constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(A _x, B _y)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, A, Q> const& _x, B _y)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(A _x, vec<1, B, Q> const& _y)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, A, Q> const& _x, vec<1, B, Q> const& _y)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y.x))
+	{}
+
+	// -- Conversion vector constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<3, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<4, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.y))
+	{}
+
+	// -- Component accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i)
+	{
+		assert(i >= 0 && i < this->length());
+		switch(i)
+		{
+		default:
+		case 0:
+			return x;
+		case 1:
+			return y;
+		}
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i) const
+	{
+		assert(i >= 0 && i < this->length());
+		switch(i)
+		{
+		default:
+		case 0:
+			return x;
+		case 1:
+			return y;
+		}
+	}
+
+	// -- Unary arithmetic operators --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, T, Q> const& v)
+		{
+			this->x = v.x;
+			this->y = v.y;
+			return *this;
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, U, Q> const& v)
+	{
+		this->x = static_cast<T>(v.x);
+		this->y = static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(U scalar)
+	{
+		this->x += static_cast<T>(scalar);
+		this->y += static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<1, U, Q> const& v)
+	{
+		this->x += static_cast<T>(v.x);
+		this->y += static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<2, U, Q> const& v)
+	{
+		this->x += static_cast<T>(v.x);
+		this->y += static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(U scalar)
+	{
+		this->x -= static_cast<T>(scalar);
+		this->y -= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<1, U, Q> const& v)
+	{
+		this->x -= static_cast<T>(v.x);
+		this->y -= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<2, U, Q> const& v)
+	{
+		this->x -= static_cast<T>(v.x);
+		this->y -= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(U scalar)
+	{
+		this->x *= static_cast<T>(scalar);
+		this->y *= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<1, U, Q> const& v)
+	{
+		this->x *= static_cast<T>(v.x);
+		this->y *= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<2, U, Q> const& v)
+	{
+		this->x *= static_cast<T>(v.x);
+		this->y *= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(U scalar)
+	{
+		this->x /= static_cast<T>(scalar);
+		this->y /= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<1, U, Q> const& v)
+	{
+		this->x /= static_cast<T>(v.x);
+		this->y /= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<2, U, Q> const& v)
+	{
+		this->x /= static_cast<T>(v.x);
+		this->y /= static_cast<T>(v.y);
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator++()
+	{
+		++this->x;
+		++this->y;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator--()
+	{
+		--this->x;
+		--this->y;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> vec<2, T, Q>::operator++(int)
+	{
+		vec<2, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> vec<2, T, Q>::operator--(int)
+	{
+		vec<2, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(U scalar)
+	{
+		this->x %= static_cast<T>(scalar);
+		this->y %= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<1, U, Q> const& v)
+	{
+		this->x %= static_cast<T>(v.x);
+		this->y %= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<2, U, Q> const& v)
+	{
+		this->x %= static_cast<T>(v.x);
+		this->y %= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(U scalar)
+	{
+		this->x &= static_cast<T>(scalar);
+		this->y &= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<1, U, Q> const& v)
+	{
+		this->x &= static_cast<T>(v.x);
+		this->y &= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<2, U, Q> const& v)
+	{
+		this->x &= static_cast<T>(v.x);
+		this->y &= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(U scalar)
+	{
+		this->x |= static_cast<T>(scalar);
+		this->y |= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<1, U, Q> const& v)
+	{
+		this->x |= static_cast<T>(v.x);
+		this->y |= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<2, U, Q> const& v)
+	{
+		this->x |= static_cast<T>(v.x);
+		this->y |= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(U scalar)
+	{
+		this->x ^= static_cast<T>(scalar);
+		this->y ^= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<1, U, Q> const& v)
+	{
+		this->x ^= static_cast<T>(v.x);
+		this->y ^= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<2, U, Q> const& v)
+	{
+		this->x ^= static_cast<T>(v.x);
+		this->y ^= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(U scalar)
+	{
+		this->x <<= static_cast<T>(scalar);
+		this->y <<= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<1, U, Q> const& v)
+	{
+		this->x <<= static_cast<T>(v.x);
+		this->y <<= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<2, U, Q> const& v)
+	{
+		this->x <<= static_cast<T>(v.x);
+		this->y <<= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(U scalar)
+	{
+		this->x >>= static_cast<T>(scalar);
+		this->y >>= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<1, U, Q> const& v)
+	{
+		this->x >>= static_cast<T>(v.x);
+		this->y >>= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<2, U, Q> const& v)
+	{
+		this->x >>= static_cast<T>(v.x);
+		this->y >>= static_cast<T>(v.y);
+		return *this;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			-v.x,
+			-v.y);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x + scalar,
+			v.y + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x + v2.x,
+			v1.y + v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar + v.x,
+			scalar + v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x + v2.x,
+			v1.x + v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x + v2.x,
+			v1.y + v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x - scalar,
+			v.y - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x - v2.x,
+			v1.y - v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar - v.x,
+			scalar - v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x - v2.x,
+			v1.x - v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x - v2.x,
+			v1.y - v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x * scalar,
+			v.y * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x * v2.x,
+			v1.y * v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar * v.x,
+			scalar * v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x * v2.x,
+			v1.x * v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x * v2.x,
+			v1.y * v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x / scalar,
+			v.y / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x / v2.x,
+			v1.y / v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar / v.x,
+			scalar / v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x / v2.x,
+			v1.x / v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x / v2.x,
+			v1.y / v2.y);
+	}
+
+	// -- Binary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x % scalar,
+			v.y % scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x % v2.x,
+			v1.y % v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar % v.x,
+			scalar % v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x % v2.x,
+			v1.x % v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x % v2.x,
+			v1.y % v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x & scalar,
+			v.y & scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x & v2.x,
+			v1.y & v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar & v.x,
+			scalar & v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x & v2.x,
+			v1.x & v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x & v2.x,
+			v1.y & v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x | scalar,
+			v.y | scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x | v2.x,
+			v1.y | v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar | v.x,
+			scalar | v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x | v2.x,
+			v1.x | v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x | v2.x,
+			v1.y | v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x ^ scalar,
+			v.y ^ scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x ^ v2.x,
+			v1.y ^ v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar ^ v.x,
+			scalar ^ v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x ^ v2.x,
+			v1.x ^ v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x ^ v2.x,
+			v1.y ^ v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x << scalar,
+			v.y << scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x << v2.x,
+			v1.y << v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar << v.x,
+			scalar << v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x << v2.x,
+			v1.x << v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x << v2.x,
+			v1.y << v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x >> scalar,
+			v.y >> scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x >> v2.x,
+			v1.y >> v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar >> v.x,
+			scalar >> v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x >> v2.x,
+			v1.x >> v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x >> v2.x,
+			v1.y >> v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator~(vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			~v.x,
+			~v.y);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return
+			detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x) &&
+			detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.y, v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return !(v1 == v2);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2)
+	{
+		return vec<2, bool, Q>(v1.x && v2.x, v1.y && v2.y);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2)
+	{
+		return vec<2, bool, Q>(v1.x || v2.x, v1.y || v2.y);
+	}
+}//namespace glm

third_party/glm/detail/type_vec3.hpp

@@ -0,0 +1,432 @@
+/// @ref core
+/// @file glm/detail/type_vec3.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+#	include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+#	include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct vec<3, T, Q>
+	{
+		// -- Implementation detail --
+
+		typedef T value_type;
+		typedef vec<3, T, Q> type;
+		typedef vec<3, bool, Q> bool_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#				if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+#					pragma warning(disable: 4324)  // structure was padded due to alignment specifier
+#				endif
+#			endif
+#		endif
+
+#		if GLM_CONFIG_XYZW_ONLY
+			T x, y, z;
+#		elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+			union
+			{
+				struct{ T x, y, z; };
+				struct{ T r, g, b; };
+				struct{ T s, t, p; };
+
+				typename detail::storage<3, T, detail::is_aligned<Q>::value>::type data;
+
+#				if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+					GLM_SWIZZLE3_2_MEMBERS(T, Q, x, y, z)
+					GLM_SWIZZLE3_2_MEMBERS(T, Q, r, g, b)
+					GLM_SWIZZLE3_2_MEMBERS(T, Q, s, t, p)
+					GLM_SWIZZLE3_3_MEMBERS(T, Q, x, y, z)
+					GLM_SWIZZLE3_3_MEMBERS(T, Q, r, g, b)
+					GLM_SWIZZLE3_3_MEMBERS(T, Q, s, t, p)
+					GLM_SWIZZLE3_4_MEMBERS(T, Q, x, y, z)
+					GLM_SWIZZLE3_4_MEMBERS(T, Q, r, g, b)
+					GLM_SWIZZLE3_4_MEMBERS(T, Q, s, t, p)
+#				endif
+			};
+#		else
+			union { T x, r, s; };
+			union { T y, g, t; };
+			union { T z, b, p; };
+
+#			if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, Q)
+#			endif//GLM_CONFIG_SWIZZLE
+#		endif//GLM_LANG
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		/// Return the count of components of the vector
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 3;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, T, P> const& v);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(T a, T b, T c);
+
+		// -- Conversion scalar constructors --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X x, Y y, Z z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z);
+
+		// -- Conversion vector constructors --
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v);
+
+		// -- Swizzle constructors --
+#		if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+			template<int E0, int E1, int E2>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& that)
+			{
+				*this = that();
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& scalar)
+			{
+				*this = vec(v(), scalar);
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& scalar, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v)
+			{
+				*this = vec(scalar, v());
+			}
+#		endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q>& operator=(vec<3, T, Q> const& v) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(vec<3, U, Q> const& v);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator++();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator--();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator++(int);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator--(int);
+
+		// -- Unary bit operators --
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(vec<3, U, Q> const& v);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator~(vec<3, T, Q> const& v);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec3.inl"
+#endif//GLM_EXTERNAL_TEMPLATE

third_party/glm/detail/type_vec4.hpp

@@ -0,0 +1,505 @@
+/// @ref core
+/// @file glm/detail/type_vec4.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+#	include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+#	include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct vec<4, T, Q>
+	{
+		// -- Implementation detail --
+
+		typedef T value_type;
+		typedef vec<4, T, Q> type;
+		typedef vec<4, bool, Q> bool_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#			endif
+#		endif
+
+#		if GLM_CONFIG_XYZW_ONLY
+			T x, y, z, w;
+#		elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+			union
+			{
+				struct { T x, y, z, w; };
+				struct { T r, g, b, a; };
+				struct { T s, t, p, q; };
+
+				typename detail::storage<4, T, detail::is_aligned<Q>::value>::type data;
+
+#				if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+					GLM_SWIZZLE4_2_MEMBERS(T, Q, x, y, z, w)
+					GLM_SWIZZLE4_2_MEMBERS(T, Q, r, g, b, a)
+					GLM_SWIZZLE4_2_MEMBERS(T, Q, s, t, p, q)
+					GLM_SWIZZLE4_3_MEMBERS(T, Q, x, y, z, w)
+					GLM_SWIZZLE4_3_MEMBERS(T, Q, r, g, b, a)
+					GLM_SWIZZLE4_3_MEMBERS(T, Q, s, t, p, q)
+					GLM_SWIZZLE4_4_MEMBERS(T, Q, x, y, z, w)
+					GLM_SWIZZLE4_4_MEMBERS(T, Q, r, g, b, a)
+					GLM_SWIZZLE4_4_MEMBERS(T, Q, s, t, p, q)
+#				endif
+			};
+#		else
+			union { T x, r, s; };
+			union { T y, g, t; };
+			union { T z, b, p; };
+			union { T w, a, q; };
+
+#			if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, Q)
+#			endif
+#		endif
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		typedef length_t length_type;
+
+		/// Return the count of components of the vector
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, Q> const& v) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, P> const& v);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(T x, T y, T z, T w);
+
+		// -- Conversion scalar constructors --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, Z _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _Y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+
+		// -- Conversion vector constructors --
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z, C _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, C _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z, vec<1, C, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, vec<1, C, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz, C _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, C _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, B _y, vec<2, C, P> const& _zw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, B _y, vec<2, C, P> const& _zw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, P> const& _xyz, B _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, P> const& _xyz, vec<1, B, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<3, B, P> const& _yzw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<3, B, P> const& _yzw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<2, B, P> const& _zw);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+		// -- Swizzle constructors --
+#		if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+			template<int E0, int E1, int E2, int E3>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<4, T, Q, E0, E1, E2, E3> const& that)
+			{
+				*this = that();
+			}
+
+			template<int E0, int E1, int F0, int F1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, detail::_swizzle<2, T, Q, F0, F1, -1, -2> const& u)
+			{
+				*this = vec<4, T, Q>(v(), u());
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, T const& y, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v)
+			{
+				*this = vec<4, T, Q>(x, y, v());
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& w)
+			{
+				*this = vec<4, T, Q>(x, v(), w);
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& z, T const& w)
+			{
+				*this = vec<4, T, Q>(v(), z, w);
+			}
+
+			template<int E0, int E1, int E2>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v, T const& w)
+			{
+				*this = vec<4, T, Q>(v(), w);
+			}
+
+			template<int E0, int E1, int E2>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v)
+			{
+				*this = vec<4, T, Q>(x, v());
+			}
+#		endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, T, Q> const& v) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(vec<4, U, Q> const& v);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator++();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator--();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator++(int);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator--(int);
+
+		// -- Unary bit operators --
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(vec<4, U, Q> const& v);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v, T const & scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v, T const & scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, T const & scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v, T const & scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator~(vec<4, T, Q> const& v);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> operator&&(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> operator||(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec4.inl"
+#endif//GLM_EXTERNAL_TEMPLATE

third_party/glm/detail/type_vec4_simd.inl

@@ -0,0 +1,775 @@
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	template<qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<4, float, Q, E0,E1,E2,E3, true> : public _swizzle_base0<float, 4>
+	{
+		GLM_FUNC_QUALIFIER vec<4, float, Q> operator ()()  const
+		{
+			__m128 data = *reinterpret_cast<__m128 const*>(&this->_buffer);
+
+			vec<4, float, Q> Result;
+#			if GLM_ARCH & GLM_ARCH_AVX_BIT
+				Result.data = _mm_permute_ps(data, _MM_SHUFFLE(E3, E2, E1, E0));
+#			else
+				Result.data = _mm_shuffle_ps(data, data, _MM_SHUFFLE(E3, E2, E1, E0));
+#			endif
+			return Result;
+		}
+	};
+
+	template<qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<4, int, Q, E0,E1,E2,E3, true> : public _swizzle_base0<int, 4>
+	{
+		GLM_FUNC_QUALIFIER vec<4, int, Q> operator ()()  const
+		{
+			__m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);
+
+			vec<4, int, Q> Result;
+			Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0));
+			return Result;
+		}
+	};
+
+	template<qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<4, uint, Q, E0,E1,E2,E3, true> : public _swizzle_base0<uint, 4>
+	{
+		GLM_FUNC_QUALIFIER vec<4, uint, Q> operator ()()  const
+		{
+			__m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);
+
+			vec<4, uint, Q> Result;
+			Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0));
+			return Result;
+		}
+	};
+#	endif// GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+	template<qualifier Q>
+	struct compute_vec4_add<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_add_ps(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_vec4_add<double, Q, true>
+	{
+		static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+		{
+			vec<4, double, Q> Result;
+			Result.data = _mm256_add_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_sub<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_sub_ps(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_vec4_sub<double, Q, true>
+	{
+		static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+		{
+			vec<4, double, Q> Result;
+			Result.data = _mm256_sub_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_mul<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_mul_ps(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_vec4_mul<double, Q, true>
+	{
+		static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+		{
+			vec<4, double, Q> Result;
+			Result.data = _mm256_mul_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_div<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_div_ps(a.data, b.data);
+			return Result;
+		}
+	};
+
+	#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_vec4_div<double, Q, true>
+	{
+		static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+		{
+			vec<4, double, Q> Result;
+			Result.data = _mm256_div_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<>
+	struct compute_vec4_div<float, aligned_lowp, true>
+	{
+		static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& a, vec<4, float, aligned_lowp> const& b)
+		{
+			vec<4, float, aligned_lowp> Result;
+			Result.data = _mm_mul_ps(a.data, _mm_rcp_ps(b.data));
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_and<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_and_si128(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_and<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_and_si256(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_or<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_or_si128(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_or<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_or_si256(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_xor<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_xor_si128(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_xor<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_xor_si256(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_shift_left<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_sll_epi32(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_shift_left<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_sll_epi64(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_shift_right<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_srl_epi32(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_shift_right<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_srl_epi64(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_bitwise_not<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& v)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_xor_si128(v.data, _mm_set1_epi32(-1));
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_bitwise_not<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& v)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_xor_si256(v.data, _mm_set1_epi32(-1));
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_equal<float, Q, false, 32, true>
+	{
+		static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			return _mm_movemask_ps(_mm_cmpeq_ps(v1.data, v2.data)) != 0;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_SSE41_BIT
+	template<qualifier Q>
+	struct compute_vec4_equal<int, Q, true, 32, true>
+	{
+		static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			//return _mm_movemask_epi8(_mm_cmpeq_epi32(v1.data, v2.data)) != 0;
+			__m128i neq = _mm_xor_si128(v1.data, v2.data);
+			return _mm_test_all_zeros(neq, neq) == 0;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_nequal<float, Q, false, 32, true>
+	{
+		static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			return _mm_movemask_ps(_mm_cmpneq_ps(v1.data, v2.data)) != 0;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_SSE41_BIT
+	template<qualifier Q>
+	struct compute_vec4_nequal<int, Q, true, 32, true>
+	{
+		static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			//return _mm_movemask_epi8(_mm_cmpneq_epi32(v1.data, v2.data)) != 0;
+			__m128i neq = _mm_xor_si128(v1.data, v2.data);
+			return _mm_test_all_zeros(neq, neq) != 0;
+		}
+	};
+#	endif
+}//namespace detail
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _s) :
+		data(_mm_set1_ps(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _s) :
+		data(_mm_set1_ps(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _s) :
+		data(_mm_set1_ps(_s))
+	{}
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_lowp>::vec(double _s) :
+		data(_mm256_set1_pd(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_mediump>::vec(double _s) :
+		data(_mm256_set1_pd(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_highp>::vec(double _s) :
+		data(_mm256_set1_pd(_s))
+	{}
+#	endif
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _s) :
+		data(_mm_set1_epi32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _s) :
+		data(_mm_set1_epi32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _s) :
+		data(_mm_set1_epi32(_s))
+	{}
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_lowp>::vec(detail::int64 _s) :
+		data(_mm256_set1_epi64x(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_mediump>::vec(detail::int64 _s) :
+		data(_mm256_set1_epi64x(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_highp>::vec(detail::int64 _s) :
+		data(_mm256_set1_epi64x(_s))
+	{}
+#	endif
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _x, float _y, float _z, float _w) :
+		data(_mm_set_ps(_w, _z, _y, _x))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _x, float _y, float _z, float _w) :
+		data(_mm_set_ps(_w, _z, _y, _x))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _x, float _y, float _z, float _w) :
+		data(_mm_set_ps(_w, _z, _y, _x))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_set_epi32(_w, _z, _y, _x))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_set_epi32(_w, _z, _y, _x))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_set_epi32(_w, _z, _y, _x))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x)))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x)))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x)))
+	{}
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#if GLM_ARCH & GLM_ARCH_NEON_BIT
+namespace glm {
+namespace detail {
+
+	template<qualifier Q>
+	struct compute_vec4_add<float, Q, true>
+	{
+		static
+		vec<4, float, Q>
+		call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = vaddq_f32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_add<uint, Q, true>
+	{
+		static
+		vec<4, uint, Q>
+		call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
+		{
+			vec<4, uint, Q> Result;
+			Result.data = vaddq_u32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_add<int, Q, true>
+	{
+		static
+		vec<4, int, Q>
+		call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
+		{
+			vec<4, uint, Q> Result;
+			Result.data = vaddq_s32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_sub<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = vsubq_f32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_sub<uint, Q, true>
+	{
+		static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
+		{
+			vec<4, uint, Q> Result;
+			Result.data = vsubq_u32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_sub<int, Q, true>
+	{
+		static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
+		{
+			vec<4, int, Q> Result;
+			Result.data = vsubq_s32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_mul<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = vmulq_f32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_mul<uint, Q, true>
+	{
+		static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
+		{
+			vec<4, uint, Q> Result;
+			Result.data = vmulq_u32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_mul<int, Q, true>
+	{
+		static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
+		{
+			vec<4, int, Q> Result;
+			Result.data = vmulq_s32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_div<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = vdivq_f32(a.data, b.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_equal<float, Q, false, 32, true>
+	{
+		static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			uint32x4_t cmp = vceqq_f32(v1.data, v2.data);
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+			cmp = vpminq_u32(cmp, cmp);
+			cmp = vpminq_u32(cmp, cmp);
+			uint32_t r = cmp[0];
+#else
+			uint32x2_t cmpx2 = vpmin_u32(vget_low_f32(cmp), vget_high_f32(cmp));
+			cmpx2 = vpmin_u32(cmpx2, cmpx2);
+			uint32_t r = cmpx2[0];
+#endif
+			return r == ~0u;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_equal<uint, Q, false, 32, true>
+	{
+		static bool call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+		{
+			uint32x4_t cmp = vceqq_u32(v1.data, v2.data);
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+			cmp = vpminq_u32(cmp, cmp);
+			cmp = vpminq_u32(cmp, cmp);
+			uint32_t r = cmp[0];
+#else
+			uint32x2_t cmpx2 = vpmin_u32(vget_low_f32(cmp), vget_high_f32(cmp));
+			cmpx2 = vpmin_u32(cmpx2, cmpx2);
+			uint32_t r = cmpx2[0];
+#endif
+			return r == ~0u;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_equal<int, Q, false, 32, true>
+	{
+		static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			uint32x4_t cmp = vceqq_s32(v1.data, v2.data);
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+			cmp = vpminq_u32(cmp, cmp);
+			cmp = vpminq_u32(cmp, cmp);
+			uint32_t r = cmp[0];
+#else
+			uint32x2_t cmpx2 = vpmin_u32(vget_low_f32(cmp), vget_high_f32(cmp));
+			cmpx2 = vpmin_u32(cmpx2, cmpx2);
+			uint32_t r = cmpx2[0];
+#endif
+			return r == ~0u;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_nequal<float, Q, false, 32, true>
+	{
+		static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			return !compute_vec4_equal<float, Q, false, 32, true>::call(v1, v2);
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_nequal<uint, Q, false, 32, true>
+	{
+		static bool call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+		{
+			return !compute_vec4_equal<uint, Q, false, 32, true>::call(v1, v2);
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_vec4_nequal<int, Q, false, 32, true>
+	{
+		static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			return !compute_vec4_equal<int, Q, false, 32, true>::call(v1, v2);
+		}
+	};
+
+}//namespace detail
+
+#if !GLM_CONFIG_XYZW_ONLY
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _s) :
+		data(vdupq_n_f32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _s) :
+		data(vdupq_n_f32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _s) :
+		data(vdupq_n_f32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _s) :
+		data(vdupq_n_s32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _s) :
+		data(vdupq_n_s32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _s) :
+		data(vdupq_n_s32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, uint, aligned_lowp>::vec(uint _s) :
+		data(vdupq_n_u32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, uint, aligned_mediump>::vec(uint _s) :
+		data(vdupq_n_u32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, uint, aligned_highp>::vec(uint _s) :
+		data(vdupq_n_u32(_s))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(const vec<4, float, aligned_highp>& rhs) :
+		data(rhs.data)
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(const vec<4, int, aligned_highp>& rhs) :
+		data(vcvtq_f32_s32(rhs.data))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(const vec<4, uint, aligned_highp>& rhs) :
+		data(vcvtq_f32_u32(rhs.data))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(int _x, int _y, int _z, int _w) :
+		data(vcvtq_f32_s32(vec<4, int, aligned_lowp>(_x, _y, _z, _w).data))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(int _x, int _y, int _z, int _w) :
+		data(vcvtq_f32_s32(vec<4, int, aligned_mediump>(_x, _y, _z, _w).data))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(int _x, int _y, int _z, int _w) :
+		data(vcvtq_f32_s32(vec<4, int, aligned_highp>(_x, _y, _z, _w).data))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(uint _x, uint _y, uint _z, uint _w) :
+		data(vcvtq_f32_u32(vec<4, uint, aligned_lowp>(_x, _y, _z, _w).data))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(uint _x, uint _y, uint _z, uint _w) :
+		data(vcvtq_f32_u32(vec<4, uint, aligned_mediump>(_x, _y, _z, _w).data))
+	{}
+
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(uint _x, uint _y, uint _z, uint _w) :
+		data(vcvtq_f32_u32(vec<4, uint, aligned_highp>(_x, _y, _z, _w).data))
+	{}
+
+#endif
+}//namespace glm
+
+#endif