Compare commits
13 commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
7e634052c5 | ||
|
|
f634d70a2f | ||
|
|
86468a9ce4 | ||
|
|
48c2cd6386 | ||
|
|
2fae908a55 | ||
|
|
fc8a1b2d35 | ||
|
|
2e5a07c847 | ||
|
|
70835b8593 | ||
|
|
fcadf735c9 | ||
|
|
e3febb936e | ||
|
|
8ad43456cf | ||
|
|
e9f81dcb31 | ||
|
|
7109d72f34 |
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -1,4 +1,3 @@
|
||||||
.vs
|
.vs
|
||||||
out
|
out
|
||||||
3rdparty
|
|
||||||
*.json
|
*.json
|
||||||
3
.gitmodules
vendored
3
.gitmodules
vendored
|
|
@ -1,3 +0,0 @@
|
||||||
[submodule "SDLFramework"]
|
|
||||||
path = SDLFramework
|
|
||||||
url = https://github.com/Lauchmelder23/SDLFramework
|
|
||||||
|
|
@ -1,11 +1,10 @@
|
||||||
# CMakeList.txt : Top-level CMake project file, do global configuration
|
cmake_minimum_required(VERSION 3.7)
|
||||||
# and include sub-projects here.
|
|
||||||
#
|
|
||||||
cmake_minimum_required (VERSION 3.8)
|
|
||||||
set(CMAKE_CXX_STANDARD 17)
|
|
||||||
|
|
||||||
project("ComplexPlotting")
|
project("ComplexPlotting")
|
||||||
|
|
||||||
# Include sub-projects.
|
set(CMAKE_CXX_STANDARD 17)
|
||||||
add_subdirectory ("SDLFramework")
|
|
||||||
add_subdirectory ("ComplexPlotting")
|
find_package(OpenGL REQUIRED)
|
||||||
|
find_package(glfw3 REQUIRED)
|
||||||
|
|
||||||
|
add_subdirectory("src")
|
||||||
|
|
@ -1,27 +0,0 @@
|
||||||
# CMakeList.txt : CMake project for ComplexPlotting, include source and define
|
|
||||||
# project specific logic here.
|
|
||||||
#
|
|
||||||
cmake_minimum_required (VERSION 3.8)
|
|
||||||
|
|
||||||
if(WIN32)
|
|
||||||
file(GLOB SDL2_LIBRARIES
|
|
||||||
${SDL2_INCLUDES}/*.lib
|
|
||||||
)
|
|
||||||
else()
|
|
||||||
|
|
||||||
endif()
|
|
||||||
|
|
||||||
# Add source to this project's executable.
|
|
||||||
add_executable (ComplexPlotting
|
|
||||||
"main.cpp"
|
|
||||||
"PlotWindow.hpp" "PlotWindow.cpp" "PlotWindowManager.hpp" "PlotWindowException.hpp")
|
|
||||||
|
|
||||||
target_include_directories(ComplexPlotting PRIVATE
|
|
||||||
${SDL2_INCLUDES}
|
|
||||||
${CMAKE_SOURCE_DIR}/SDLFramework/src/sdlf
|
|
||||||
)
|
|
||||||
|
|
||||||
target_link_libraries(ComplexPlotting PRIVATE
|
|
||||||
${SDL2_LIBRARIES}
|
|
||||||
sdlf
|
|
||||||
)
|
|
||||||
|
|
@ -1,128 +0,0 @@
|
||||||
#include "PlotWindow.hpp"
|
|
||||||
#include "PlotWindowException.hpp"
|
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
#define PI 3.1415926535f
|
|
||||||
|
|
||||||
#define MAP(x, A, B, a, b) ((x - A) * (b - a) / (B - A) + a)
|
|
||||||
|
|
||||||
SDL_Color HSVtoRGB(float H, float S, float V)
|
|
||||||
{
|
|
||||||
float s = S / 100;
|
|
||||||
float v = V / 100;
|
|
||||||
float C = s * v;
|
|
||||||
float X = C * (1 - abs(fmod(H / 60.0, 2) - 1));
|
|
||||||
float m = v - C;
|
|
||||||
float r, g, b;
|
|
||||||
if (H >= 0 && H < 60) {
|
|
||||||
r = C, g = X, b = 0;
|
|
||||||
}
|
|
||||||
else if (H >= 60 && H < 120) {
|
|
||||||
r = X, g = C, b = 0;
|
|
||||||
}
|
|
||||||
else if (H >= 120 && H < 180) {
|
|
||||||
r = 0, g = C, b = X;
|
|
||||||
}
|
|
||||||
else if (H >= 180 && H < 240) {
|
|
||||||
r = 0, g = X, b = C;
|
|
||||||
}
|
|
||||||
else if (H >= 240 && H < 300) {
|
|
||||||
r = X, g = 0, b = C;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
r = C, g = 0, b = X;
|
|
||||||
}
|
|
||||||
Uint8 R = (r + m) * 255;
|
|
||||||
Uint8 G = (g + m) * 255;
|
|
||||||
Uint8 B = (b + m) * 255;
|
|
||||||
|
|
||||||
return SDL_Color{ R, G, B, 255 };
|
|
||||||
}
|
|
||||||
|
|
||||||
PlotWindow::PlotWindow(Uint32 id, std::string title, float rLow, float rHigh, float iLow, float iHigh) :
|
|
||||||
IWindow::IWindow(
|
|
||||||
UnitVector2u * 400,
|
|
||||||
UnitVector2i* SDL_WINDOWPOS_UNDEFINED,
|
|
||||||
"Plot " + std::to_string(id) + " [" + title + "]",
|
|
||||||
NULL),
|
|
||||||
id(id), texture(nullptr),
|
|
||||||
low({ rLow, iLow }), high({rHigh, iHigh}),
|
|
||||||
w(0), h(0)
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void PlotWindow::SetCallback(CmplxFunc callback)
|
|
||||||
{
|
|
||||||
this->callback = callback;
|
|
||||||
}
|
|
||||||
|
|
||||||
void PlotWindow::DrawTexture()
|
|
||||||
{
|
|
||||||
SDL_SetRenderTarget(m_pRenderer, texture);
|
|
||||||
for (int y = 0; y < h; y++)
|
|
||||||
{
|
|
||||||
for (int x = 0; x < h; x++)
|
|
||||||
{
|
|
||||||
float a = std::arg(callback(std::complex<float>
|
|
||||||
{
|
|
||||||
MAP((float)x, 0, w, low.real(), high.real()),
|
|
||||||
MAP((float)y, 0, h, low.real(), high.real())
|
|
||||||
}
|
|
||||||
));
|
|
||||||
a = a / PI * 180;
|
|
||||||
if (a < 0)
|
|
||||||
a = 360 + a;
|
|
||||||
|
|
||||||
SDL_Color c = HSVtoRGB(a, 100, 100);
|
|
||||||
|
|
||||||
SDL_SetRenderDrawColor(m_pRenderer, c.r, c.g, c.b, c.a);
|
|
||||||
SDL_RenderDrawPoint(m_pRenderer, x, y);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
SDL_SetRenderTarget(m_pRenderer, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool PlotWindow::OnCreate()
|
|
||||||
{
|
|
||||||
SDL_GetWindowSize(m_pWindow, &w, &h);
|
|
||||||
texture = SDL_CreateTexture(m_pRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, w, h);
|
|
||||||
if (texture == nullptr)
|
|
||||||
throw PlotWindowException("Failed to create SDL_Texture.", this);
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool PlotWindow::OnEvent(const SDL_Event& e)
|
|
||||||
{
|
|
||||||
if (e.window.windowID != m_uWindowID)
|
|
||||||
return true;
|
|
||||||
|
|
||||||
switch (e.window.event)
|
|
||||||
{
|
|
||||||
case SDL_WINDOWEVENT_CLOSE:
|
|
||||||
m_isWindowOpen = false;
|
|
||||||
return false;
|
|
||||||
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool PlotWindow::OnUpdate(double frametime)
|
|
||||||
{
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
void PlotWindow::OnRender(SDL_Renderer* renderer)
|
|
||||||
{
|
|
||||||
SDL_RenderClear(m_pRenderer);
|
|
||||||
SDL_RenderCopy(m_pRenderer, texture, NULL, NULL);
|
|
||||||
|
|
||||||
SDL_RenderPresent(m_pRenderer);
|
|
||||||
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
@ -1,36 +0,0 @@
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include <complex>
|
|
||||||
#include <functional>
|
|
||||||
|
|
||||||
#include <SDL.h>
|
|
||||||
|
|
||||||
#include "Window.hpp"
|
|
||||||
|
|
||||||
using namespace sf;
|
|
||||||
|
|
||||||
typedef std::function<std::complex<float>(std::complex<float>)> CmplxFunc;
|
|
||||||
|
|
||||||
class PlotWindow :
|
|
||||||
public IWindow
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
PlotWindow(Uint32 id, std::string title, float rLow, float rHigh, float iLow, float iHigh);
|
|
||||||
|
|
||||||
void SetCallback(CmplxFunc callback);
|
|
||||||
void DrawTexture();
|
|
||||||
|
|
||||||
bool OnCreate() override;
|
|
||||||
bool OnEvent(const SDL_Event& e) override;
|
|
||||||
bool OnUpdate(double frametime = 0) override;
|
|
||||||
void OnRender(SDL_Renderer* renderer = nullptr) override;
|
|
||||||
|
|
||||||
private:
|
|
||||||
Uint32 id;
|
|
||||||
CmplxFunc callback;
|
|
||||||
|
|
||||||
SDL_Texture* texture;
|
|
||||||
int w, h;
|
|
||||||
|
|
||||||
std::complex<float> low, high;
|
|
||||||
};
|
|
||||||
|
|
@ -1,21 +0,0 @@
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include "PlotWindow.hpp"
|
|
||||||
|
|
||||||
class PlotWindowException :
|
|
||||||
public std::exception
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
PlotWindowException(const char* message, PlotWindow* src) :
|
|
||||||
std::exception(message), src(src)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
PlotWindow* where() const noexcept
|
|
||||||
{
|
|
||||||
return src;
|
|
||||||
}
|
|
||||||
|
|
||||||
protected:
|
|
||||||
PlotWindow* src;
|
|
||||||
};
|
|
||||||
|
|
@ -1,138 +0,0 @@
|
||||||
#include "PlotWindow.hpp"
|
|
||||||
|
|
||||||
#include "PlotWindowException.hpp"
|
|
||||||
|
|
||||||
#include <map>
|
|
||||||
#include <thread>
|
|
||||||
#include <future>
|
|
||||||
|
|
||||||
class PlotWindowManager
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
PlotWindowManager() = delete;
|
|
||||||
PlotWindowManager& operator=(const PlotWindowManager& other) = delete;
|
|
||||||
|
|
||||||
static PlotWindow* MakeNew(std::string title)
|
|
||||||
{
|
|
||||||
PlotWindow* plt = new PlotWindow(PlotWindowCount, title, -2.f, 2.f, -2.f, 2.f);
|
|
||||||
plt->Open();
|
|
||||||
|
|
||||||
// TODO: remove random values
|
|
||||||
float a = (float)(rand() % 200 - 100) / 100.f;
|
|
||||||
float b = (float)(rand() % 200 - 100) / 100.f;
|
|
||||||
plt->SetCallback(std::bind([a, b](std::complex<float> c)
|
|
||||||
{
|
|
||||||
return std::complex<float>{1, 1} / (c + std::complex<float>{1, 0})
|
|
||||||
+ std::complex<float>{2, 1} / (c + std::complex<float>{-1, 0});
|
|
||||||
},
|
|
||||||
std::placeholders::_1));
|
|
||||||
plt->DrawTexture();
|
|
||||||
|
|
||||||
PlotWindows.insert({ PlotWindowCount, plt });
|
|
||||||
PlotWindowCount++;
|
|
||||||
|
|
||||||
return plt;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void HandleEvents(const SDL_Event& e)
|
|
||||||
{
|
|
||||||
for (std::map<Uint32, PlotWindow*>::iterator it = PlotWindows.begin(); it != PlotWindows.end(); )
|
|
||||||
{
|
|
||||||
if (!it->second->OnEvent(e))
|
|
||||||
{
|
|
||||||
it->second->Stop();
|
|
||||||
delete it->second;
|
|
||||||
it->second = NULL;
|
|
||||||
it = PlotWindows.erase(it);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
it++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void Update()
|
|
||||||
{
|
|
||||||
// Check for input from the console
|
|
||||||
if (InputFuture.wait_for(std::chrono::milliseconds(0)) != std::future_status::timeout)
|
|
||||||
{
|
|
||||||
std::string title = InputFuture.get();
|
|
||||||
if (title != "")
|
|
||||||
{
|
|
||||||
try
|
|
||||||
{
|
|
||||||
PlotWindow* newWindow = MakeNew(title);
|
|
||||||
PrintThreadSafe("-- Success\n");
|
|
||||||
}
|
|
||||||
catch (PlotWindowException e)
|
|
||||||
{
|
|
||||||
PrintThreadSafe(e.what());
|
|
||||||
PrintThreadSafe("\n");
|
|
||||||
PrintThreadSafe("-- Failed.\n");
|
|
||||||
|
|
||||||
PlotWindow* src = e.where();
|
|
||||||
src->Stop();
|
|
||||||
delete src;
|
|
||||||
src = nullptr;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
InputPromise = std::promise<std::string>();
|
|
||||||
InputFuture = InputPromise.get_future();
|
|
||||||
|
|
||||||
InputThread.join();
|
|
||||||
InputThread = std::thread(PlotWindowManager::InputThreadFunc);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (std::map<Uint32, PlotWindow*>::iterator it = PlotWindows.begin(); it != PlotWindows.end(); it++)
|
|
||||||
it->second->OnUpdate();
|
|
||||||
}
|
|
||||||
|
|
||||||
static void Render()
|
|
||||||
{
|
|
||||||
for (std::map<Uint32, PlotWindow*>::iterator it = PlotWindows.begin(); it != PlotWindows.end(); it++)
|
|
||||||
it->second->OnRender();
|
|
||||||
}
|
|
||||||
|
|
||||||
static void Quit()
|
|
||||||
{
|
|
||||||
InputThread.detach();
|
|
||||||
}
|
|
||||||
|
|
||||||
static void PrintThreadSafe(std::string s, bool block = true)
|
|
||||||
{
|
|
||||||
if (block)
|
|
||||||
StdOutMutex.lock();
|
|
||||||
else
|
|
||||||
if (!StdOutMutex.try_lock())
|
|
||||||
return;
|
|
||||||
|
|
||||||
std::cout << s;
|
|
||||||
|
|
||||||
StdOutMutex.unlock();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
static inline Uint32 PlotWindowCount = 1;
|
|
||||||
static inline std::map<Uint32, PlotWindow*> PlotWindows;
|
|
||||||
|
|
||||||
static inline std::promise<std::string> InputPromise;
|
|
||||||
static inline std::future<std::string> InputFuture = InputPromise.get_future();
|
|
||||||
|
|
||||||
static inline std::mutex StdOutMutex;
|
|
||||||
|
|
||||||
private:
|
|
||||||
static void InputThreadFunc()
|
|
||||||
{
|
|
||||||
std::string in;
|
|
||||||
|
|
||||||
PrintThreadSafe("> ");
|
|
||||||
std::getline(std::cin, in);
|
|
||||||
|
|
||||||
InputPromise.set_value(in);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
static inline std::thread InputThread = std::thread(PlotWindowManager::InputThreadFunc);
|
|
||||||
};
|
|
||||||
|
|
@ -1,34 +0,0 @@
|
||||||
#include <stdio.h>
|
|
||||||
#include <vector>
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
#include "SDL.h"
|
|
||||||
#include "PlotWindowManager.hpp"
|
|
||||||
|
|
||||||
#undef main
|
|
||||||
|
|
||||||
int main(int argc, char** argv)
|
|
||||||
{
|
|
||||||
printf("Running on SDL %i.%i.%i\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
|
|
||||||
|
|
||||||
SDL_Init(SDL_INIT_VIDEO);
|
|
||||||
|
|
||||||
// Wait for window processes to end
|
|
||||||
SDL_Event e;
|
|
||||||
bool quit = false;
|
|
||||||
while (!quit)
|
|
||||||
{
|
|
||||||
while (SDL_PollEvent(&e))
|
|
||||||
{
|
|
||||||
PlotWindowManager::HandleEvents(e);
|
|
||||||
}
|
|
||||||
|
|
||||||
PlotWindowManager::Update();
|
|
||||||
|
|
||||||
PlotWindowManager::Render();
|
|
||||||
}
|
|
||||||
|
|
||||||
PlotWindowManager::Quit();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
674
LICENSE
674
LICENSE
|
|
@ -1,674 +0,0 @@
|
||||||
GNU GENERAL PUBLIC LICENSE
|
|
||||||
Version 3, 29 June 2007
|
|
||||||
|
|
||||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
|
||||||
Everyone is permitted to copy and distribute verbatim copies
|
|
||||||
of this license document, but changing it is not allowed.
|
|
||||||
|
|
||||||
Preamble
|
|
||||||
|
|
||||||
The GNU General Public License is a free, copyleft license for
|
|
||||||
software and other kinds of works.
|
|
||||||
|
|
||||||
The licenses for most software and other practical works are designed
|
|
||||||
to take away your freedom to share and change the works. By contrast,
|
|
||||||
the GNU General Public License is intended to guarantee your freedom to
|
|
||||||
share and change all versions of a program--to make sure it remains free
|
|
||||||
software for all its users. We, the Free Software Foundation, use the
|
|
||||||
GNU General Public License for most of our software; it applies also to
|
|
||||||
any other work released this way by its authors. You can apply it to
|
|
||||||
your programs, too.
|
|
||||||
|
|
||||||
When we speak of free software, we are referring to freedom, not
|
|
||||||
price. Our General Public Licenses are designed to make sure that you
|
|
||||||
have the freedom to distribute copies of free software (and charge for
|
|
||||||
them if you wish), that you receive source code or can get it if you
|
|
||||||
want it, that you can change the software or use pieces of it in new
|
|
||||||
free programs, and that you know you can do these things.
|
|
||||||
|
|
||||||
To protect your rights, we need to prevent others from denying you
|
|
||||||
these rights or asking you to surrender the rights. Therefore, you have
|
|
||||||
certain responsibilities if you distribute copies of the software, or if
|
|
||||||
you modify it: responsibilities to respect the freedom of others.
|
|
||||||
|
|
||||||
For example, if you distribute copies of such a program, whether
|
|
||||||
gratis or for a fee, you must pass on to the recipients the same
|
|
||||||
freedoms that you received. You must make sure that they, too, receive
|
|
||||||
or can get the source code. And you must show them these terms so they
|
|
||||||
know their rights.
|
|
||||||
|
|
||||||
Developers that use the GNU GPL protect your rights with two steps:
|
|
||||||
(1) assert copyright on the software, and (2) offer you this License
|
|
||||||
giving you legal permission to copy, distribute and/or modify it.
|
|
||||||
|
|
||||||
For the developers' and authors' protection, the GPL clearly explains
|
|
||||||
that there is no warranty for this free software. For both users' and
|
|
||||||
authors' sake, the GPL requires that modified versions be marked as
|
|
||||||
changed, so that their problems will not be attributed erroneously to
|
|
||||||
authors of previous versions.
|
|
||||||
|
|
||||||
Some devices are designed to deny users access to install or run
|
|
||||||
modified versions of the software inside them, although the manufacturer
|
|
||||||
can do so. This is fundamentally incompatible with the aim of
|
|
||||||
protecting users' freedom to change the software. The systematic
|
|
||||||
pattern of such abuse occurs in the area of products for individuals to
|
|
||||||
use, which is precisely where it is most unacceptable. Therefore, we
|
|
||||||
have designed this version of the GPL to prohibit the practice for those
|
|
||||||
products. If such problems arise substantially in other domains, we
|
|
||||||
stand ready to extend this provision to those domains in future versions
|
|
||||||
of the GPL, as needed to protect the freedom of users.
|
|
||||||
|
|
||||||
Finally, every program is threatened constantly by software patents.
|
|
||||||
States should not allow patents to restrict development and use of
|
|
||||||
software on general-purpose computers, but in those that do, we wish to
|
|
||||||
avoid the special danger that patents applied to a free program could
|
|
||||||
make it effectively proprietary. To prevent this, the GPL assures that
|
|
||||||
patents cannot be used to render the program non-free.
|
|
||||||
|
|
||||||
The precise terms and conditions for copying, distribution and
|
|
||||||
modification follow.
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
0. Definitions.
|
|
||||||
|
|
||||||
"This License" refers to version 3 of the GNU General Public License.
|
|
||||||
|
|
||||||
"Copyright" also means copyright-like laws that apply to other kinds of
|
|
||||||
works, such as semiconductor masks.
|
|
||||||
|
|
||||||
"The Program" refers to any copyrightable work licensed under this
|
|
||||||
License. Each licensee is addressed as "you". "Licensees" and
|
|
||||||
"recipients" may be individuals or organizations.
|
|
||||||
|
|
||||||
To "modify" a work means to copy from or adapt all or part of the work
|
|
||||||
in a fashion requiring copyright permission, other than the making of an
|
|
||||||
exact copy. The resulting work is called a "modified version" of the
|
|
||||||
earlier work or a work "based on" the earlier work.
|
|
||||||
|
|
||||||
A "covered work" means either the unmodified Program or a work based
|
|
||||||
on the Program.
|
|
||||||
|
|
||||||
To "propagate" a work means to do anything with it that, without
|
|
||||||
permission, would make you directly or secondarily liable for
|
|
||||||
infringement under applicable copyright law, except executing it on a
|
|
||||||
computer or modifying a private copy. Propagation includes copying,
|
|
||||||
distribution (with or without modification), making available to the
|
|
||||||
public, and in some countries other activities as well.
|
|
||||||
|
|
||||||
To "convey" a work means any kind of propagation that enables other
|
|
||||||
parties to make or receive copies. Mere interaction with a user through
|
|
||||||
a computer network, with no transfer of a copy, is not conveying.
|
|
||||||
|
|
||||||
An interactive user interface displays "Appropriate Legal Notices"
|
|
||||||
to the extent that it includes a convenient and prominently visible
|
|
||||||
feature that (1) displays an appropriate copyright notice, and (2)
|
|
||||||
tells the user that there is no warranty for the work (except to the
|
|
||||||
extent that warranties are provided), that licensees may convey the
|
|
||||||
work under this License, and how to view a copy of this License. If
|
|
||||||
the interface presents a list of user commands or options, such as a
|
|
||||||
menu, a prominent item in the list meets this criterion.
|
|
||||||
|
|
||||||
1. Source Code.
|
|
||||||
|
|
||||||
The "source code" for a work means the preferred form of the work
|
|
||||||
for making modifications to it. "Object code" means any non-source
|
|
||||||
form of a work.
|
|
||||||
|
|
||||||
A "Standard Interface" means an interface that either is an official
|
|
||||||
standard defined by a recognized standards body, or, in the case of
|
|
||||||
interfaces specified for a particular programming language, one that
|
|
||||||
is widely used among developers working in that language.
|
|
||||||
|
|
||||||
The "System Libraries" of an executable work include anything, other
|
|
||||||
than the work as a whole, that (a) is included in the normal form of
|
|
||||||
packaging a Major Component, but which is not part of that Major
|
|
||||||
Component, and (b) serves only to enable use of the work with that
|
|
||||||
Major Component, or to implement a Standard Interface for which an
|
|
||||||
implementation is available to the public in source code form. A
|
|
||||||
"Major Component", in this context, means a major essential component
|
|
||||||
(kernel, window system, and so on) of the specific operating system
|
|
||||||
(if any) on which the executable work runs, or a compiler used to
|
|
||||||
produce the work, or an object code interpreter used to run it.
|
|
||||||
|
|
||||||
The "Corresponding Source" for a work in object code form means all
|
|
||||||
the source code needed to generate, install, and (for an executable
|
|
||||||
work) run the object code and to modify the work, including scripts to
|
|
||||||
control those activities. However, it does not include the work's
|
|
||||||
System Libraries, or general-purpose tools or generally available free
|
|
||||||
programs which are used unmodified in performing those activities but
|
|
||||||
which are not part of the work. For example, Corresponding Source
|
|
||||||
includes interface definition files associated with source files for
|
|
||||||
the work, and the source code for shared libraries and dynamically
|
|
||||||
linked subprograms that the work is specifically designed to require,
|
|
||||||
such as by intimate data communication or control flow between those
|
|
||||||
subprograms and other parts of the work.
|
|
||||||
|
|
||||||
The Corresponding Source need not include anything that users
|
|
||||||
can regenerate automatically from other parts of the Corresponding
|
|
||||||
Source.
|
|
||||||
|
|
||||||
The Corresponding Source for a work in source code form is that
|
|
||||||
same work.
|
|
||||||
|
|
||||||
2. Basic Permissions.
|
|
||||||
|
|
||||||
All rights granted under this License are granted for the term of
|
|
||||||
copyright on the Program, and are irrevocable provided the stated
|
|
||||||
conditions are met. This License explicitly affirms your unlimited
|
|
||||||
permission to run the unmodified Program. The output from running a
|
|
||||||
covered work is covered by this License only if the output, given its
|
|
||||||
content, constitutes a covered work. This License acknowledges your
|
|
||||||
rights of fair use or other equivalent, as provided by copyright law.
|
|
||||||
|
|
||||||
You may make, run and propagate covered works that you do not
|
|
||||||
convey, without conditions so long as your license otherwise remains
|
|
||||||
in force. You may convey covered works to others for the sole purpose
|
|
||||||
of having them make modifications exclusively for you, or provide you
|
|
||||||
with facilities for running those works, provided that you comply with
|
|
||||||
the terms of this License in conveying all material for which you do
|
|
||||||
not control copyright. Those thus making or running the covered works
|
|
||||||
for you must do so exclusively on your behalf, under your direction
|
|
||||||
and control, on terms that prohibit them from making any copies of
|
|
||||||
your copyrighted material outside their relationship with you.
|
|
||||||
|
|
||||||
Conveying under any other circumstances is permitted solely under
|
|
||||||
the conditions stated below. Sublicensing is not allowed; section 10
|
|
||||||
makes it unnecessary.
|
|
||||||
|
|
||||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
|
||||||
|
|
||||||
No covered work shall be deemed part of an effective technological
|
|
||||||
measure under any applicable law fulfilling obligations under article
|
|
||||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
|
||||||
similar laws prohibiting or restricting circumvention of such
|
|
||||||
measures.
|
|
||||||
|
|
||||||
When you convey a covered work, you waive any legal power to forbid
|
|
||||||
circumvention of technological measures to the extent such circumvention
|
|
||||||
is effected by exercising rights under this License with respect to
|
|
||||||
the covered work, and you disclaim any intention to limit operation or
|
|
||||||
modification of the work as a means of enforcing, against the work's
|
|
||||||
users, your or third parties' legal rights to forbid circumvention of
|
|
||||||
technological measures.
|
|
||||||
|
|
||||||
4. Conveying Verbatim Copies.
|
|
||||||
|
|
||||||
You may convey verbatim copies of the Program's source code as you
|
|
||||||
receive it, in any medium, provided that you conspicuously and
|
|
||||||
appropriately publish on each copy an appropriate copyright notice;
|
|
||||||
keep intact all notices stating that this License and any
|
|
||||||
non-permissive terms added in accord with section 7 apply to the code;
|
|
||||||
keep intact all notices of the absence of any warranty; and give all
|
|
||||||
recipients a copy of this License along with the Program.
|
|
||||||
|
|
||||||
You may charge any price or no price for each copy that you convey,
|
|
||||||
and you may offer support or warranty protection for a fee.
|
|
||||||
|
|
||||||
5. Conveying Modified Source Versions.
|
|
||||||
|
|
||||||
You may convey a work based on the Program, or the modifications to
|
|
||||||
produce it from the Program, in the form of source code under the
|
|
||||||
terms of section 4, provided that you also meet all of these conditions:
|
|
||||||
|
|
||||||
a) The work must carry prominent notices stating that you modified
|
|
||||||
it, and giving a relevant date.
|
|
||||||
|
|
||||||
b) The work must carry prominent notices stating that it is
|
|
||||||
released under this License and any conditions added under section
|
|
||||||
7. This requirement modifies the requirement in section 4 to
|
|
||||||
"keep intact all notices".
|
|
||||||
|
|
||||||
c) You must license the entire work, as a whole, under this
|
|
||||||
License to anyone who comes into possession of a copy. This
|
|
||||||
License will therefore apply, along with any applicable section 7
|
|
||||||
additional terms, to the whole of the work, and all its parts,
|
|
||||||
regardless of how they are packaged. This License gives no
|
|
||||||
permission to license the work in any other way, but it does not
|
|
||||||
invalidate such permission if you have separately received it.
|
|
||||||
|
|
||||||
d) If the work has interactive user interfaces, each must display
|
|
||||||
Appropriate Legal Notices; however, if the Program has interactive
|
|
||||||
interfaces that do not display Appropriate Legal Notices, your
|
|
||||||
work need not make them do so.
|
|
||||||
|
|
||||||
A compilation of a covered work with other separate and independent
|
|
||||||
works, which are not by their nature extensions of the covered work,
|
|
||||||
and which are not combined with it such as to form a larger program,
|
|
||||||
in or on a volume of a storage or distribution medium, is called an
|
|
||||||
"aggregate" if the compilation and its resulting copyright are not
|
|
||||||
used to limit the access or legal rights of the compilation's users
|
|
||||||
beyond what the individual works permit. Inclusion of a covered work
|
|
||||||
in an aggregate does not cause this License to apply to the other
|
|
||||||
parts of the aggregate.
|
|
||||||
|
|
||||||
6. Conveying Non-Source Forms.
|
|
||||||
|
|
||||||
You may convey a covered work in object code form under the terms
|
|
||||||
of sections 4 and 5, provided that you also convey the
|
|
||||||
machine-readable Corresponding Source under the terms of this License,
|
|
||||||
in one of these ways:
|
|
||||||
|
|
||||||
a) Convey the object code in, or embodied in, a physical product
|
|
||||||
(including a physical distribution medium), accompanied by the
|
|
||||||
Corresponding Source fixed on a durable physical medium
|
|
||||||
customarily used for software interchange.
|
|
||||||
|
|
||||||
b) Convey the object code in, or embodied in, a physical product
|
|
||||||
(including a physical distribution medium), accompanied by a
|
|
||||||
written offer, valid for at least three years and valid for as
|
|
||||||
long as you offer spare parts or customer support for that product
|
|
||||||
model, to give anyone who possesses the object code either (1) a
|
|
||||||
copy of the Corresponding Source for all the software in the
|
|
||||||
product that is covered by this License, on a durable physical
|
|
||||||
medium customarily used for software interchange, for a price no
|
|
||||||
more than your reasonable cost of physically performing this
|
|
||||||
conveying of source, or (2) access to copy the
|
|
||||||
Corresponding Source from a network server at no charge.
|
|
||||||
|
|
||||||
c) Convey individual copies of the object code with a copy of the
|
|
||||||
written offer to provide the Corresponding Source. This
|
|
||||||
alternative is allowed only occasionally and noncommercially, and
|
|
||||||
only if you received the object code with such an offer, in accord
|
|
||||||
with subsection 6b.
|
|
||||||
|
|
||||||
d) Convey the object code by offering access from a designated
|
|
||||||
place (gratis or for a charge), and offer equivalent access to the
|
|
||||||
Corresponding Source in the same way through the same place at no
|
|
||||||
further charge. You need not require recipients to copy the
|
|
||||||
Corresponding Source along with the object code. If the place to
|
|
||||||
copy the object code is a network server, the Corresponding Source
|
|
||||||
may be on a different server (operated by you or a third party)
|
|
||||||
that supports equivalent copying facilities, provided you maintain
|
|
||||||
clear directions next to the object code saying where to find the
|
|
||||||
Corresponding Source. Regardless of what server hosts the
|
|
||||||
Corresponding Source, you remain obligated to ensure that it is
|
|
||||||
available for as long as needed to satisfy these requirements.
|
|
||||||
|
|
||||||
e) Convey the object code using peer-to-peer transmission, provided
|
|
||||||
you inform other peers where the object code and Corresponding
|
|
||||||
Source of the work are being offered to the general public at no
|
|
||||||
charge under subsection 6d.
|
|
||||||
|
|
||||||
A separable portion of the object code, whose source code is excluded
|
|
||||||
from the Corresponding Source as a System Library, need not be
|
|
||||||
included in conveying the object code work.
|
|
||||||
|
|
||||||
A "User Product" is either (1) a "consumer product", which means any
|
|
||||||
tangible personal property which is normally used for personal, family,
|
|
||||||
or household purposes, or (2) anything designed or sold for incorporation
|
|
||||||
into a dwelling. In determining whether a product is a consumer product,
|
|
||||||
doubtful cases shall be resolved in favor of coverage. For a particular
|
|
||||||
product received by a particular user, "normally used" refers to a
|
|
||||||
typical or common use of that class of product, regardless of the status
|
|
||||||
of the particular user or of the way in which the particular user
|
|
||||||
actually uses, or expects or is expected to use, the product. A product
|
|
||||||
is a consumer product regardless of whether the product has substantial
|
|
||||||
commercial, industrial or non-consumer uses, unless such uses represent
|
|
||||||
the only significant mode of use of the product.
|
|
||||||
|
|
||||||
"Installation Information" for a User Product means any methods,
|
|
||||||
procedures, authorization keys, or other information required to install
|
|
||||||
and execute modified versions of a covered work in that User Product from
|
|
||||||
a modified version of its Corresponding Source. The information must
|
|
||||||
suffice to ensure that the continued functioning of the modified object
|
|
||||||
code is in no case prevented or interfered with solely because
|
|
||||||
modification has been made.
|
|
||||||
|
|
||||||
If you convey an object code work under this section in, or with, or
|
|
||||||
specifically for use in, a User Product, and the conveying occurs as
|
|
||||||
part of a transaction in which the right of possession and use of the
|
|
||||||
User Product is transferred to the recipient in perpetuity or for a
|
|
||||||
fixed term (regardless of how the transaction is characterized), the
|
|
||||||
Corresponding Source conveyed under this section must be accompanied
|
|
||||||
by the Installation Information. But this requirement does not apply
|
|
||||||
if neither you nor any third party retains the ability to install
|
|
||||||
modified object code on the User Product (for example, the work has
|
|
||||||
been installed in ROM).
|
|
||||||
|
|
||||||
The requirement to provide Installation Information does not include a
|
|
||||||
requirement to continue to provide support service, warranty, or updates
|
|
||||||
for a work that has been modified or installed by the recipient, or for
|
|
||||||
the User Product in which it has been modified or installed. Access to a
|
|
||||||
network may be denied when the modification itself materially and
|
|
||||||
adversely affects the operation of the network or violates the rules and
|
|
||||||
protocols for communication across the network.
|
|
||||||
|
|
||||||
Corresponding Source conveyed, and Installation Information provided,
|
|
||||||
in accord with this section must be in a format that is publicly
|
|
||||||
documented (and with an implementation available to the public in
|
|
||||||
source code form), and must require no special password or key for
|
|
||||||
unpacking, reading or copying.
|
|
||||||
|
|
||||||
7. Additional Terms.
|
|
||||||
|
|
||||||
"Additional permissions" are terms that supplement the terms of this
|
|
||||||
License by making exceptions from one or more of its conditions.
|
|
||||||
Additional permissions that are applicable to the entire Program shall
|
|
||||||
be treated as though they were included in this License, to the extent
|
|
||||||
that they are valid under applicable law. If additional permissions
|
|
||||||
apply only to part of the Program, that part may be used separately
|
|
||||||
under those permissions, but the entire Program remains governed by
|
|
||||||
this License without regard to the additional permissions.
|
|
||||||
|
|
||||||
When you convey a copy of a covered work, you may at your option
|
|
||||||
remove any additional permissions from that copy, or from any part of
|
|
||||||
it. (Additional permissions may be written to require their own
|
|
||||||
removal in certain cases when you modify the work.) You may place
|
|
||||||
additional permissions on material, added by you to a covered work,
|
|
||||||
for which you have or can give appropriate copyright permission.
|
|
||||||
|
|
||||||
Notwithstanding any other provision of this License, for material you
|
|
||||||
add to a covered work, you may (if authorized by the copyright holders of
|
|
||||||
that material) supplement the terms of this License with terms:
|
|
||||||
|
|
||||||
a) Disclaiming warranty or limiting liability differently from the
|
|
||||||
terms of sections 15 and 16 of this License; or
|
|
||||||
|
|
||||||
b) Requiring preservation of specified reasonable legal notices or
|
|
||||||
author attributions in that material or in the Appropriate Legal
|
|
||||||
Notices displayed by works containing it; or
|
|
||||||
|
|
||||||
c) Prohibiting misrepresentation of the origin of that material, or
|
|
||||||
requiring that modified versions of such material be marked in
|
|
||||||
reasonable ways as different from the original version; or
|
|
||||||
|
|
||||||
d) Limiting the use for publicity purposes of names of licensors or
|
|
||||||
authors of the material; or
|
|
||||||
|
|
||||||
e) Declining to grant rights under trademark law for use of some
|
|
||||||
trade names, trademarks, or service marks; or
|
|
||||||
|
|
||||||
f) Requiring indemnification of licensors and authors of that
|
|
||||||
material by anyone who conveys the material (or modified versions of
|
|
||||||
it) with contractual assumptions of liability to the recipient, for
|
|
||||||
any liability that these contractual assumptions directly impose on
|
|
||||||
those licensors and authors.
|
|
||||||
|
|
||||||
All other non-permissive additional terms are considered "further
|
|
||||||
restrictions" within the meaning of section 10. If the Program as you
|
|
||||||
received it, or any part of it, contains a notice stating that it is
|
|
||||||
governed by this License along with a term that is a further
|
|
||||||
restriction, you may remove that term. If a license document contains
|
|
||||||
a further restriction but permits relicensing or conveying under this
|
|
||||||
License, you may add to a covered work material governed by the terms
|
|
||||||
of that license document, provided that the further restriction does
|
|
||||||
not survive such relicensing or conveying.
|
|
||||||
|
|
||||||
If you add terms to a covered work in accord with this section, you
|
|
||||||
must place, in the relevant source files, a statement of the
|
|
||||||
additional terms that apply to those files, or a notice indicating
|
|
||||||
where to find the applicable terms.
|
|
||||||
|
|
||||||
Additional terms, permissive or non-permissive, may be stated in the
|
|
||||||
form of a separately written license, or stated as exceptions;
|
|
||||||
the above requirements apply either way.
|
|
||||||
|
|
||||||
8. Termination.
|
|
||||||
|
|
||||||
You may not propagate or modify a covered work except as expressly
|
|
||||||
provided under this License. Any attempt otherwise to propagate or
|
|
||||||
modify it is void, and will automatically terminate your rights under
|
|
||||||
this License (including any patent licenses granted under the third
|
|
||||||
paragraph of section 11).
|
|
||||||
|
|
||||||
However, if you cease all violation of this License, then your
|
|
||||||
license from a particular copyright holder is reinstated (a)
|
|
||||||
provisionally, unless and until the copyright holder explicitly and
|
|
||||||
finally terminates your license, and (b) permanently, if the copyright
|
|
||||||
holder fails to notify you of the violation by some reasonable means
|
|
||||||
prior to 60 days after the cessation.
|
|
||||||
|
|
||||||
Moreover, your license from a particular copyright holder is
|
|
||||||
reinstated permanently if the copyright holder notifies you of the
|
|
||||||
violation by some reasonable means, this is the first time you have
|
|
||||||
received notice of violation of this License (for any work) from that
|
|
||||||
copyright holder, and you cure the violation prior to 30 days after
|
|
||||||
your receipt of the notice.
|
|
||||||
|
|
||||||
Termination of your rights under this section does not terminate the
|
|
||||||
licenses of parties who have received copies or rights from you under
|
|
||||||
this License. If your rights have been terminated and not permanently
|
|
||||||
reinstated, you do not qualify to receive new licenses for the same
|
|
||||||
material under section 10.
|
|
||||||
|
|
||||||
9. Acceptance Not Required for Having Copies.
|
|
||||||
|
|
||||||
You are not required to accept this License in order to receive or
|
|
||||||
run a copy of the Program. Ancillary propagation of a covered work
|
|
||||||
occurring solely as a consequence of using peer-to-peer transmission
|
|
||||||
to receive a copy likewise does not require acceptance. However,
|
|
||||||
nothing other than this License grants you permission to propagate or
|
|
||||||
modify any covered work. These actions infringe copyright if you do
|
|
||||||
not accept this License. Therefore, by modifying or propagating a
|
|
||||||
covered work, you indicate your acceptance of this License to do so.
|
|
||||||
|
|
||||||
10. Automatic Licensing of Downstream Recipients.
|
|
||||||
|
|
||||||
Each time you convey a covered work, the recipient automatically
|
|
||||||
receives a license from the original licensors, to run, modify and
|
|
||||||
propagate that work, subject to this License. You are not responsible
|
|
||||||
for enforcing compliance by third parties with this License.
|
|
||||||
|
|
||||||
An "entity transaction" is a transaction transferring control of an
|
|
||||||
organization, or substantially all assets of one, or subdividing an
|
|
||||||
organization, or merging organizations. If propagation of a covered
|
|
||||||
work results from an entity transaction, each party to that
|
|
||||||
transaction who receives a copy of the work also receives whatever
|
|
||||||
licenses to the work the party's predecessor in interest had or could
|
|
||||||
give under the previous paragraph, plus a right to possession of the
|
|
||||||
Corresponding Source of the work from the predecessor in interest, if
|
|
||||||
the predecessor has it or can get it with reasonable efforts.
|
|
||||||
|
|
||||||
You may not impose any further restrictions on the exercise of the
|
|
||||||
rights granted or affirmed under this License. For example, you may
|
|
||||||
not impose a license fee, royalty, or other charge for exercise of
|
|
||||||
rights granted under this License, and you may not initiate litigation
|
|
||||||
(including a cross-claim or counterclaim in a lawsuit) alleging that
|
|
||||||
any patent claim is infringed by making, using, selling, offering for
|
|
||||||
sale, or importing the Program or any portion of it.
|
|
||||||
|
|
||||||
11. Patents.
|
|
||||||
|
|
||||||
A "contributor" is a copyright holder who authorizes use under this
|
|
||||||
License of the Program or a work on which the Program is based. The
|
|
||||||
work thus licensed is called the contributor's "contributor version".
|
|
||||||
|
|
||||||
A contributor's "essential patent claims" are all patent claims
|
|
||||||
owned or controlled by the contributor, whether already acquired or
|
|
||||||
hereafter acquired, that would be infringed by some manner, permitted
|
|
||||||
by this License, of making, using, or selling its contributor version,
|
|
||||||
but do not include claims that would be infringed only as a
|
|
||||||
consequence of further modification of the contributor version. For
|
|
||||||
purposes of this definition, "control" includes the right to grant
|
|
||||||
patent sublicenses in a manner consistent with the requirements of
|
|
||||||
this License.
|
|
||||||
|
|
||||||
Each contributor grants you a non-exclusive, worldwide, royalty-free
|
|
||||||
patent license under the contributor's essential patent claims, to
|
|
||||||
make, use, sell, offer for sale, import and otherwise run, modify and
|
|
||||||
propagate the contents of its contributor version.
|
|
||||||
|
|
||||||
In the following three paragraphs, a "patent license" is any express
|
|
||||||
agreement or commitment, however denominated, not to enforce a patent
|
|
||||||
(such as an express permission to practice a patent or covenant not to
|
|
||||||
sue for patent infringement). To "grant" such a patent license to a
|
|
||||||
party means to make such an agreement or commitment not to enforce a
|
|
||||||
patent against the party.
|
|
||||||
|
|
||||||
If you convey a covered work, knowingly relying on a patent license,
|
|
||||||
and the Corresponding Source of the work is not available for anyone
|
|
||||||
to copy, free of charge and under the terms of this License, through a
|
|
||||||
publicly available network server or other readily accessible means,
|
|
||||||
then you must either (1) cause the Corresponding Source to be so
|
|
||||||
available, or (2) arrange to deprive yourself of the benefit of the
|
|
||||||
patent license for this particular work, or (3) arrange, in a manner
|
|
||||||
consistent with the requirements of this License, to extend the patent
|
|
||||||
license to downstream recipients. "Knowingly relying" means you have
|
|
||||||
actual knowledge that, but for the patent license, your conveying the
|
|
||||||
covered work in a country, or your recipient's use of the covered work
|
|
||||||
in a country, would infringe one or more identifiable patents in that
|
|
||||||
country that you have reason to believe are valid.
|
|
||||||
|
|
||||||
If, pursuant to or in connection with a single transaction or
|
|
||||||
arrangement, you convey, or propagate by procuring conveyance of, a
|
|
||||||
covered work, and grant a patent license to some of the parties
|
|
||||||
receiving the covered work authorizing them to use, propagate, modify
|
|
||||||
or convey a specific copy of the covered work, then the patent license
|
|
||||||
you grant is automatically extended to all recipients of the covered
|
|
||||||
work and works based on it.
|
|
||||||
|
|
||||||
A patent license is "discriminatory" if it does not include within
|
|
||||||
the scope of its coverage, prohibits the exercise of, or is
|
|
||||||
conditioned on the non-exercise of one or more of the rights that are
|
|
||||||
specifically granted under this License. You may not convey a covered
|
|
||||||
work if you are a party to an arrangement with a third party that is
|
|
||||||
in the business of distributing software, under which you make payment
|
|
||||||
to the third party based on the extent of your activity of conveying
|
|
||||||
the work, and under which the third party grants, to any of the
|
|
||||||
parties who would receive the covered work from you, a discriminatory
|
|
||||||
patent license (a) in connection with copies of the covered work
|
|
||||||
conveyed by you (or copies made from those copies), or (b) primarily
|
|
||||||
for and in connection with specific products or compilations that
|
|
||||||
contain the covered work, unless you entered into that arrangement,
|
|
||||||
or that patent license was granted, prior to 28 March 2007.
|
|
||||||
|
|
||||||
Nothing in this License shall be construed as excluding or limiting
|
|
||||||
any implied license or other defenses to infringement that may
|
|
||||||
otherwise be available to you under applicable patent law.
|
|
||||||
|
|
||||||
12. No Surrender of Others' Freedom.
|
|
||||||
|
|
||||||
If conditions are imposed on you (whether by court order, agreement or
|
|
||||||
otherwise) that contradict the conditions of this License, they do not
|
|
||||||
excuse you from the conditions of this License. If you cannot convey a
|
|
||||||
covered work so as to satisfy simultaneously your obligations under this
|
|
||||||
License and any other pertinent obligations, then as a consequence you may
|
|
||||||
not convey it at all. For example, if you agree to terms that obligate you
|
|
||||||
to collect a royalty for further conveying from those to whom you convey
|
|
||||||
the Program, the only way you could satisfy both those terms and this
|
|
||||||
License would be to refrain entirely from conveying the Program.
|
|
||||||
|
|
||||||
13. Use with the GNU Affero General Public License.
|
|
||||||
|
|
||||||
Notwithstanding any other provision of this License, you have
|
|
||||||
permission to link or combine any covered work with a work licensed
|
|
||||||
under version 3 of the GNU Affero General Public License into a single
|
|
||||||
combined work, and to convey the resulting work. The terms of this
|
|
||||||
License will continue to apply to the part which is the covered work,
|
|
||||||
but the special requirements of the GNU Affero General Public License,
|
|
||||||
section 13, concerning interaction through a network will apply to the
|
|
||||||
combination as such.
|
|
||||||
|
|
||||||
14. Revised Versions of this License.
|
|
||||||
|
|
||||||
The Free Software Foundation may publish revised and/or new versions of
|
|
||||||
the GNU General Public License from time to time. Such new versions will
|
|
||||||
be similar in spirit to the present version, but may differ in detail to
|
|
||||||
address new problems or concerns.
|
|
||||||
|
|
||||||
Each version is given a distinguishing version number. If the
|
|
||||||
Program specifies that a certain numbered version of the GNU General
|
|
||||||
Public License "or any later version" applies to it, you have the
|
|
||||||
option of following the terms and conditions either of that numbered
|
|
||||||
version or of any later version published by the Free Software
|
|
||||||
Foundation. If the Program does not specify a version number of the
|
|
||||||
GNU General Public License, you may choose any version ever published
|
|
||||||
by the Free Software Foundation.
|
|
||||||
|
|
||||||
If the Program specifies that a proxy can decide which future
|
|
||||||
versions of the GNU General Public License can be used, that proxy's
|
|
||||||
public statement of acceptance of a version permanently authorizes you
|
|
||||||
to choose that version for the Program.
|
|
||||||
|
|
||||||
Later license versions may give you additional or different
|
|
||||||
permissions. However, no additional obligations are imposed on any
|
|
||||||
author or copyright holder as a result of your choosing to follow a
|
|
||||||
later version.
|
|
||||||
|
|
||||||
15. Disclaimer of Warranty.
|
|
||||||
|
|
||||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
|
||||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
|
||||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
|
||||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
|
||||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
||||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
|
||||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
|
||||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
|
||||||
|
|
||||||
16. Limitation of Liability.
|
|
||||||
|
|
||||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
|
||||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
|
||||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
|
||||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
|
||||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
|
||||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
|
||||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
|
||||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
|
||||||
SUCH DAMAGES.
|
|
||||||
|
|
||||||
17. Interpretation of Sections 15 and 16.
|
|
||||||
|
|
||||||
If the disclaimer of warranty and limitation of liability provided
|
|
||||||
above cannot be given local legal effect according to their terms,
|
|
||||||
reviewing courts shall apply local law that most closely approximates
|
|
||||||
an absolute waiver of all civil liability in connection with the
|
|
||||||
Program, unless a warranty or assumption of liability accompanies a
|
|
||||||
copy of the Program in return for a fee.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
How to Apply These Terms to Your New Programs
|
|
||||||
|
|
||||||
If you develop a new program, and you want it to be of the greatest
|
|
||||||
possible use to the public, the best way to achieve this is to make it
|
|
||||||
free software which everyone can redistribute and change under these terms.
|
|
||||||
|
|
||||||
To do so, attach the following notices to the program. It is safest
|
|
||||||
to attach them to the start of each source file to most effectively
|
|
||||||
state the exclusion of warranty; and each file should have at least
|
|
||||||
the "copyright" line and a pointer to where the full notice is found.
|
|
||||||
|
|
||||||
<one line to give the program's name and a brief idea of what it does.>
|
|
||||||
Copyright (C) <year> <name of author>
|
|
||||||
|
|
||||||
This program is free software: you can redistribute it and/or modify
|
|
||||||
it under the terms of the GNU General Public License as published by
|
|
||||||
the Free Software Foundation, either version 3 of the License, or
|
|
||||||
(at your option) any later version.
|
|
||||||
|
|
||||||
This program is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
GNU General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU General Public License
|
|
||||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
Also add information on how to contact you by electronic and paper mail.
|
|
||||||
|
|
||||||
If the program does terminal interaction, make it output a short
|
|
||||||
notice like this when it starts in an interactive mode:
|
|
||||||
|
|
||||||
<program> Copyright (C) <year> <name of author>
|
|
||||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
|
||||||
This is free software, and you are welcome to redistribute it
|
|
||||||
under certain conditions; type `show c' for details.
|
|
||||||
|
|
||||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
|
||||||
parts of the General Public License. Of course, your program's commands
|
|
||||||
might be different; for a GUI interface, you would use an "about box".
|
|
||||||
|
|
||||||
You should also get your employer (if you work as a programmer) or school,
|
|
||||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
|
||||||
For more information on this, and how to apply and follow the GNU GPL, see
|
|
||||||
<https://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
The GNU General Public License does not permit incorporating your program
|
|
||||||
into proprietary programs. If your program is a subroutine library, you
|
|
||||||
may consider it more useful to permit linking proprietary applications with
|
|
||||||
the library. If this is what you want to do, use the GNU Lesser General
|
|
||||||
Public License instead of this License. But first, please read
|
|
||||||
<https://www.gnu.org/licenses/why-not-lgpl.html>.
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
Subproject commit 9c57e5c1d0df339aefb1e235ab968ae4dadcb980
|
|
||||||
8
shaders/grid.frag
Normal file
8
shaders/grid.frag
Normal file
|
|
@ -0,0 +1,8 @@
|
||||||
|
#version 460 core
|
||||||
|
|
||||||
|
out vec4 fragColor;
|
||||||
|
|
||||||
|
void main()
|
||||||
|
{
|
||||||
|
fragColor = vec4(0.1f, 0.1f, 0.1f, 1.0f);
|
||||||
|
}
|
||||||
13
shaders/grid.vert
Normal file
13
shaders/grid.vert
Normal file
|
|
@ -0,0 +1,13 @@
|
||||||
|
#version 460 core
|
||||||
|
|
||||||
|
layout (location = 0) in vec3 aPos;
|
||||||
|
layout (location = 1) in float aArg;
|
||||||
|
|
||||||
|
uniform mat4 model;
|
||||||
|
uniform mat4 view;
|
||||||
|
uniform mat4 projection;
|
||||||
|
|
||||||
|
void main()
|
||||||
|
{
|
||||||
|
gl_Position = projection * view * model * vec4(aPos, 1.0f);
|
||||||
|
}
|
||||||
16
shaders/plot.frag
Normal file
16
shaders/plot.frag
Normal file
|
|
@ -0,0 +1,16 @@
|
||||||
|
#version 460 core
|
||||||
|
|
||||||
|
in float vertexArg;
|
||||||
|
out vec4 fragmentColor;
|
||||||
|
|
||||||
|
vec3 hsv2rgb(vec3 c)
|
||||||
|
{
|
||||||
|
vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
|
||||||
|
vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
|
||||||
|
return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
|
||||||
|
}
|
||||||
|
|
||||||
|
void main()
|
||||||
|
{
|
||||||
|
fragmentColor = vec4(hsv2rgb(vec3(vertexArg, 1.0f, 1.0f)), 1.0f);
|
||||||
|
}
|
||||||
16
shaders/plot.vert
Normal file
16
shaders/plot.vert
Normal file
|
|
@ -0,0 +1,16 @@
|
||||||
|
#version 460 core
|
||||||
|
|
||||||
|
layout (location = 0) in vec3 aPos;
|
||||||
|
layout (location = 1) in float aArg;
|
||||||
|
|
||||||
|
out float vertexArg;
|
||||||
|
|
||||||
|
uniform mat4 model;
|
||||||
|
uniform mat4 view;
|
||||||
|
uniform mat4 projection;
|
||||||
|
|
||||||
|
void main()
|
||||||
|
{
|
||||||
|
gl_Position = projection * view * model * vec4(aPos, 1.0f);
|
||||||
|
vertexArg = aArg;
|
||||||
|
}
|
||||||
29
src/CMakeLists.txt
Normal file
29
src/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,29 @@
|
||||||
|
|
||||||
|
add_executable(ComplexPlotting
|
||||||
|
"main.cpp"
|
||||||
|
"PlotWindow.hpp" "PlotWindow.cpp" "PlotManager.hpp" "PlotManager.cpp" "objects/Shader.hpp" "objects/Shader.cpp" )
|
||||||
|
|
||||||
|
file(GLOB vendor_SRC
|
||||||
|
${CMAKE_SOURCE_DIR}/vendor/src/*.c
|
||||||
|
${CMAKE_SOURCE_DIR}/vendor/src/*.cpp
|
||||||
|
)
|
||||||
|
|
||||||
|
target_sources(ComplexPlotting PRIVATE
|
||||||
|
${vendor_SRC}
|
||||||
|
objects
|
||||||
|
)
|
||||||
|
|
||||||
|
target_include_directories(ComplexPlotting PRIVATE
|
||||||
|
glfw
|
||||||
|
${CMAKE_SOURCE_DIR}/vendor/include
|
||||||
|
${CMAKE_SOURCE_DIR}/vendor/include/imgui
|
||||||
|
objects
|
||||||
|
)
|
||||||
|
|
||||||
|
target_link_libraries(ComplexPlotting
|
||||||
|
glfw
|
||||||
|
)
|
||||||
|
|
||||||
|
add_custom_command(TARGET ComplexPlotting POST_BUILD
|
||||||
|
COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/shaders $<TARGET_FILE_DIR:ComplexPlotting>/shaders
|
||||||
|
)
|
||||||
30
src/PlotManager.cpp
Normal file
30
src/PlotManager.cpp
Normal file
|
|
@ -0,0 +1,30 @@
|
||||||
|
#include "PlotManager.hpp"
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
|
||||||
|
void PlotManager::NewPlot(std::string title)
|
||||||
|
{
|
||||||
|
currentID++;
|
||||||
|
OpenWindow = new PlotWindow(700, 700, currentID, 50, title);
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotManager::Loop()
|
||||||
|
{
|
||||||
|
if (OpenWindow->ShouldClose())
|
||||||
|
{
|
||||||
|
Close();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
OpenWindow->GiveContext();
|
||||||
|
OpenWindow->Clear();
|
||||||
|
OpenWindow->Display();
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotManager::Close()
|
||||||
|
{
|
||||||
|
OpenWindow->Destroy();
|
||||||
|
delete OpenWindow;
|
||||||
|
OpenWindow = nullptr;
|
||||||
|
isOpen = false;
|
||||||
|
}
|
||||||
29
src/PlotManager.hpp
Normal file
29
src/PlotManager.hpp
Normal file
|
|
@ -0,0 +1,29 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include <thread>
|
||||||
|
#include <future>
|
||||||
|
|
||||||
|
#include <imgui/imstb_truetype.h>
|
||||||
|
|
||||||
|
#include "PlotWindow.hpp"
|
||||||
|
#include "objects/Shader.hpp"
|
||||||
|
|
||||||
|
typedef std::vector<PlotWindow> WList;
|
||||||
|
|
||||||
|
class PlotManager
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
static void NewPlot(std::string title);
|
||||||
|
static void Loop();
|
||||||
|
|
||||||
|
static void Close();
|
||||||
|
|
||||||
|
public:
|
||||||
|
inline static bool isOpen = true;
|
||||||
|
inline static int currentID = 0;
|
||||||
|
|
||||||
|
private:
|
||||||
|
inline static PlotWindow* OpenWindow = nullptr;
|
||||||
|
};
|
||||||
266
src/PlotWindow.cpp
Normal file
266
src/PlotWindow.cpp
Normal file
|
|
@ -0,0 +1,266 @@
|
||||||
|
#include "PlotWindow.hpp"
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
#include <string>
|
||||||
|
#include <fstream>
|
||||||
|
#include <complex>
|
||||||
|
|
||||||
|
#include <glm/gtc/matrix_transform.hpp>
|
||||||
|
#include <glm/gtx/quaternion.hpp>
|
||||||
|
|
||||||
|
#include <imgui/imgui.h>
|
||||||
|
#include <imgui/imgui_impl_glfw.h>
|
||||||
|
#include <imgui/imgui_impl_opengl3.h>
|
||||||
|
|
||||||
|
#define PI 3.14159265358979F
|
||||||
|
|
||||||
|
#define frand() ((float)rand() / (float)RAND_MAX)
|
||||||
|
#define indexof(x, y, w) ((y) * w + x)
|
||||||
|
|
||||||
|
typedef std::complex<float> fCmplx;
|
||||||
|
|
||||||
|
fCmplx test_function(fCmplx z)
|
||||||
|
{
|
||||||
|
return fCmplx(1.0f, 0.0f) / (z - fCmplx(0.5, 0.0))
|
||||||
|
+ fCmplx(1.0f, 0.0f) / (z + fCmplx(0.5, 0.0));
|
||||||
|
}
|
||||||
|
|
||||||
|
PlotWindow::PlotWindow(int w, int h, int id, unsigned int detail, std::string title) :
|
||||||
|
window(nullptr), id(id),
|
||||||
|
projection(glm::mat4(1.0f)),
|
||||||
|
VAO(0), VBO(0), EBO(0)
|
||||||
|
{
|
||||||
|
IMGUI_CHECKVERSION();
|
||||||
|
|
||||||
|
width = w;
|
||||||
|
height = h;
|
||||||
|
|
||||||
|
window = glfwCreateWindow(w, h, ("Plot " + std::to_string(id) + " | " + title).c_str(), NULL, NULL);
|
||||||
|
if (window == nullptr)
|
||||||
|
{
|
||||||
|
const char* buffer = new const char[512];
|
||||||
|
glfwGetError(&buffer);
|
||||||
|
std::cerr << "Failed to initialize GLFWwindow: " << std::endl << buffer << std::endl;
|
||||||
|
delete[] buffer;
|
||||||
|
buffer = nullptr;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
glfwMakeContextCurrent(window);
|
||||||
|
glfwSetFramebufferSizeCallback(window, FramebufferSizeCallback);
|
||||||
|
glfwSetMouseButtonCallback(window, MouseButtonCallback);
|
||||||
|
glfwSetScrollCallback(window, ScrollCallback);
|
||||||
|
glfwSetCursorPosCallback(window, CursorPositionCallback);
|
||||||
|
|
||||||
|
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
|
||||||
|
{
|
||||||
|
std::cerr << "Failed to initialize GLAD" << std::endl;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
ImGui::CreateContext();
|
||||||
|
|
||||||
|
ImGuiIO& io = ImGui::GetIO();
|
||||||
|
|
||||||
|
ImGui_ImplGlfw_InitForOpenGL(window, true);
|
||||||
|
ImGui_ImplOpenGL3_Init((const char*)glGetString(GL_NUM_SHADING_LANGUAGE_VERSIONS));
|
||||||
|
|
||||||
|
ImGui::StyleColorsDark();
|
||||||
|
|
||||||
|
glViewport(0, 0, w, h);
|
||||||
|
glEnable(GL_MULTISAMPLE);
|
||||||
|
|
||||||
|
plotShader = new Shader("shaders/plot.vert", "shaders/plot.frag");
|
||||||
|
gridShader = new Shader("shaders/grid.vert", "shaders/grid.frag");
|
||||||
|
|
||||||
|
// Generate meshed plane
|
||||||
|
if (detail < 2) detail = 2;
|
||||||
|
float diff = 2.0f / (float)(detail - 1);
|
||||||
|
for (int z = 0; z < detail; z++)
|
||||||
|
{
|
||||||
|
for (int x = 0; x < detail; x++)
|
||||||
|
{
|
||||||
|
fCmplx cmplx = test_function(fCmplx(-1.0f + x * diff, -1.0f + z * diff));
|
||||||
|
vertices.push_back(
|
||||||
|
{
|
||||||
|
-1.0f + x * diff,
|
||||||
|
std::abs(cmplx),
|
||||||
|
-1.0f + z * diff,
|
||||||
|
(std::arg(cmplx) + PI) / 2 / PI
|
||||||
|
}
|
||||||
|
);
|
||||||
|
|
||||||
|
if (x < detail - 1 && z < detail - 1)
|
||||||
|
{
|
||||||
|
indices.push_back(indexof(x, z, detail));
|
||||||
|
indices.push_back(indexof(x + 1, z, detail));
|
||||||
|
indices.push_back(indexof(x, z + 1, detail));
|
||||||
|
indices.push_back(indexof(x + 1, z, detail));
|
||||||
|
indices.push_back(indexof(x + 1, z + 1, detail));
|
||||||
|
indices.push_back(indexof(x, z + 1, detail));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Generate buffers
|
||||||
|
glGenVertexArrays(1, &VAO);
|
||||||
|
glGenBuffers(1, &VBO);
|
||||||
|
glGenBuffers(1, &EBO);
|
||||||
|
|
||||||
|
glBindVertexArray(VAO);
|
||||||
|
|
||||||
|
// Create VBO
|
||||||
|
glBindBuffer(GL_ARRAY_BUFFER, VBO);
|
||||||
|
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), (float*)&vertices[0], GL_STATIC_DRAW);
|
||||||
|
|
||||||
|
// Create EBO
|
||||||
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
|
||||||
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
|
||||||
|
|
||||||
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
|
||||||
|
glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(3 * sizeof(float)));
|
||||||
|
glEnableVertexAttribArray(0);
|
||||||
|
glEnableVertexAttribArray(1);
|
||||||
|
|
||||||
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||||
|
glBindVertexArray(0);
|
||||||
|
|
||||||
|
glEnable(GL_DEPTH_TEST);
|
||||||
|
|
||||||
|
//view = glm::rotate(view, glm::radians(45.0f), glm::vec3(1.0f, 0.0f, 0.0f));
|
||||||
|
view = glm::translate(view, glm::vec3(0.0f, -0.0f, -3.0f));
|
||||||
|
projection = glm::perspective(45.0f, (float)w / (float)h, 0.1f, 10.0f);
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotWindow::Destroy()
|
||||||
|
{
|
||||||
|
glfwMakeContextCurrent(window);
|
||||||
|
|
||||||
|
delete plotShader;
|
||||||
|
plotShader = nullptr;
|
||||||
|
|
||||||
|
glDeleteBuffers(1, &EBO);
|
||||||
|
glDeleteBuffers(1, &VBO);
|
||||||
|
glDeleteVertexArrays(1, &VAO);
|
||||||
|
|
||||||
|
glfwDestroyWindow(window);
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotWindow::GiveContext()
|
||||||
|
{
|
||||||
|
glfwMakeContextCurrent(window);
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotWindow::Clear()
|
||||||
|
{
|
||||||
|
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
||||||
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotWindow::Display()
|
||||||
|
{
|
||||||
|
// model = glm::rotate(model, glm::radians(1.0f), glm::vec3(0.0f, 1.0f, 0.0f));
|
||||||
|
|
||||||
|
static float transX = 0.0f, transY = 0.0f, transZ = 0.0f;
|
||||||
|
static float pitch = 0.0f, yaw = 0.0f, roll = 0.0f;
|
||||||
|
static bool grid = true;
|
||||||
|
|
||||||
|
ImGui_ImplOpenGL3_NewFrame();
|
||||||
|
ImGui_ImplGlfw_NewFrame();
|
||||||
|
|
||||||
|
ImGui::NewFrame();
|
||||||
|
|
||||||
|
ImGui::Begin("Controls");
|
||||||
|
|
||||||
|
if (ImGui::CollapsingHeader("Plot"))
|
||||||
|
{
|
||||||
|
ImGui::Checkbox("Grid", &grid);
|
||||||
|
ImGui::SliderFloat("Scale", &scaling, 0.0f, 10.0f);
|
||||||
|
ImGui::Separator();
|
||||||
|
ImGui::SliderFloat("X", &transX, -5.0f, 5.0f);
|
||||||
|
ImGui::SliderFloat("Y", &transY, -5.0f, 5.0f);
|
||||||
|
ImGui::SliderFloat("Z", &transZ, -5.0f, 5.0f);
|
||||||
|
ImGui::Separator();
|
||||||
|
ImGui::SliderAngle("Pitch", &pitch, -180.0f, 180.f, "%.0f°");
|
||||||
|
ImGui::SliderAngle("Yaw", &yaw, -180.0f, 180.f, "%.0f°");
|
||||||
|
ImGui::SliderAngle("Roll", &roll, -180.0f, 180.f, "%.0f°");
|
||||||
|
}
|
||||||
|
|
||||||
|
ImGui::End();
|
||||||
|
|
||||||
|
//model = glm::mat4(1.0f);
|
||||||
|
//model = glm::translate(model, glm::vec3(transX, transY, transZ));
|
||||||
|
//model = glm::scale(model, glm::vec3(scale, scale, scale));
|
||||||
|
//model = glm::rotate(model, pitch, glm::vec3(1.0f, 0.0f, 0.0f));
|
||||||
|
//model = glm::rotate(model, yaw, glm::vec3(0.0f, 1.0f, 0.0f));
|
||||||
|
//model = glm::rotate(model, roll, glm::vec3(0.0f, 0.0f, 1.0f));
|
||||||
|
|
||||||
|
glBindVertexArray(VAO);
|
||||||
|
|
||||||
|
model *= glm::toMat4(modelRotation);
|
||||||
|
projection = glm::perspective(45.0f, (float)width / (float)height, 0.1f, 100.0f);
|
||||||
|
|
||||||
|
if (grid)
|
||||||
|
{
|
||||||
|
gridShader->Use();
|
||||||
|
gridShader->SetUniformMat4("model", &model[0][0]);
|
||||||
|
gridShader->SetUniformMat4("view", &view[0][0]);
|
||||||
|
gridShader->SetUniformMat4("projection", &projection[0][0]);
|
||||||
|
|
||||||
|
glDrawElements(GL_LINES, indices.size(), GL_UNSIGNED_INT, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
plotShader->Use();
|
||||||
|
|
||||||
|
plotShader->SetUniformMat4("model", &model[0][0]);
|
||||||
|
plotShader->SetUniformMat4("view", &view[0][0]);
|
||||||
|
plotShader->SetUniformMat4("projection", &projection[0][0]);
|
||||||
|
|
||||||
|
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
|
||||||
|
|
||||||
|
ImGui::Render();
|
||||||
|
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
|
||||||
|
|
||||||
|
glfwSwapBuffers(window);
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotWindow::FramebufferSizeCallback(GLFWwindow* window, int w, int h)
|
||||||
|
{
|
||||||
|
glfwMakeContextCurrent(window);
|
||||||
|
width = w;
|
||||||
|
height = h;
|
||||||
|
glViewport(0, 0, w, h);
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotWindow::MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
|
||||||
|
{
|
||||||
|
isLeftButtonDown = ((button == GLFW_MOUSE_BUTTON_LEFT) && (action == GLFW_PRESS));
|
||||||
|
isRightButtonDown = ((button == GLFW_MOUSE_BUTTON_RIGHT) && (action == GLFW_PRESS));
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotWindow::ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
|
||||||
|
{
|
||||||
|
model = glm::scale(model, glm::vec3(1.0f + yoffset / 5.0f));
|
||||||
|
}
|
||||||
|
|
||||||
|
void PlotWindow::CursorPositionCallback(GLFWwindow* window, double xpos, double ypos)
|
||||||
|
{
|
||||||
|
glm::vec2 currentPos = glm::vec2(-ypos, -xpos);
|
||||||
|
glm::vec2 diff = currentPos - prevCursorPos;
|
||||||
|
|
||||||
|
if (isRightButtonDown)
|
||||||
|
{
|
||||||
|
static glm::vec3 xAxis, yAxis;
|
||||||
|
xAxis = glm::inverse(model) * glm::inverse(view) * glm::vec4(1.0f, 0.0f, 0.0, 0.0f);
|
||||||
|
yAxis = glm::inverse(model) * glm::inverse(view) * glm::vec4(0.0f, 1.0f, 0.0, 0.0f);
|
||||||
|
model = glm::rotate(model, -diff.x / 30.f, xAxis);
|
||||||
|
model = glm::rotate(model, -diff.y / 30.f, yAxis);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isLeftButtonDown)
|
||||||
|
{
|
||||||
|
view = glm::translate(view, glm::vec3(-diff.y, diff.x, 0.0f) / 50.0f);
|
||||||
|
}
|
||||||
|
|
||||||
|
prevCursorPos = currentPos;
|
||||||
|
}
|
||||||
67
src/PlotWindow.hpp
Normal file
67
src/PlotWindow.hpp
Normal file
|
|
@ -0,0 +1,67 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include <glad/glad.h>
|
||||||
|
#include <glfw/glfw3.h>
|
||||||
|
|
||||||
|
#include <glm/glm.hpp>
|
||||||
|
#include <glm/gtc/quaternion.hpp>
|
||||||
|
|
||||||
|
#include <imgui/imgui.h>
|
||||||
|
|
||||||
|
#include "Shader.hpp"
|
||||||
|
|
||||||
|
typedef unsigned int BufferObject;
|
||||||
|
|
||||||
|
typedef struct
|
||||||
|
{
|
||||||
|
float x, y, z;
|
||||||
|
float arg;
|
||||||
|
} Vertex;
|
||||||
|
|
||||||
|
class PlotWindow
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
PlotWindow(int w, int h, int id, unsigned int detail, std::string title);
|
||||||
|
|
||||||
|
bool ShouldClose() { return glfwWindowShouldClose(window); }
|
||||||
|
void Destroy();
|
||||||
|
|
||||||
|
void GiveContext();
|
||||||
|
virtual void Clear();
|
||||||
|
virtual void Display();
|
||||||
|
|
||||||
|
private:
|
||||||
|
int id;
|
||||||
|
GLFWwindow* window;
|
||||||
|
BufferObject VAO, VBO, EBO;
|
||||||
|
|
||||||
|
Shader* plotShader, *gridShader;
|
||||||
|
|
||||||
|
std::vector<Vertex> vertices;
|
||||||
|
std::vector<unsigned int> indices;
|
||||||
|
|
||||||
|
static inline glm::mat4 model = glm::mat4(1.0f);
|
||||||
|
static inline glm::quat modelRotation = glm::quat();
|
||||||
|
static inline glm::mat4 modelScale = glm::mat4(1.0f);
|
||||||
|
static inline glm::mat4 view = glm::mat4(1.0f);
|
||||||
|
glm::mat4 projection;
|
||||||
|
|
||||||
|
static inline bool isInit = false;
|
||||||
|
static inline bool isLeftButtonDown = false;
|
||||||
|
static inline bool isRightButtonDown = false;
|
||||||
|
|
||||||
|
static inline float scaling = 1.0f;
|
||||||
|
|
||||||
|
static inline glm::vec2 prevCursorPos = glm::vec2(1.0f, 1.0f);
|
||||||
|
|
||||||
|
static inline int width = 0, height = 0;
|
||||||
|
|
||||||
|
private:
|
||||||
|
static void FramebufferSizeCallback(GLFWwindow* window, int w, int h);
|
||||||
|
static void MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
|
||||||
|
static void ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
|
||||||
|
static void CursorPositionCallback(GLFWwindow* window, double xpos, double ypos);
|
||||||
|
};
|
||||||
40
src/main.cpp
Normal file
40
src/main.cpp
Normal file
|
|
@ -0,0 +1,40 @@
|
||||||
|
#include <iostream>
|
||||||
|
#include <vector>
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
|
#include <glad/glad.h>
|
||||||
|
#include <glfw/glfw3.h>
|
||||||
|
|
||||||
|
#include "PlotManager.hpp"
|
||||||
|
|
||||||
|
int main(int argc, char** argv)
|
||||||
|
{
|
||||||
|
srand(time(0));
|
||||||
|
|
||||||
|
int result = glfwInit();
|
||||||
|
if (result != GL_TRUE)
|
||||||
|
{
|
||||||
|
const char* buffer = new char[512];
|
||||||
|
glfwGetError(&buffer);
|
||||||
|
std::cout << "Failed to initialize GLFW: " << std::endl << buffer << std::endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
|
||||||
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
|
||||||
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
||||||
|
glfwWindowHint(GLFW_SAMPLES, 4);
|
||||||
|
|
||||||
|
|
||||||
|
std::string input;
|
||||||
|
std::cout << "> ";
|
||||||
|
std::cin >> input;
|
||||||
|
std::cout << std::endl;
|
||||||
|
|
||||||
|
PlotManager::NewPlot(input);
|
||||||
|
|
||||||
|
while (PlotManager::isOpen)
|
||||||
|
{
|
||||||
|
glfwPollEvents();
|
||||||
|
PlotManager::Loop();
|
||||||
|
}
|
||||||
|
}
|
||||||
104
src/objects/Shader.cpp
Normal file
104
src/objects/Shader.cpp
Normal file
|
|
@ -0,0 +1,104 @@
|
||||||
|
#include "Shader.hpp"
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
#include <fstream>
|
||||||
|
|
||||||
|
Shader::Shader(const char* vertShaderPath, const char* fragShaderPath) :
|
||||||
|
program(0)
|
||||||
|
{
|
||||||
|
int success;
|
||||||
|
char errorBuffer[512];
|
||||||
|
|
||||||
|
// Create Vertex shader
|
||||||
|
unsigned int vert;
|
||||||
|
vert = glCreateShader(GL_VERTEX_SHADER);
|
||||||
|
char* sourceBuffer;
|
||||||
|
LoadShaderSource(vertShaderPath, &sourceBuffer);
|
||||||
|
if (sourceBuffer == nullptr)
|
||||||
|
sourceBuffer = "";
|
||||||
|
|
||||||
|
glShaderSource(vert, 1, &sourceBuffer, NULL);
|
||||||
|
glCompileShader(vert);
|
||||||
|
glGetShaderiv(vert, GL_COMPILE_STATUS, &success);
|
||||||
|
if (!success)
|
||||||
|
{
|
||||||
|
glGetShaderInfoLog(vert, 512, NULL, errorBuffer);
|
||||||
|
std::cerr << vertShaderPath << std::endl << errorBuffer << std::endl;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Create Fragment shader
|
||||||
|
unsigned int frag;
|
||||||
|
frag = glCreateShader(GL_FRAGMENT_SHADER);
|
||||||
|
LoadShaderSource(fragShaderPath, &sourceBuffer);
|
||||||
|
if (sourceBuffer == nullptr)
|
||||||
|
sourceBuffer = "";
|
||||||
|
|
||||||
|
glShaderSource(frag, 1, &sourceBuffer, NULL);
|
||||||
|
glCompileShader(frag);
|
||||||
|
glGetShaderiv(frag, GL_COMPILE_STATUS, &success);
|
||||||
|
if (!success)
|
||||||
|
{
|
||||||
|
glGetShaderInfoLog(frag, 512, NULL, errorBuffer);
|
||||||
|
std::cerr << fragShaderPath << std::endl << errorBuffer << std::endl;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Link shaders
|
||||||
|
program = glCreateProgram();
|
||||||
|
glAttachShader(program, vert);
|
||||||
|
glAttachShader(program, frag);
|
||||||
|
glLinkProgram(program);
|
||||||
|
glGetProgramiv(program, GL_LINK_STATUS, &success);
|
||||||
|
if (!success)
|
||||||
|
{
|
||||||
|
glGetProgramInfoLog(program, 512, NULL, errorBuffer);
|
||||||
|
std::cerr << errorBuffer << std::endl;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
glDeleteShader(frag);
|
||||||
|
glDeleteShader(vert);
|
||||||
|
}
|
||||||
|
|
||||||
|
Shader::~Shader()
|
||||||
|
{
|
||||||
|
glDeleteProgram(program);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Shader::Use()
|
||||||
|
{
|
||||||
|
glUseProgram(program);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Shader::SetUniformMat4(const char* location, const float* value) const
|
||||||
|
{
|
||||||
|
glUniformMatrix4fv(glGetUniformLocation(program, location), 1, GL_FALSE, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Shader::LoadShaderSource(const char* filepath, char** buffer)
|
||||||
|
{
|
||||||
|
std::ifstream file(filepath);
|
||||||
|
if (!file.good())
|
||||||
|
{
|
||||||
|
std::cerr << "Failed to open file: " << filepath << std::endl;
|
||||||
|
*buffer = nullptr;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string source(
|
||||||
|
(std::istreambuf_iterator<char>(file)),
|
||||||
|
std::istreambuf_iterator<char>()
|
||||||
|
);
|
||||||
|
size_t len = source.size();
|
||||||
|
|
||||||
|
*buffer = (char*)malloc(len + sizeof(char));
|
||||||
|
if (*buffer == nullptr)
|
||||||
|
{
|
||||||
|
std::cerr << "Failed to allocate memory for shader source code" << std::endl;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
memcpy_s(*buffer, len, source.c_str(), len);
|
||||||
|
(*buffer)[len] = '\0';
|
||||||
|
}
|
||||||
23
src/objects/Shader.hpp
Normal file
23
src/objects/Shader.hpp
Normal file
|
|
@ -0,0 +1,23 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <glad/glad.h>
|
||||||
|
|
||||||
|
typedef unsigned int ProgramID;
|
||||||
|
|
||||||
|
class Shader
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
Shader(const char* vertShaderPath, const char* fragShaderPath);
|
||||||
|
~Shader();
|
||||||
|
|
||||||
|
void Use();
|
||||||
|
|
||||||
|
void SetUniformMat4(const char* location, const float* value) const;
|
||||||
|
|
||||||
|
private:
|
||||||
|
|
||||||
|
static void LoadShaderSource(const char* filepath, char** buffer);
|
||||||
|
|
||||||
|
private:
|
||||||
|
ProgramID program;
|
||||||
|
};
|
||||||
290
vendor/include/KHR/khrplatform.h
vendored
Normal file
290
vendor/include/KHR/khrplatform.h
vendored
Normal file
|
|
@ -0,0 +1,290 @@
|
||||||
|
#ifndef __khrplatform_h_
|
||||||
|
#define __khrplatform_h_
|
||||||
|
|
||||||
|
/*
|
||||||
|
** Copyright (c) 2008-2018 The Khronos Group Inc.
|
||||||
|
**
|
||||||
|
** Permission is hereby granted, free of charge, to any person obtaining a
|
||||||
|
** copy of this software and/or associated documentation files (the
|
||||||
|
** "Materials"), to deal in the Materials without restriction, including
|
||||||
|
** without limitation the rights to use, copy, modify, merge, publish,
|
||||||
|
** distribute, sublicense, and/or sell copies of the Materials, and to
|
||||||
|
** permit persons to whom the Materials are furnished to do so, subject to
|
||||||
|
** the following conditions:
|
||||||
|
**
|
||||||
|
** The above copyright notice and this permission notice shall be included
|
||||||
|
** in all copies or substantial portions of the Materials.
|
||||||
|
**
|
||||||
|
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||||
|
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||||
|
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||||
|
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||||
|
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* Khronos platform-specific types and definitions.
|
||||||
|
*
|
||||||
|
* The master copy of khrplatform.h is maintained in the Khronos EGL
|
||||||
|
* Registry repository at https://github.com/KhronosGroup/EGL-Registry
|
||||||
|
* The last semantic modification to khrplatform.h was at commit ID:
|
||||||
|
* 67a3e0864c2d75ea5287b9f3d2eb74a745936692
|
||||||
|
*
|
||||||
|
* Adopters may modify this file to suit their platform. Adopters are
|
||||||
|
* encouraged to submit platform specific modifications to the Khronos
|
||||||
|
* group so that they can be included in future versions of this file.
|
||||||
|
* Please submit changes by filing pull requests or issues on
|
||||||
|
* the EGL Registry repository linked above.
|
||||||
|
*
|
||||||
|
*
|
||||||
|
* See the Implementer's Guidelines for information about where this file
|
||||||
|
* should be located on your system and for more details of its use:
|
||||||
|
* http://www.khronos.org/registry/implementers_guide.pdf
|
||||||
|
*
|
||||||
|
* This file should be included as
|
||||||
|
* #include <KHR/khrplatform.h>
|
||||||
|
* by Khronos client API header files that use its types and defines.
|
||||||
|
*
|
||||||
|
* The types in khrplatform.h should only be used to define API-specific types.
|
||||||
|
*
|
||||||
|
* Types defined in khrplatform.h:
|
||||||
|
* khronos_int8_t signed 8 bit
|
||||||
|
* khronos_uint8_t unsigned 8 bit
|
||||||
|
* khronos_int16_t signed 16 bit
|
||||||
|
* khronos_uint16_t unsigned 16 bit
|
||||||
|
* khronos_int32_t signed 32 bit
|
||||||
|
* khronos_uint32_t unsigned 32 bit
|
||||||
|
* khronos_int64_t signed 64 bit
|
||||||
|
* khronos_uint64_t unsigned 64 bit
|
||||||
|
* khronos_intptr_t signed same number of bits as a pointer
|
||||||
|
* khronos_uintptr_t unsigned same number of bits as a pointer
|
||||||
|
* khronos_ssize_t signed size
|
||||||
|
* khronos_usize_t unsigned size
|
||||||
|
* khronos_float_t signed 32 bit floating point
|
||||||
|
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
|
||||||
|
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
|
||||||
|
* nanoseconds
|
||||||
|
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
|
||||||
|
* khronos_boolean_enum_t enumerated boolean type. This should
|
||||||
|
* only be used as a base type when a client API's boolean type is
|
||||||
|
* an enum. Client APIs which use an integer or other type for
|
||||||
|
* booleans cannot use this as the base type for their boolean.
|
||||||
|
*
|
||||||
|
* Tokens defined in khrplatform.h:
|
||||||
|
*
|
||||||
|
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
|
||||||
|
*
|
||||||
|
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
|
||||||
|
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
|
||||||
|
*
|
||||||
|
* Calling convention macros defined in this file:
|
||||||
|
* KHRONOS_APICALL
|
||||||
|
* KHRONOS_APIENTRY
|
||||||
|
* KHRONOS_APIATTRIBUTES
|
||||||
|
*
|
||||||
|
* These may be used in function prototypes as:
|
||||||
|
*
|
||||||
|
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
|
||||||
|
* int arg1,
|
||||||
|
* int arg2) KHRONOS_APIATTRIBUTES;
|
||||||
|
*/
|
||||||
|
|
||||||
|
#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
|
||||||
|
# define KHRONOS_STATIC 1
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* Definition of KHRONOS_APICALL
|
||||||
|
*-------------------------------------------------------------------------
|
||||||
|
* This precedes the return type of the function in the function prototype.
|
||||||
|
*/
|
||||||
|
#if defined(KHRONOS_STATIC)
|
||||||
|
/* If the preprocessor constant KHRONOS_STATIC is defined, make the
|
||||||
|
* header compatible with static linking. */
|
||||||
|
# define KHRONOS_APICALL
|
||||||
|
#elif defined(_WIN32)
|
||||||
|
# define KHRONOS_APICALL __declspec(dllimport)
|
||||||
|
#elif defined (__SYMBIAN32__)
|
||||||
|
# define KHRONOS_APICALL IMPORT_C
|
||||||
|
#elif defined(__ANDROID__)
|
||||||
|
# define KHRONOS_APICALL __attribute__((visibility("default")))
|
||||||
|
#else
|
||||||
|
# define KHRONOS_APICALL
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* Definition of KHRONOS_APIENTRY
|
||||||
|
*-------------------------------------------------------------------------
|
||||||
|
* This follows the return type of the function and precedes the function
|
||||||
|
* name in the function prototype.
|
||||||
|
*/
|
||||||
|
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
|
||||||
|
/* Win32 but not WinCE */
|
||||||
|
# define KHRONOS_APIENTRY __stdcall
|
||||||
|
#else
|
||||||
|
# define KHRONOS_APIENTRY
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* Definition of KHRONOS_APIATTRIBUTES
|
||||||
|
*-------------------------------------------------------------------------
|
||||||
|
* This follows the closing parenthesis of the function prototype arguments.
|
||||||
|
*/
|
||||||
|
#if defined (__ARMCC_2__)
|
||||||
|
#define KHRONOS_APIATTRIBUTES __softfp
|
||||||
|
#else
|
||||||
|
#define KHRONOS_APIATTRIBUTES
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* basic type definitions
|
||||||
|
*-----------------------------------------------------------------------*/
|
||||||
|
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Using <stdint.h>
|
||||||
|
*/
|
||||||
|
#include <stdint.h>
|
||||||
|
typedef int32_t khronos_int32_t;
|
||||||
|
typedef uint32_t khronos_uint32_t;
|
||||||
|
typedef int64_t khronos_int64_t;
|
||||||
|
typedef uint64_t khronos_uint64_t;
|
||||||
|
#define KHRONOS_SUPPORT_INT64 1
|
||||||
|
#define KHRONOS_SUPPORT_FLOAT 1
|
||||||
|
|
||||||
|
#elif defined(__VMS ) || defined(__sgi)
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Using <inttypes.h>
|
||||||
|
*/
|
||||||
|
#include <inttypes.h>
|
||||||
|
typedef int32_t khronos_int32_t;
|
||||||
|
typedef uint32_t khronos_uint32_t;
|
||||||
|
typedef int64_t khronos_int64_t;
|
||||||
|
typedef uint64_t khronos_uint64_t;
|
||||||
|
#define KHRONOS_SUPPORT_INT64 1
|
||||||
|
#define KHRONOS_SUPPORT_FLOAT 1
|
||||||
|
|
||||||
|
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Win32
|
||||||
|
*/
|
||||||
|
typedef __int32 khronos_int32_t;
|
||||||
|
typedef unsigned __int32 khronos_uint32_t;
|
||||||
|
typedef __int64 khronos_int64_t;
|
||||||
|
typedef unsigned __int64 khronos_uint64_t;
|
||||||
|
#define KHRONOS_SUPPORT_INT64 1
|
||||||
|
#define KHRONOS_SUPPORT_FLOAT 1
|
||||||
|
|
||||||
|
#elif defined(__sun__) || defined(__digital__)
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Sun or Digital
|
||||||
|
*/
|
||||||
|
typedef int khronos_int32_t;
|
||||||
|
typedef unsigned int khronos_uint32_t;
|
||||||
|
#if defined(__arch64__) || defined(_LP64)
|
||||||
|
typedef long int khronos_int64_t;
|
||||||
|
typedef unsigned long int khronos_uint64_t;
|
||||||
|
#else
|
||||||
|
typedef long long int khronos_int64_t;
|
||||||
|
typedef unsigned long long int khronos_uint64_t;
|
||||||
|
#endif /* __arch64__ */
|
||||||
|
#define KHRONOS_SUPPORT_INT64 1
|
||||||
|
#define KHRONOS_SUPPORT_FLOAT 1
|
||||||
|
|
||||||
|
#elif 0
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Hypothetical platform with no float or int64 support
|
||||||
|
*/
|
||||||
|
typedef int khronos_int32_t;
|
||||||
|
typedef unsigned int khronos_uint32_t;
|
||||||
|
#define KHRONOS_SUPPORT_INT64 0
|
||||||
|
#define KHRONOS_SUPPORT_FLOAT 0
|
||||||
|
|
||||||
|
#else
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Generic fallback
|
||||||
|
*/
|
||||||
|
#include <stdint.h>
|
||||||
|
typedef int32_t khronos_int32_t;
|
||||||
|
typedef uint32_t khronos_uint32_t;
|
||||||
|
typedef int64_t khronos_int64_t;
|
||||||
|
typedef uint64_t khronos_uint64_t;
|
||||||
|
#define KHRONOS_SUPPORT_INT64 1
|
||||||
|
#define KHRONOS_SUPPORT_FLOAT 1
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Types that are (so far) the same on all platforms
|
||||||
|
*/
|
||||||
|
typedef signed char khronos_int8_t;
|
||||||
|
typedef unsigned char khronos_uint8_t;
|
||||||
|
typedef signed short int khronos_int16_t;
|
||||||
|
typedef unsigned short int khronos_uint16_t;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Types that differ between LLP64 and LP64 architectures - in LLP64,
|
||||||
|
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
|
||||||
|
* to be the only LLP64 architecture in current use.
|
||||||
|
*/
|
||||||
|
#ifdef _WIN64
|
||||||
|
typedef signed long long int khronos_intptr_t;
|
||||||
|
typedef unsigned long long int khronos_uintptr_t;
|
||||||
|
typedef signed long long int khronos_ssize_t;
|
||||||
|
typedef unsigned long long int khronos_usize_t;
|
||||||
|
#else
|
||||||
|
typedef signed long int khronos_intptr_t;
|
||||||
|
typedef unsigned long int khronos_uintptr_t;
|
||||||
|
typedef signed long int khronos_ssize_t;
|
||||||
|
typedef unsigned long int khronos_usize_t;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if KHRONOS_SUPPORT_FLOAT
|
||||||
|
/*
|
||||||
|
* Float type
|
||||||
|
*/
|
||||||
|
typedef float khronos_float_t;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if KHRONOS_SUPPORT_INT64
|
||||||
|
/* Time types
|
||||||
|
*
|
||||||
|
* These types can be used to represent a time interval in nanoseconds or
|
||||||
|
* an absolute Unadjusted System Time. Unadjusted System Time is the number
|
||||||
|
* of nanoseconds since some arbitrary system event (e.g. since the last
|
||||||
|
* time the system booted). The Unadjusted System Time is an unsigned
|
||||||
|
* 64 bit value that wraps back to 0 every 584 years. Time intervals
|
||||||
|
* may be either signed or unsigned.
|
||||||
|
*/
|
||||||
|
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
|
||||||
|
typedef khronos_int64_t khronos_stime_nanoseconds_t;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Dummy value used to pad enum types to 32 bits.
|
||||||
|
*/
|
||||||
|
#ifndef KHRONOS_MAX_ENUM
|
||||||
|
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Enumerated boolean type
|
||||||
|
*
|
||||||
|
* Values other than zero should be considered to be true. Therefore
|
||||||
|
* comparisons should not be made against KHRONOS_TRUE.
|
||||||
|
*/
|
||||||
|
typedef enum {
|
||||||
|
KHRONOS_FALSE = 0,
|
||||||
|
KHRONOS_TRUE = 1,
|
||||||
|
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
|
||||||
|
} khronos_boolean_enum_t;
|
||||||
|
|
||||||
|
#endif /* __khrplatform_h_ */
|
||||||
3682
vendor/include/glad/glad.h
vendored
Normal file
3682
vendor/include/glad/glad.h
vendored
Normal file
File diff suppressed because it is too large
Load diff
539
vendor/include/glm/common.hpp
vendored
Normal file
539
vendor/include/glm/common.hpp
vendored
Normal file
|
|
@ -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"
|
||||||
|
|
||||||
394
vendor/include/glm/detail/_features.hpp
vendored
Normal file
394
vendor/include/glm/detail/_features.hpp
vendored
Normal file
|
|
@ -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)
|
||||||
27
vendor/include/glm/detail/_fixes.hpp
vendored
Normal file
27
vendor/include/glm/detail/_fixes.hpp
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
81
vendor/include/glm/detail/_noise.hpp
vendored
Normal file
81
vendor/include/glm/detail/_noise.hpp
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
804
vendor/include/glm/detail/_swizzle.hpp
vendored
Normal file
804
vendor/include/glm/detail/_swizzle.hpp
vendored
Normal file
|
|
@ -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; };
|
||||||
682
vendor/include/glm/detail/_swizzle_func.hpp
vendored
Normal file
682
vendor/include/glm/detail/_swizzle_func.hpp
vendored
Normal file
|
|
@ -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)
|
||||||
|
|
||||||
162
vendor/include/glm/detail/_vectorize.hpp
vendored
Normal file
162
vendor/include/glm/detail/_vectorize.hpp
vendored
Normal file
|
|
@ -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
|
||||||
50
vendor/include/glm/detail/compute_common.hpp
vendored
Normal file
50
vendor/include/glm/detail/compute_common.hpp
vendored
Normal file
|
|
@ -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
|
||||||
30
vendor/include/glm/detail/compute_vector_relational.hpp
vendored
Normal file
30
vendor/include/glm/detail/compute_vector_relational.hpp
vendored
Normal file
|
|
@ -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
|
||||||
792
vendor/include/glm/detail/func_common.inl
vendored
Normal file
792
vendor/include/glm/detail/func_common.inl
vendored
Normal file
|
|
@ -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
|
||||||
231
vendor/include/glm/detail/func_common_simd.inl
vendored
Normal file
231
vendor/include/glm/detail/func_common_simd.inl
vendored
Normal file
|
|
@ -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
|
||||||
152
vendor/include/glm/detail/func_exponential.inl
vendored
Normal file
152
vendor/include/glm/detail/func_exponential.inl
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
37
vendor/include/glm/detail/func_exponential_simd.inl
vendored
Normal file
37
vendor/include/glm/detail/func_exponential_simd.inl
vendored
Normal file
|
|
@ -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
|
||||||
243
vendor/include/glm/detail/func_geometric.inl
vendored
Normal file
243
vendor/include/glm/detail/func_geometric.inl
vendored
Normal file
|
|
@ -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
|
||||||
163
vendor/include/glm/detail/func_geometric_simd.inl
vendored
Normal file
163
vendor/include/glm/detail/func_geometric_simd.inl
vendored
Normal file
|
|
@ -0,0 +1,163 @@
|
||||||
|
/// @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 sqrt(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);
|
||||||
|
return vaddvq_f32(v);
|
||||||
|
#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
|
||||||
372
vendor/include/glm/detail/func_integer.inl
vendored
Normal file
372
vendor/include/glm/detail/func_integer.inl
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
65
vendor/include/glm/detail/func_integer_simd.inl
vendored
Normal file
65
vendor/include/glm/detail/func_integer_simd.inl
vendored
Normal file
|
|
@ -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
|
||||||
398
vendor/include/glm/detail/func_matrix.inl
vendored
Normal file
398
vendor/include/glm/detail/func_matrix.inl
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
249
vendor/include/glm/detail/func_matrix_simd.inl
vendored
Normal file
249
vendor/include/glm/detail/func_matrix_simd.inl
vendored
Normal file
|
|
@ -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
|
||||||
189
vendor/include/glm/detail/func_packing.inl
vendored
Normal file
189
vendor/include/glm/detail/func_packing.inl
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
6
vendor/include/glm/detail/func_packing_simd.inl
vendored
Normal file
6
vendor/include/glm/detail/func_packing_simd.inl
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
||||||
|
namespace glm{
|
||||||
|
namespace detail
|
||||||
|
{
|
||||||
|
|
||||||
|
}//namespace detail
|
||||||
|
}//namespace glm
|
||||||
197
vendor/include/glm/detail/func_trigonometric.inl
vendored
Normal file
197
vendor/include/glm/detail/func_trigonometric.inl
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
0
vendor/include/glm/detail/func_trigonometric_simd.inl
vendored
Normal file
0
vendor/include/glm/detail/func_trigonometric_simd.inl
vendored
Normal file
87
vendor/include/glm/detail/func_vector_relational.inl
vendored
Normal file
87
vendor/include/glm/detail/func_vector_relational.inl
vendored
Normal file
|
|
@ -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
|
||||||
6
vendor/include/glm/detail/func_vector_relational_simd.inl
vendored
Normal file
6
vendor/include/glm/detail/func_vector_relational_simd.inl
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
||||||
|
namespace glm{
|
||||||
|
namespace detail
|
||||||
|
{
|
||||||
|
|
||||||
|
}//namespace detail
|
||||||
|
}//namespace glm
|
||||||
263
vendor/include/glm/detail/glm.cpp
vendored
Normal file
263
vendor/include/glm/detail/glm.cpp
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
230
vendor/include/glm/detail/qualifier.hpp
vendored
Normal file
230
vendor/include/glm/detail/qualifier.hpp
vendored
Normal file
|
|
@ -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
|
||||||
1135
vendor/include/glm/detail/setup.hpp
vendored
Normal file
1135
vendor/include/glm/detail/setup.hpp
vendored
Normal file
File diff suppressed because it is too large
Load diff
68
vendor/include/glm/detail/type_float.hpp
vendored
Normal file
68
vendor/include/glm/detail/type_float.hpp
vendored
Normal file
|
|
@ -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
|
||||||
16
vendor/include/glm/detail/type_half.hpp
vendored
Normal file
16
vendor/include/glm/detail/type_half.hpp
vendored
Normal file
|
|
@ -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"
|
||||||
241
vendor/include/glm/detail/type_half.inl
vendored
Normal file
241
vendor/include/glm/detail/type_half.inl
vendored
Normal file
|
|
@ -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
|
||||||
177
vendor/include/glm/detail/type_mat2x2.hpp
vendored
Normal file
177
vendor/include/glm/detail/type_mat2x2.hpp
vendored
Normal file
|
|
@ -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
|
||||||
536
vendor/include/glm/detail/type_mat2x2.inl
vendored
Normal file
536
vendor/include/glm/detail/type_mat2x2.inl
vendored
Normal file
|
|
@ -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
|
||||||
159
vendor/include/glm/detail/type_mat2x3.hpp
vendored
Normal file
159
vendor/include/glm/detail/type_mat2x3.hpp
vendored
Normal file
|
|
@ -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
|
||||||
510
vendor/include/glm/detail/type_mat2x3.inl
vendored
Normal file
510
vendor/include/glm/detail/type_mat2x3.inl
vendored
Normal file
|
|
@ -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
|
||||||
161
vendor/include/glm/detail/type_mat2x4.hpp
vendored
Normal file
161
vendor/include/glm/detail/type_mat2x4.hpp
vendored
Normal file
|
|
@ -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
|
||||||
520
vendor/include/glm/detail/type_mat2x4.inl
vendored
Normal file
520
vendor/include/glm/detail/type_mat2x4.inl
vendored
Normal file
|
|
@ -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
|
||||||
167
vendor/include/glm/detail/type_mat3x2.hpp
vendored
Normal file
167
vendor/include/glm/detail/type_mat3x2.hpp
vendored
Normal file
|
|
@ -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
|
||||||
532
vendor/include/glm/detail/type_mat3x2.inl
vendored
Normal file
532
vendor/include/glm/detail/type_mat3x2.inl
vendored
Normal file
|
|
@ -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
|
||||||
184
vendor/include/glm/detail/type_mat3x3.hpp
vendored
Normal file
184
vendor/include/glm/detail/type_mat3x3.hpp
vendored
Normal file
|
|
@ -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
|
||||||
601
vendor/include/glm/detail/type_mat3x3.inl
vendored
Normal file
601
vendor/include/glm/detail/type_mat3x3.inl
vendored
Normal file
|
|
@ -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
|
||||||
166
vendor/include/glm/detail/type_mat3x4.hpp
vendored
Normal file
166
vendor/include/glm/detail/type_mat3x4.hpp
vendored
Normal file
|
|
@ -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
|
||||||
578
vendor/include/glm/detail/type_mat3x4.inl
vendored
Normal file
578
vendor/include/glm/detail/type_mat3x4.inl
vendored
Normal file
|
|
@ -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
|
||||||
171
vendor/include/glm/detail/type_mat4x2.hpp
vendored
Normal file
171
vendor/include/glm/detail/type_mat4x2.hpp
vendored
Normal file
|
|
@ -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
|
||||||
574
vendor/include/glm/detail/type_mat4x2.inl
vendored
Normal file
574
vendor/include/glm/detail/type_mat4x2.inl
vendored
Normal file
|
|
@ -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
|
||||||
171
vendor/include/glm/detail/type_mat4x3.hpp
vendored
Normal file
171
vendor/include/glm/detail/type_mat4x3.hpp
vendored
Normal file
|
|
@ -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
|
||||||
598
vendor/include/glm/detail/type_mat4x3.inl
vendored
Normal file
598
vendor/include/glm/detail/type_mat4x3.inl
vendored
Normal file
|
|
@ -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
|
||||||
189
vendor/include/glm/detail/type_mat4x4.hpp
vendored
Normal file
189
vendor/include/glm/detail/type_mat4x4.hpp
vendored
Normal file
|
|
@ -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
|
||||||
706
vendor/include/glm/detail/type_mat4x4.inl
vendored
Normal file
706
vendor/include/glm/detail/type_mat4x4.inl
vendored
Normal file
|
|
@ -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
|
||||||
6
vendor/include/glm/detail/type_mat4x4_simd.inl
vendored
Normal file
6
vendor/include/glm/detail/type_mat4x4_simd.inl
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
||||||
|
/// @ref core
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
|
||||||
|
}//namespace glm
|
||||||
186
vendor/include/glm/detail/type_quat.hpp
vendored
Normal file
186
vendor/include/glm/detail/type_quat.hpp
vendored
Normal file
|
|
@ -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
|
||||||
408
vendor/include/glm/detail/type_quat.inl
vendored
Normal file
408
vendor/include/glm/detail/type_quat.inl
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
188
vendor/include/glm/detail/type_quat_simd.inl
vendored
Normal file
188
vendor/include/glm/detail/type_quat_simd.inl
vendored
Normal file
|
|
@ -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
|
||||||
|
|
||||||
308
vendor/include/glm/detail/type_vec1.hpp
vendored
Normal file
308
vendor/include/glm/detail/type_vec1.hpp
vendored
Normal file
|
|
@ -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
|
||||||
551
vendor/include/glm/detail/type_vec1.inl
vendored
Normal file
551
vendor/include/glm/detail/type_vec1.inl
vendored
Normal file
|
|
@ -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>(
|
||||||
|
static_cast<T>(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>(
|
||||||
|
static_cast<T>(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>(
|
||||||
|
static_cast<T>(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>(
|
||||||
|
static_cast<T>(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
|
||||||
399
vendor/include/glm/detail/type_vec2.hpp
vendored
Normal file
399
vendor/include/glm/detail/type_vec2.hpp
vendored
Normal file
|
|
@ -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
|
||||||
913
vendor/include/glm/detail/type_vec2.inl
vendored
Normal file
913
vendor/include/glm/detail/type_vec2.inl
vendored
Normal file
|
|
@ -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
|
||||||
432
vendor/include/glm/detail/type_vec3.hpp
vendored
Normal file
432
vendor/include/glm/detail/type_vec3.hpp
vendored
Normal file
|
|
@ -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
|
||||||
1068
vendor/include/glm/detail/type_vec3.inl
vendored
Normal file
1068
vendor/include/glm/detail/type_vec3.inl
vendored
Normal file
File diff suppressed because it is too large
Load diff
505
vendor/include/glm/detail/type_vec4.hpp
vendored
Normal file
505
vendor/include/glm/detail/type_vec4.hpp
vendored
Normal file
|
|
@ -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
|
||||||
1140
vendor/include/glm/detail/type_vec4.inl
vendored
Normal file
1140
vendor/include/glm/detail/type_vec4.inl
vendored
Normal file
File diff suppressed because it is too large
Load diff
775
vendor/include/glm/detail/type_vec4_simd.inl
vendored
Normal file
775
vendor/include/glm/detail/type_vec4_simd.inl
vendored
Normal file
|
|
@ -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
|
||||||
110
vendor/include/glm/exponential.hpp
vendored
Normal file
110
vendor/include/glm/exponential.hpp
vendored
Normal file
|
|
@ -0,0 +1,110 @@
|
||||||
|
/// @ref core
|
||||||
|
/// @file glm/exponential.hpp
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
|
||||||
|
///
|
||||||
|
/// @defgroup core_func_exponential Exponential functions
|
||||||
|
/// @ingroup core
|
||||||
|
///
|
||||||
|
/// Provides GLSL exponential functions
|
||||||
|
///
|
||||||
|
/// These all operate component-wise. The description is per component.
|
||||||
|
///
|
||||||
|
/// Include <glm/exponential.hpp> to use these core features.
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "detail/type_vec1.hpp"
|
||||||
|
#include "detail/type_vec2.hpp"
|
||||||
|
#include "detail/type_vec3.hpp"
|
||||||
|
#include "detail/type_vec4.hpp"
|
||||||
|
#include <cmath>
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
/// @addtogroup core_func_exponential
|
||||||
|
/// @{
|
||||||
|
|
||||||
|
/// Returns 'base' raised to the power 'exponent'.
|
||||||
|
///
|
||||||
|
/// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type qualifier.
|
||||||
|
/// @param exponent Floating point value representing the 'exponent'.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
|
||||||
|
template<length_t L, typename T, qualifier Q>
|
||||||
|
GLM_FUNC_DECL vec<L, T, Q> pow(vec<L, T, Q> const& base, vec<L, T, Q> const& exponent);
|
||||||
|
|
||||||
|
/// Returns the natural exponentiation of x, i.e., e^x.
|
||||||
|
///
|
||||||
|
/// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier.
|
||||||
|
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
|
||||||
|
/// @tparam T Floating-point scalar types.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
|
||||||
|
template<length_t L, typename T, qualifier Q>
|
||||||
|
GLM_FUNC_DECL vec<L, T, Q> exp(vec<L, T, Q> const& v);
|
||||||
|
|
||||||
|
/// Returns the natural logarithm of v, i.e.,
|
||||||
|
/// returns the value y which satisfies the equation x = e^y.
|
||||||
|
/// Results are undefined if v <= 0.
|
||||||
|
///
|
||||||
|
/// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier.
|
||||||
|
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
|
||||||
|
/// @tparam T Floating-point scalar types.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
|
||||||
|
template<length_t L, typename T, qualifier Q>
|
||||||
|
GLM_FUNC_DECL vec<L, T, Q> log(vec<L, T, Q> const& v);
|
||||||
|
|
||||||
|
/// Returns 2 raised to the v power.
|
||||||
|
///
|
||||||
|
/// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier.
|
||||||
|
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
|
||||||
|
/// @tparam T Floating-point scalar types.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
|
||||||
|
template<length_t L, typename T, qualifier Q>
|
||||||
|
GLM_FUNC_DECL vec<L, T, Q> exp2(vec<L, T, Q> const& v);
|
||||||
|
|
||||||
|
/// Returns the base 2 log of x, i.e., returns the value y,
|
||||||
|
/// which satisfies the equation x = 2 ^ y.
|
||||||
|
///
|
||||||
|
/// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier.
|
||||||
|
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
|
||||||
|
/// @tparam T Floating-point scalar types.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
|
||||||
|
template<length_t L, typename T, qualifier Q>
|
||||||
|
GLM_FUNC_DECL vec<L, T, Q> log2(vec<L, T, Q> const& v);
|
||||||
|
|
||||||
|
/// Returns the positive square root of v.
|
||||||
|
///
|
||||||
|
/// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier.
|
||||||
|
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
|
||||||
|
/// @tparam T Floating-point scalar types.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
|
||||||
|
template<length_t L, typename T, qualifier Q>
|
||||||
|
GLM_FUNC_DECL vec<L, T, Q> sqrt(vec<L, T, Q> const& v);
|
||||||
|
|
||||||
|
/// Returns the reciprocal of the positive square root of v.
|
||||||
|
///
|
||||||
|
/// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier.
|
||||||
|
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
|
||||||
|
/// @tparam T Floating-point scalar types.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
|
||||||
|
template<length_t L, typename T, qualifier Q>
|
||||||
|
GLM_FUNC_DECL vec<L, T, Q> inversesqrt(vec<L, T, Q> const& v);
|
||||||
|
|
||||||
|
/// @}
|
||||||
|
}//namespace glm
|
||||||
|
|
||||||
|
#include "detail/func_exponential.inl"
|
||||||
253
vendor/include/glm/ext.hpp
vendored
Normal file
253
vendor/include/glm/ext.hpp
vendored
Normal file
|
|
@ -0,0 +1,253 @@
|
||||||
|
/// @file glm/ext.hpp
|
||||||
|
///
|
||||||
|
/// @ref core (Dependence)
|
||||||
|
|
||||||
|
#include "detail/setup.hpp"
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "glm.hpp"
|
||||||
|
|
||||||
|
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED)
|
||||||
|
# define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED
|
||||||
|
# pragma message("GLM: All extensions included (not recommended)")
|
||||||
|
#endif//GLM_MESSAGES
|
||||||
|
|
||||||
|
#include "./ext/matrix_clip_space.hpp"
|
||||||
|
#include "./ext/matrix_common.hpp"
|
||||||
|
|
||||||
|
#include "./ext/matrix_double2x2.hpp"
|
||||||
|
#include "./ext/matrix_double2x2_precision.hpp"
|
||||||
|
#include "./ext/matrix_double2x3.hpp"
|
||||||
|
#include "./ext/matrix_double2x3_precision.hpp"
|
||||||
|
#include "./ext/matrix_double2x4.hpp"
|
||||||
|
#include "./ext/matrix_double2x4_precision.hpp"
|
||||||
|
#include "./ext/matrix_double3x2.hpp"
|
||||||
|
#include "./ext/matrix_double3x2_precision.hpp"
|
||||||
|
#include "./ext/matrix_double3x3.hpp"
|
||||||
|
#include "./ext/matrix_double3x3_precision.hpp"
|
||||||
|
#include "./ext/matrix_double3x4.hpp"
|
||||||
|
#include "./ext/matrix_double3x4_precision.hpp"
|
||||||
|
#include "./ext/matrix_double4x2.hpp"
|
||||||
|
#include "./ext/matrix_double4x2_precision.hpp"
|
||||||
|
#include "./ext/matrix_double4x3.hpp"
|
||||||
|
#include "./ext/matrix_double4x3_precision.hpp"
|
||||||
|
#include "./ext/matrix_double4x4.hpp"
|
||||||
|
#include "./ext/matrix_double4x4_precision.hpp"
|
||||||
|
|
||||||
|
#include "./ext/matrix_float2x2.hpp"
|
||||||
|
#include "./ext/matrix_float2x2_precision.hpp"
|
||||||
|
#include "./ext/matrix_float2x3.hpp"
|
||||||
|
#include "./ext/matrix_float2x3_precision.hpp"
|
||||||
|
#include "./ext/matrix_float2x4.hpp"
|
||||||
|
#include "./ext/matrix_float2x4_precision.hpp"
|
||||||
|
#include "./ext/matrix_float3x2.hpp"
|
||||||
|
#include "./ext/matrix_float3x2_precision.hpp"
|
||||||
|
#include "./ext/matrix_float3x3.hpp"
|
||||||
|
#include "./ext/matrix_float3x3_precision.hpp"
|
||||||
|
#include "./ext/matrix_float3x4.hpp"
|
||||||
|
#include "./ext/matrix_float3x4_precision.hpp"
|
||||||
|
#include "./ext/matrix_float4x2.hpp"
|
||||||
|
#include "./ext/matrix_float4x2_precision.hpp"
|
||||||
|
#include "./ext/matrix_float4x3.hpp"
|
||||||
|
#include "./ext/matrix_float4x3_precision.hpp"
|
||||||
|
#include "./ext/matrix_float4x4.hpp"
|
||||||
|
#include "./ext/matrix_float4x4_precision.hpp"
|
||||||
|
|
||||||
|
#include "./ext/matrix_int2x2.hpp"
|
||||||
|
#include "./ext/matrix_int2x2_sized.hpp"
|
||||||
|
#include "./ext/matrix_int2x3.hpp"
|
||||||
|
#include "./ext/matrix_int2x3_sized.hpp"
|
||||||
|
#include "./ext/matrix_int2x4.hpp"
|
||||||
|
#include "./ext/matrix_int2x4_sized.hpp"
|
||||||
|
#include "./ext/matrix_int3x2.hpp"
|
||||||
|
#include "./ext/matrix_int3x2_sized.hpp"
|
||||||
|
#include "./ext/matrix_int3x3.hpp"
|
||||||
|
#include "./ext/matrix_int3x3_sized.hpp"
|
||||||
|
#include "./ext/matrix_int3x4.hpp"
|
||||||
|
#include "./ext/matrix_int3x4_sized.hpp"
|
||||||
|
#include "./ext/matrix_int4x2.hpp"
|
||||||
|
#include "./ext/matrix_int4x2_sized.hpp"
|
||||||
|
#include "./ext/matrix_int4x3.hpp"
|
||||||
|
#include "./ext/matrix_int4x3_sized.hpp"
|
||||||
|
#include "./ext/matrix_int4x4.hpp"
|
||||||
|
#include "./ext/matrix_int4x4_sized.hpp"
|
||||||
|
|
||||||
|
#include "./ext/matrix_uint2x2.hpp"
|
||||||
|
#include "./ext/matrix_uint2x2_sized.hpp"
|
||||||
|
#include "./ext/matrix_uint2x3.hpp"
|
||||||
|
#include "./ext/matrix_uint2x3_sized.hpp"
|
||||||
|
#include "./ext/matrix_uint2x4.hpp"
|
||||||
|
#include "./ext/matrix_uint2x4_sized.hpp"
|
||||||
|
#include "./ext/matrix_uint3x2.hpp"
|
||||||
|
#include "./ext/matrix_uint3x2_sized.hpp"
|
||||||
|
#include "./ext/matrix_uint3x3.hpp"
|
||||||
|
#include "./ext/matrix_uint3x3_sized.hpp"
|
||||||
|
#include "./ext/matrix_uint3x4.hpp"
|
||||||
|
#include "./ext/matrix_uint3x4_sized.hpp"
|
||||||
|
#include "./ext/matrix_uint4x2.hpp"
|
||||||
|
#include "./ext/matrix_uint4x2_sized.hpp"
|
||||||
|
#include "./ext/matrix_uint4x3.hpp"
|
||||||
|
#include "./ext/matrix_uint4x3_sized.hpp"
|
||||||
|
#include "./ext/matrix_uint4x4.hpp"
|
||||||
|
#include "./ext/matrix_uint4x4_sized.hpp"
|
||||||
|
|
||||||
|
#include "./ext/matrix_projection.hpp"
|
||||||
|
#include "./ext/matrix_relational.hpp"
|
||||||
|
#include "./ext/matrix_transform.hpp"
|
||||||
|
|
||||||
|
#include "./ext/quaternion_common.hpp"
|
||||||
|
#include "./ext/quaternion_double.hpp"
|
||||||
|
#include "./ext/quaternion_double_precision.hpp"
|
||||||
|
#include "./ext/quaternion_float.hpp"
|
||||||
|
#include "./ext/quaternion_float_precision.hpp"
|
||||||
|
#include "./ext/quaternion_exponential.hpp"
|
||||||
|
#include "./ext/quaternion_geometric.hpp"
|
||||||
|
#include "./ext/quaternion_relational.hpp"
|
||||||
|
#include "./ext/quaternion_transform.hpp"
|
||||||
|
#include "./ext/quaternion_trigonometric.hpp"
|
||||||
|
|
||||||
|
#include "./ext/scalar_common.hpp"
|
||||||
|
#include "./ext/scalar_constants.hpp"
|
||||||
|
#include "./ext/scalar_integer.hpp"
|
||||||
|
#include "./ext/scalar_packing.hpp"
|
||||||
|
#include "./ext/scalar_relational.hpp"
|
||||||
|
#include "./ext/scalar_ulp.hpp"
|
||||||
|
|
||||||
|
#include "./ext/scalar_int_sized.hpp"
|
||||||
|
#include "./ext/scalar_uint_sized.hpp"
|
||||||
|
|
||||||
|
#include "./ext/vector_common.hpp"
|
||||||
|
#include "./ext/vector_integer.hpp"
|
||||||
|
#include "./ext/vector_packing.hpp"
|
||||||
|
#include "./ext/vector_relational.hpp"
|
||||||
|
#include "./ext/vector_ulp.hpp"
|
||||||
|
|
||||||
|
#include "./ext/vector_bool1.hpp"
|
||||||
|
#include "./ext/vector_bool1_precision.hpp"
|
||||||
|
#include "./ext/vector_bool2.hpp"
|
||||||
|
#include "./ext/vector_bool2_precision.hpp"
|
||||||
|
#include "./ext/vector_bool3.hpp"
|
||||||
|
#include "./ext/vector_bool3_precision.hpp"
|
||||||
|
#include "./ext/vector_bool4.hpp"
|
||||||
|
#include "./ext/vector_bool4_precision.hpp"
|
||||||
|
|
||||||
|
#include "./ext/vector_double1.hpp"
|
||||||
|
#include "./ext/vector_double1_precision.hpp"
|
||||||
|
#include "./ext/vector_double2.hpp"
|
||||||
|
#include "./ext/vector_double2_precision.hpp"
|
||||||
|
#include "./ext/vector_double3.hpp"
|
||||||
|
#include "./ext/vector_double3_precision.hpp"
|
||||||
|
#include "./ext/vector_double4.hpp"
|
||||||
|
#include "./ext/vector_double4_precision.hpp"
|
||||||
|
|
||||||
|
#include "./ext/vector_float1.hpp"
|
||||||
|
#include "./ext/vector_float1_precision.hpp"
|
||||||
|
#include "./ext/vector_float2.hpp"
|
||||||
|
#include "./ext/vector_float2_precision.hpp"
|
||||||
|
#include "./ext/vector_float3.hpp"
|
||||||
|
#include "./ext/vector_float3_precision.hpp"
|
||||||
|
#include "./ext/vector_float4.hpp"
|
||||||
|
#include "./ext/vector_float4_precision.hpp"
|
||||||
|
|
||||||
|
#include "./ext/vector_int1.hpp"
|
||||||
|
#include "./ext/vector_int1_sized.hpp"
|
||||||
|
#include "./ext/vector_int2.hpp"
|
||||||
|
#include "./ext/vector_int2_sized.hpp"
|
||||||
|
#include "./ext/vector_int3.hpp"
|
||||||
|
#include "./ext/vector_int3_sized.hpp"
|
||||||
|
#include "./ext/vector_int4.hpp"
|
||||||
|
#include "./ext/vector_int4_sized.hpp"
|
||||||
|
|
||||||
|
#include "./ext/vector_uint1.hpp"
|
||||||
|
#include "./ext/vector_uint1_sized.hpp"
|
||||||
|
#include "./ext/vector_uint2.hpp"
|
||||||
|
#include "./ext/vector_uint2_sized.hpp"
|
||||||
|
#include "./ext/vector_uint3.hpp"
|
||||||
|
#include "./ext/vector_uint3_sized.hpp"
|
||||||
|
#include "./ext/vector_uint4.hpp"
|
||||||
|
#include "./ext/vector_uint4_sized.hpp"
|
||||||
|
|
||||||
|
#include "./gtc/bitfield.hpp"
|
||||||
|
#include "./gtc/color_space.hpp"
|
||||||
|
#include "./gtc/constants.hpp"
|
||||||
|
#include "./gtc/epsilon.hpp"
|
||||||
|
#include "./gtc/integer.hpp"
|
||||||
|
#include "./gtc/matrix_access.hpp"
|
||||||
|
#include "./gtc/matrix_integer.hpp"
|
||||||
|
#include "./gtc/matrix_inverse.hpp"
|
||||||
|
#include "./gtc/matrix_transform.hpp"
|
||||||
|
#include "./gtc/noise.hpp"
|
||||||
|
#include "./gtc/packing.hpp"
|
||||||
|
#include "./gtc/quaternion.hpp"
|
||||||
|
#include "./gtc/random.hpp"
|
||||||
|
#include "./gtc/reciprocal.hpp"
|
||||||
|
#include "./gtc/round.hpp"
|
||||||
|
#include "./gtc/type_precision.hpp"
|
||||||
|
#include "./gtc/type_ptr.hpp"
|
||||||
|
#include "./gtc/ulp.hpp"
|
||||||
|
#include "./gtc/vec1.hpp"
|
||||||
|
#if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
|
||||||
|
# include "./gtc/type_aligned.hpp"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef GLM_ENABLE_EXPERIMENTAL
|
||||||
|
#include "./gtx/associated_min_max.hpp"
|
||||||
|
#include "./gtx/bit.hpp"
|
||||||
|
#include "./gtx/closest_point.hpp"
|
||||||
|
#include "./gtx/color_encoding.hpp"
|
||||||
|
#include "./gtx/color_space.hpp"
|
||||||
|
#include "./gtx/color_space_YCoCg.hpp"
|
||||||
|
#include "./gtx/compatibility.hpp"
|
||||||
|
#include "./gtx/component_wise.hpp"
|
||||||
|
#include "./gtx/dual_quaternion.hpp"
|
||||||
|
#include "./gtx/euler_angles.hpp"
|
||||||
|
#include "./gtx/extend.hpp"
|
||||||
|
#include "./gtx/extended_min_max.hpp"
|
||||||
|
#include "./gtx/fast_exponential.hpp"
|
||||||
|
#include "./gtx/fast_square_root.hpp"
|
||||||
|
#include "./gtx/fast_trigonometry.hpp"
|
||||||
|
#include "./gtx/functions.hpp"
|
||||||
|
#include "./gtx/gradient_paint.hpp"
|
||||||
|
#include "./gtx/handed_coordinate_space.hpp"
|
||||||
|
#include "./gtx/integer.hpp"
|
||||||
|
#include "./gtx/intersect.hpp"
|
||||||
|
#include "./gtx/log_base.hpp"
|
||||||
|
#include "./gtx/matrix_cross_product.hpp"
|
||||||
|
#include "./gtx/matrix_interpolation.hpp"
|
||||||
|
#include "./gtx/matrix_major_storage.hpp"
|
||||||
|
#include "./gtx/matrix_operation.hpp"
|
||||||
|
#include "./gtx/matrix_query.hpp"
|
||||||
|
#include "./gtx/mixed_product.hpp"
|
||||||
|
#include "./gtx/norm.hpp"
|
||||||
|
#include "./gtx/normal.hpp"
|
||||||
|
#include "./gtx/normalize_dot.hpp"
|
||||||
|
#include "./gtx/number_precision.hpp"
|
||||||
|
#include "./gtx/optimum_pow.hpp"
|
||||||
|
#include "./gtx/orthonormalize.hpp"
|
||||||
|
#include "./gtx/perpendicular.hpp"
|
||||||
|
#include "./gtx/polar_coordinates.hpp"
|
||||||
|
#include "./gtx/projection.hpp"
|
||||||
|
#include "./gtx/quaternion.hpp"
|
||||||
|
#include "./gtx/raw_data.hpp"
|
||||||
|
#include "./gtx/rotate_vector.hpp"
|
||||||
|
#include "./gtx/spline.hpp"
|
||||||
|
#include "./gtx/std_based_type.hpp"
|
||||||
|
#if !(GLM_COMPILER & GLM_COMPILER_CUDA)
|
||||||
|
# include "./gtx/string_cast.hpp"
|
||||||
|
#endif
|
||||||
|
#include "./gtx/transform.hpp"
|
||||||
|
#include "./gtx/transform2.hpp"
|
||||||
|
#include "./gtx/vec_swizzle.hpp"
|
||||||
|
#include "./gtx/vector_angle.hpp"
|
||||||
|
#include "./gtx/vector_query.hpp"
|
||||||
|
#include "./gtx/wrap.hpp"
|
||||||
|
|
||||||
|
#if GLM_HAS_TEMPLATE_ALIASES
|
||||||
|
# include "./gtx/scalar_multiplication.hpp"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if GLM_HAS_RANGE_FOR
|
||||||
|
# include "./gtx/range.hpp"
|
||||||
|
#endif
|
||||||
|
#endif//GLM_ENABLE_EXPERIMENTAL
|
||||||
522
vendor/include/glm/ext/matrix_clip_space.hpp
vendored
Normal file
522
vendor/include/glm/ext/matrix_clip_space.hpp
vendored
Normal file
|
|
@ -0,0 +1,522 @@
|
||||||
|
/// @ref ext_matrix_clip_space
|
||||||
|
/// @file glm/ext/matrix_clip_space.hpp
|
||||||
|
///
|
||||||
|
/// @defgroup ext_matrix_clip_space GLM_EXT_matrix_clip_space
|
||||||
|
/// @ingroup ext
|
||||||
|
///
|
||||||
|
/// Defines functions that generate clip space transformation matrices.
|
||||||
|
///
|
||||||
|
/// The matrices generated by this extension use standard OpenGL fixed-function
|
||||||
|
/// conventions. For example, the lookAt function generates a transform from world
|
||||||
|
/// space into the specific eye space that the projective matrix functions
|
||||||
|
/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
|
||||||
|
/// specifications defines the particular layout of this eye space.
|
||||||
|
///
|
||||||
|
/// Include <glm/ext/matrix_clip_space.hpp> to use the features of this extension.
|
||||||
|
///
|
||||||
|
/// @see ext_matrix_transform
|
||||||
|
/// @see ext_matrix_projection
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
// Dependencies
|
||||||
|
#include "../ext/scalar_constants.hpp"
|
||||||
|
#include "../geometric.hpp"
|
||||||
|
#include "../trigonometric.hpp"
|
||||||
|
|
||||||
|
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
|
||||||
|
# pragma message("GLM: GLM_EXT_matrix_clip_space extension included")
|
||||||
|
#endif
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
/// @addtogroup ext_matrix_clip_space
|
||||||
|
/// @{
|
||||||
|
|
||||||
|
/// Creates a matrix for projecting two-dimensional coordinates onto the screen.
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top, T const& zNear, T const& zFar)
|
||||||
|
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluOrtho2D.xml">gluOrtho2D man page</a>
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
|
||||||
|
T left, T right, T bottom, T top);
|
||||||
|
|
||||||
|
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_ZO(
|
||||||
|
T left, T right, T bottom, T top, T zNear, T zFar);
|
||||||
|
|
||||||
|
/// Creates a matrix for an orthographic parallel viewing volume using right-handed coordinates.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_NO(
|
||||||
|
T left, T right, T bottom, T top, T zNear, T zFar);
|
||||||
|
|
||||||
|
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_ZO(
|
||||||
|
T left, T right, T bottom, T top, T zNear, T zFar);
|
||||||
|
|
||||||
|
/// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_NO(
|
||||||
|
T left, T right, T bottom, T top, T zNear, T zFar);
|
||||||
|
|
||||||
|
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoZO(
|
||||||
|
T left, T right, T bottom, T top, T zNear, T zFar);
|
||||||
|
|
||||||
|
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoNO(
|
||||||
|
T left, T right, T bottom, T top, T zNear, T zFar);
|
||||||
|
|
||||||
|
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
|
||||||
|
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH(
|
||||||
|
T left, T right, T bottom, T top, T zNear, T zFar);
|
||||||
|
|
||||||
|
/// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
|
||||||
|
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH(
|
||||||
|
T left, T right, T bottom, T top, T zNear, T zFar);
|
||||||
|
|
||||||
|
/// Creates a matrix for an orthographic parallel viewing volume, using the default handedness and default near and far clip planes definition.
|
||||||
|
/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
///
|
||||||
|
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
|
||||||
|
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glOrtho.xml">glOrtho man page</a>
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
|
||||||
|
T left, T right, T bottom, T top, T zNear, T zFar);
|
||||||
|
|
||||||
|
/// Creates a left handed frustum matrix.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_ZO(
|
||||||
|
T left, T right, T bottom, T top, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a left handed frustum matrix.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_NO(
|
||||||
|
T left, T right, T bottom, T top, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a right handed frustum matrix.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_ZO(
|
||||||
|
T left, T right, T bottom, T top, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a right handed frustum matrix.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_NO(
|
||||||
|
T left, T right, T bottom, T top, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumZO(
|
||||||
|
T left, T right, T bottom, T top, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumNO(
|
||||||
|
T left, T right, T bottom, T top, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a left handed frustum matrix.
|
||||||
|
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH(
|
||||||
|
T left, T right, T bottom, T top, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a right handed frustum matrix.
|
||||||
|
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH(
|
||||||
|
T left, T right, T bottom, T top, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a frustum matrix with default handedness, using the default handedness and default near and far clip planes definition.
|
||||||
|
/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml">glFrustum man page</a>
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustum(
|
||||||
|
T left, T right, T bottom, T top, T near, T far);
|
||||||
|
|
||||||
|
|
||||||
|
/// Creates a matrix for a right handed, symetric perspective-view frustum.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_ZO(
|
||||||
|
T fovy, T aspect, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a matrix for a right handed, symetric perspective-view frustum.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_NO(
|
||||||
|
T fovy, T aspect, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a matrix for a left handed, symetric perspective-view frustum.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_ZO(
|
||||||
|
T fovy, T aspect, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a matrix for a left handed, symetric perspective-view frustum.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_NO(
|
||||||
|
T fovy, T aspect, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveZO(
|
||||||
|
T fovy, T aspect, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveNO(
|
||||||
|
T fovy, T aspect, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a matrix for a right handed, symetric perspective-view frustum.
|
||||||
|
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH(
|
||||||
|
T fovy, T aspect, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a matrix for a left handed, symetric perspective-view frustum.
|
||||||
|
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH(
|
||||||
|
T fovy, T aspect, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a matrix for a symetric perspective-view frustum based on the default handedness and default near and far clip planes definition.
|
||||||
|
/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml">gluPerspective man page</a>
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspective(
|
||||||
|
T fovy, T aspect, T near, T far);
|
||||||
|
|
||||||
|
/// Builds a perspective projection matrix based on a field of view using right-handed coordinates.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fov Expressed in radians.
|
||||||
|
/// @param width Width of the viewport
|
||||||
|
/// @param height Height of the viewport
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_ZO(
|
||||||
|
T fov, T width, T height, T near, T far);
|
||||||
|
|
||||||
|
/// Builds a perspective projection matrix based on a field of view using right-handed coordinates.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fov Expressed in radians.
|
||||||
|
/// @param width Width of the viewport
|
||||||
|
/// @param height Height of the viewport
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_NO(
|
||||||
|
T fov, T width, T height, T near, T far);
|
||||||
|
|
||||||
|
/// Builds a perspective projection matrix based on a field of view using left-handed coordinates.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fov Expressed in radians.
|
||||||
|
/// @param width Width of the viewport
|
||||||
|
/// @param height Height of the viewport
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_ZO(
|
||||||
|
T fov, T width, T height, T near, T far);
|
||||||
|
|
||||||
|
/// Builds a perspective projection matrix based on a field of view using left-handed coordinates.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fov Expressed in radians.
|
||||||
|
/// @param width Width of the viewport
|
||||||
|
/// @param height Height of the viewport
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_NO(
|
||||||
|
T fov, T width, T height, T near, T far);
|
||||||
|
|
||||||
|
/// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fov Expressed in radians.
|
||||||
|
/// @param width Width of the viewport
|
||||||
|
/// @param height Height of the viewport
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovZO(
|
||||||
|
T fov, T width, T height, T near, T far);
|
||||||
|
|
||||||
|
/// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
|
||||||
|
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fov Expressed in radians.
|
||||||
|
/// @param width Width of the viewport
|
||||||
|
/// @param height Height of the viewport
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovNO(
|
||||||
|
T fov, T width, T height, T near, T far);
|
||||||
|
|
||||||
|
/// Builds a right handed perspective projection matrix based on a field of view.
|
||||||
|
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fov Expressed in radians.
|
||||||
|
/// @param width Width of the viewport
|
||||||
|
/// @param height Height of the viewport
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH(
|
||||||
|
T fov, T width, T height, T near, T far);
|
||||||
|
|
||||||
|
/// Builds a left handed perspective projection matrix based on a field of view.
|
||||||
|
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
|
||||||
|
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
|
||||||
|
///
|
||||||
|
/// @param fov Expressed in radians.
|
||||||
|
/// @param width Width of the viewport
|
||||||
|
/// @param height Height of the viewport
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH(
|
||||||
|
T fov, T width, T height, T near, T far);
|
||||||
|
|
||||||
|
/// Builds a perspective projection matrix based on a field of view and the default handedness and default near and far clip planes definition.
|
||||||
|
/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
|
||||||
|
///
|
||||||
|
/// @param fov Expressed in radians.
|
||||||
|
/// @param width Width of the viewport
|
||||||
|
/// @param height Height of the viewport
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov(
|
||||||
|
T fov, T width, T height, T near, T far);
|
||||||
|
|
||||||
|
/// Creates a matrix for a left handed, symmetric perspective-view frustum with far plane at infinite.
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveLH(
|
||||||
|
T fovy, T aspect, T near);
|
||||||
|
|
||||||
|
/// Creates a matrix for a right handed, symmetric perspective-view frustum with far plane at infinite.
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH(
|
||||||
|
T fovy, T aspect, T near);
|
||||||
|
|
||||||
|
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite with default handedness.
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective(
|
||||||
|
T fovy, T aspect, T near);
|
||||||
|
|
||||||
|
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
|
||||||
|
T fovy, T aspect, T near);
|
||||||
|
|
||||||
|
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
|
||||||
|
///
|
||||||
|
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
|
||||||
|
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
|
||||||
|
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
|
||||||
|
/// @param ep Epsilon
|
||||||
|
///
|
||||||
|
/// @tparam T A floating-point scalar type
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
|
||||||
|
T fovy, T aspect, T near, T ep);
|
||||||
|
|
||||||
|
/// @}
|
||||||
|
}//namespace glm
|
||||||
|
|
||||||
|
#include "matrix_clip_space.inl"
|
||||||
555
vendor/include/glm/ext/matrix_clip_space.inl
vendored
Normal file
555
vendor/include/glm/ext/matrix_clip_space.inl
vendored
Normal file
|
|
@ -0,0 +1,555 @@
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top)
|
||||||
|
{
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(1));
|
||||||
|
Result[0][0] = static_cast<T>(2) / (right - left);
|
||||||
|
Result[1][1] = static_cast<T>(2) / (top - bottom);
|
||||||
|
Result[2][2] = - static_cast<T>(1);
|
||||||
|
Result[3][0] = - (right + left) / (right - left);
|
||||||
|
Result[3][1] = - (top + bottom) / (top - bottom);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_ZO(T left, T right, T bottom, T top, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
mat<4, 4, T, defaultp> Result(1);
|
||||||
|
Result[0][0] = static_cast<T>(2) / (right - left);
|
||||||
|
Result[1][1] = static_cast<T>(2) / (top - bottom);
|
||||||
|
Result[2][2] = static_cast<T>(1) / (zFar - zNear);
|
||||||
|
Result[3][0] = - (right + left) / (right - left);
|
||||||
|
Result[3][1] = - (top + bottom) / (top - bottom);
|
||||||
|
Result[3][2] = - zNear / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_NO(T left, T right, T bottom, T top, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
mat<4, 4, T, defaultp> Result(1);
|
||||||
|
Result[0][0] = static_cast<T>(2) / (right - left);
|
||||||
|
Result[1][1] = static_cast<T>(2) / (top - bottom);
|
||||||
|
Result[2][2] = static_cast<T>(2) / (zFar - zNear);
|
||||||
|
Result[3][0] = - (right + left) / (right - left);
|
||||||
|
Result[3][1] = - (top + bottom) / (top - bottom);
|
||||||
|
Result[3][2] = - (zFar + zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_ZO(T left, T right, T bottom, T top, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
mat<4, 4, T, defaultp> Result(1);
|
||||||
|
Result[0][0] = static_cast<T>(2) / (right - left);
|
||||||
|
Result[1][1] = static_cast<T>(2) / (top - bottom);
|
||||||
|
Result[2][2] = - static_cast<T>(1) / (zFar - zNear);
|
||||||
|
Result[3][0] = - (right + left) / (right - left);
|
||||||
|
Result[3][1] = - (top + bottom) / (top - bottom);
|
||||||
|
Result[3][2] = - zNear / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_NO(T left, T right, T bottom, T top, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
mat<4, 4, T, defaultp> Result(1);
|
||||||
|
Result[0][0] = static_cast<T>(2) / (right - left);
|
||||||
|
Result[1][1] = static_cast<T>(2) / (top - bottom);
|
||||||
|
Result[2][2] = - static_cast<T>(2) / (zFar - zNear);
|
||||||
|
Result[3][0] = - (right + left) / (right - left);
|
||||||
|
Result[3][1] = - (top + bottom) / (top - bottom);
|
||||||
|
Result[3][2] = - (zFar + zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoZO(T left, T right, T bottom, T top, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
|
||||||
|
return orthoLH_ZO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return orthoRH_ZO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoNO(T left, T right, T bottom, T top, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
|
||||||
|
return orthoLH_NO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return orthoRH_NO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH(T left, T right, T bottom, T top, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
|
||||||
|
return orthoLH_ZO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return orthoLH_NO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH(T left, T right, T bottom, T top, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
|
||||||
|
return orthoRH_ZO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return orthoRH_NO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO
|
||||||
|
return orthoLH_ZO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO
|
||||||
|
return orthoLH_NO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO
|
||||||
|
return orthoRH_ZO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO
|
||||||
|
return orthoRH_NO(left, right, bottom, top, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal)
|
||||||
|
{
|
||||||
|
mat<4, 4, T, defaultp> Result(0);
|
||||||
|
Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
|
||||||
|
Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
|
||||||
|
Result[2][0] = (right + left) / (right - left);
|
||||||
|
Result[2][1] = (top + bottom) / (top - bottom);
|
||||||
|
Result[2][2] = farVal / (farVal - nearVal);
|
||||||
|
Result[2][3] = static_cast<T>(1);
|
||||||
|
Result[3][2] = -(farVal * nearVal) / (farVal - nearVal);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_NO(T left, T right, T bottom, T top, T nearVal, T farVal)
|
||||||
|
{
|
||||||
|
mat<4, 4, T, defaultp> Result(0);
|
||||||
|
Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
|
||||||
|
Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
|
||||||
|
Result[2][0] = (right + left) / (right - left);
|
||||||
|
Result[2][1] = (top + bottom) / (top - bottom);
|
||||||
|
Result[2][2] = (farVal + nearVal) / (farVal - nearVal);
|
||||||
|
Result[2][3] = static_cast<T>(1);
|
||||||
|
Result[3][2] = - (static_cast<T>(2) * farVal * nearVal) / (farVal - nearVal);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal)
|
||||||
|
{
|
||||||
|
mat<4, 4, T, defaultp> Result(0);
|
||||||
|
Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
|
||||||
|
Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
|
||||||
|
Result[2][0] = (right + left) / (right - left);
|
||||||
|
Result[2][1] = (top + bottom) / (top - bottom);
|
||||||
|
Result[2][2] = farVal / (nearVal - farVal);
|
||||||
|
Result[2][3] = static_cast<T>(-1);
|
||||||
|
Result[3][2] = -(farVal * nearVal) / (farVal - nearVal);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_NO(T left, T right, T bottom, T top, T nearVal, T farVal)
|
||||||
|
{
|
||||||
|
mat<4, 4, T, defaultp> Result(0);
|
||||||
|
Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
|
||||||
|
Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
|
||||||
|
Result[2][0] = (right + left) / (right - left);
|
||||||
|
Result[2][1] = (top + bottom) / (top - bottom);
|
||||||
|
Result[2][2] = - (farVal + nearVal) / (farVal - nearVal);
|
||||||
|
Result[2][3] = static_cast<T>(-1);
|
||||||
|
Result[3][2] = - (static_cast<T>(2) * farVal * nearVal) / (farVal - nearVal);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumZO(T left, T right, T bottom, T top, T nearVal, T farVal)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
|
||||||
|
return frustumLH_ZO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# else
|
||||||
|
return frustumRH_ZO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumNO(T left, T right, T bottom, T top, T nearVal, T farVal)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
|
||||||
|
return frustumLH_NO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# else
|
||||||
|
return frustumRH_NO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH(T left, T right, T bottom, T top, T nearVal, T farVal)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
|
||||||
|
return frustumLH_ZO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# else
|
||||||
|
return frustumLH_NO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH(T left, T right, T bottom, T top, T nearVal, T farVal)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
|
||||||
|
return frustumRH_ZO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# else
|
||||||
|
return frustumRH_NO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustum(T left, T right, T bottom, T top, T nearVal, T farVal)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO
|
||||||
|
return frustumLH_ZO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO
|
||||||
|
return frustumLH_NO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO
|
||||||
|
return frustumRH_ZO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO
|
||||||
|
return frustumRH_NO(left, right, bottom, top, nearVal, farVal);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_ZO(T fovy, T aspect, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
|
||||||
|
|
||||||
|
T const tanHalfFovy = tan(fovy / static_cast<T>(2));
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
|
||||||
|
Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
|
||||||
|
Result[2][2] = zFar / (zNear - zFar);
|
||||||
|
Result[2][3] = - static_cast<T>(1);
|
||||||
|
Result[3][2] = -(zFar * zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_NO(T fovy, T aspect, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
|
||||||
|
|
||||||
|
T const tanHalfFovy = tan(fovy / static_cast<T>(2));
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
|
||||||
|
Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
|
||||||
|
Result[2][2] = - (zFar + zNear) / (zFar - zNear);
|
||||||
|
Result[2][3] = - static_cast<T>(1);
|
||||||
|
Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_ZO(T fovy, T aspect, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
|
||||||
|
|
||||||
|
T const tanHalfFovy = tan(fovy / static_cast<T>(2));
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
|
||||||
|
Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
|
||||||
|
Result[2][2] = zFar / (zFar - zNear);
|
||||||
|
Result[2][3] = static_cast<T>(1);
|
||||||
|
Result[3][2] = -(zFar * zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_NO(T fovy, T aspect, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
|
||||||
|
|
||||||
|
T const tanHalfFovy = tan(fovy / static_cast<T>(2));
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
|
||||||
|
Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
|
||||||
|
Result[2][2] = (zFar + zNear) / (zFar - zNear);
|
||||||
|
Result[2][3] = static_cast<T>(1);
|
||||||
|
Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveZO(T fovy, T aspect, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
|
||||||
|
return perspectiveLH_ZO(fovy, aspect, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return perspectiveRH_ZO(fovy, aspect, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveNO(T fovy, T aspect, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
|
||||||
|
return perspectiveLH_NO(fovy, aspect, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return perspectiveRH_NO(fovy, aspect, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH(T fovy, T aspect, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
|
||||||
|
return perspectiveLH_ZO(fovy, aspect, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return perspectiveLH_NO(fovy, aspect, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH(T fovy, T aspect, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
|
||||||
|
return perspectiveRH_ZO(fovy, aspect, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return perspectiveRH_NO(fovy, aspect, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspective(T fovy, T aspect, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO
|
||||||
|
return perspectiveLH_ZO(fovy, aspect, zNear, zFar);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO
|
||||||
|
return perspectiveLH_NO(fovy, aspect, zNear, zFar);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO
|
||||||
|
return perspectiveRH_ZO(fovy, aspect, zNear, zFar);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO
|
||||||
|
return perspectiveRH_NO(fovy, aspect, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_ZO(T fov, T width, T height, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
assert(width > static_cast<T>(0));
|
||||||
|
assert(height > static_cast<T>(0));
|
||||||
|
assert(fov > static_cast<T>(0));
|
||||||
|
|
||||||
|
T const rad = fov;
|
||||||
|
T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
|
||||||
|
T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = w;
|
||||||
|
Result[1][1] = h;
|
||||||
|
Result[2][2] = zFar / (zNear - zFar);
|
||||||
|
Result[2][3] = - static_cast<T>(1);
|
||||||
|
Result[3][2] = -(zFar * zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_NO(T fov, T width, T height, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
assert(width > static_cast<T>(0));
|
||||||
|
assert(height > static_cast<T>(0));
|
||||||
|
assert(fov > static_cast<T>(0));
|
||||||
|
|
||||||
|
T const rad = fov;
|
||||||
|
T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
|
||||||
|
T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = w;
|
||||||
|
Result[1][1] = h;
|
||||||
|
Result[2][2] = - (zFar + zNear) / (zFar - zNear);
|
||||||
|
Result[2][3] = - static_cast<T>(1);
|
||||||
|
Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_ZO(T fov, T width, T height, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
assert(width > static_cast<T>(0));
|
||||||
|
assert(height > static_cast<T>(0));
|
||||||
|
assert(fov > static_cast<T>(0));
|
||||||
|
|
||||||
|
T const rad = fov;
|
||||||
|
T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
|
||||||
|
T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = w;
|
||||||
|
Result[1][1] = h;
|
||||||
|
Result[2][2] = zFar / (zFar - zNear);
|
||||||
|
Result[2][3] = static_cast<T>(1);
|
||||||
|
Result[3][2] = -(zFar * zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_NO(T fov, T width, T height, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
assert(width > static_cast<T>(0));
|
||||||
|
assert(height > static_cast<T>(0));
|
||||||
|
assert(fov > static_cast<T>(0));
|
||||||
|
|
||||||
|
T const rad = fov;
|
||||||
|
T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
|
||||||
|
T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = w;
|
||||||
|
Result[1][1] = h;
|
||||||
|
Result[2][2] = (zFar + zNear) / (zFar - zNear);
|
||||||
|
Result[2][3] = static_cast<T>(1);
|
||||||
|
Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovZO(T fov, T width, T height, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
|
||||||
|
return perspectiveFovLH_ZO(fov, width, height, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return perspectiveFovRH_ZO(fov, width, height, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovNO(T fov, T width, T height, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
|
||||||
|
return perspectiveFovLH_NO(fov, width, height, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return perspectiveFovRH_NO(fov, width, height, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH(T fov, T width, T height, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
|
||||||
|
return perspectiveFovLH_ZO(fov, width, height, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return perspectiveFovLH_NO(fov, width, height, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH(T fov, T width, T height, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
|
||||||
|
return perspectiveFovRH_ZO(fov, width, height, zNear, zFar);
|
||||||
|
# else
|
||||||
|
return perspectiveFovRH_NO(fov, width, height, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFov(T fov, T width, T height, T zNear, T zFar)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO
|
||||||
|
return perspectiveFovLH_ZO(fov, width, height, zNear, zFar);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO
|
||||||
|
return perspectiveFovLH_NO(fov, width, height, zNear, zFar);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO
|
||||||
|
return perspectiveFovRH_ZO(fov, width, height, zNear, zFar);
|
||||||
|
# elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO
|
||||||
|
return perspectiveFovRH_NO(fov, width, height, zNear, zFar);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveRH(T fovy, T aspect, T zNear)
|
||||||
|
{
|
||||||
|
T const range = tan(fovy / static_cast<T>(2)) * zNear;
|
||||||
|
T const left = -range * aspect;
|
||||||
|
T const right = range * aspect;
|
||||||
|
T const bottom = -range;
|
||||||
|
T const top = range;
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
|
||||||
|
Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
|
||||||
|
Result[2][2] = - static_cast<T>(1);
|
||||||
|
Result[2][3] = - static_cast<T>(1);
|
||||||
|
Result[3][2] = - static_cast<T>(2) * zNear;
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveLH(T fovy, T aspect, T zNear)
|
||||||
|
{
|
||||||
|
T const range = tan(fovy / static_cast<T>(2)) * zNear;
|
||||||
|
T const left = -range * aspect;
|
||||||
|
T const right = range * aspect;
|
||||||
|
T const bottom = -range;
|
||||||
|
T const top = range;
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(T(0));
|
||||||
|
Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
|
||||||
|
Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
|
||||||
|
Result[2][2] = static_cast<T>(1);
|
||||||
|
Result[2][3] = static_cast<T>(1);
|
||||||
|
Result[3][2] = - static_cast<T>(2) * zNear;
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspective(T fovy, T aspect, T zNear)
|
||||||
|
{
|
||||||
|
# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
|
||||||
|
return infinitePerspectiveLH(fovy, aspect, zNear);
|
||||||
|
# else
|
||||||
|
return infinitePerspectiveRH(fovy, aspect, zNear);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
// Infinite projection matrix: http://www.terathon.com/gdc07_lengyel.pdf
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear, T ep)
|
||||||
|
{
|
||||||
|
T const range = tan(fovy / static_cast<T>(2)) * zNear;
|
||||||
|
T const left = -range * aspect;
|
||||||
|
T const right = range * aspect;
|
||||||
|
T const bottom = -range;
|
||||||
|
T const top = range;
|
||||||
|
|
||||||
|
mat<4, 4, T, defaultp> Result(static_cast<T>(0));
|
||||||
|
Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
|
||||||
|
Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
|
||||||
|
Result[2][2] = ep - static_cast<T>(1);
|
||||||
|
Result[2][3] = static_cast<T>(-1);
|
||||||
|
Result[3][2] = (ep - static_cast<T>(2)) * zNear;
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear)
|
||||||
|
{
|
||||||
|
return tweakedInfinitePerspective(fovy, aspect, zNear, epsilon<T>());
|
||||||
|
}
|
||||||
|
}//namespace glm
|
||||||
36
vendor/include/glm/ext/matrix_common.hpp
vendored
Normal file
36
vendor/include/glm/ext/matrix_common.hpp
vendored
Normal file
|
|
@ -0,0 +1,36 @@
|
||||||
|
/// @ref ext_matrix_common
|
||||||
|
/// @file glm/ext/matrix_common.hpp
|
||||||
|
///
|
||||||
|
/// @defgroup ext_matrix_common GLM_EXT_matrix_common
|
||||||
|
/// @ingroup ext
|
||||||
|
///
|
||||||
|
/// Defines functions for common matrix operations.
|
||||||
|
///
|
||||||
|
/// Include <glm/ext/matrix_common.hpp> to use the features of this extension.
|
||||||
|
///
|
||||||
|
/// @see ext_matrix_common
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "../detail/qualifier.hpp"
|
||||||
|
#include "../detail/_fixes.hpp"
|
||||||
|
|
||||||
|
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
|
||||||
|
# pragma message("GLM: GLM_EXT_matrix_transform extension included")
|
||||||
|
#endif
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
/// @addtogroup ext_matrix_common
|
||||||
|
/// @{
|
||||||
|
|
||||||
|
template<length_t C, length_t R, typename T, typename U, qualifier Q>
|
||||||
|
GLM_FUNC_DECL mat<C, R, T, Q> mix(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, mat<C, R, U, Q> const& a);
|
||||||
|
|
||||||
|
template<length_t C, length_t R, typename T, typename U, qualifier Q>
|
||||||
|
GLM_FUNC_DECL mat<C, R, T, Q> mix(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, U a);
|
||||||
|
|
||||||
|
/// @}
|
||||||
|
}//namespace glm
|
||||||
|
|
||||||
|
#include "matrix_common.inl"
|
||||||
16
vendor/include/glm/ext/matrix_common.inl
vendored
Normal file
16
vendor/include/glm/ext/matrix_common.inl
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
||||||
|
#include "../matrix.hpp"
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
template<length_t C, length_t R, typename T, typename U, qualifier Q>
|
||||||
|
GLM_FUNC_QUALIFIER mat<C, R, T, Q> mix(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, U a)
|
||||||
|
{
|
||||||
|
return mat<C, R, U, Q>(x) * (static_cast<U>(1) - a) + mat<C, R, U, Q>(y) * a;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<length_t C, length_t R, typename T, typename U, qualifier Q>
|
||||||
|
GLM_FUNC_QUALIFIER mat<C, R, T, Q> mix(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, mat<C, R, U, Q> const& a)
|
||||||
|
{
|
||||||
|
return matrixCompMult(mat<C, R, U, Q>(x), static_cast<U>(1) - a) + matrixCompMult(mat<C, R, U, Q>(y), a);
|
||||||
|
}
|
||||||
|
}//namespace glm
|
||||||
23
vendor/include/glm/ext/matrix_double2x2.hpp
vendored
Normal file
23
vendor/include/glm/ext/matrix_double2x2.hpp
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
||||||
|
/// @ref core
|
||||||
|
/// @file glm/ext/matrix_double2x2.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
#include "../detail/type_mat2x2.hpp"
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
/// @addtogroup core_matrix
|
||||||
|
/// @{
|
||||||
|
|
||||||
|
/// 2 columns of 2 components matrix of double-precision floating-point numbers.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
typedef mat<2, 2, double, defaultp> dmat2x2;
|
||||||
|
|
||||||
|
/// 2 columns of 2 components matrix of double-precision floating-point numbers.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
typedef mat<2, 2, double, defaultp> dmat2;
|
||||||
|
|
||||||
|
/// @}
|
||||||
|
}//namespace glm
|
||||||
49
vendor/include/glm/ext/matrix_double2x2_precision.hpp
vendored
Normal file
49
vendor/include/glm/ext/matrix_double2x2_precision.hpp
vendored
Normal file
|
|
@ -0,0 +1,49 @@
|
||||||
|
/// @ref core
|
||||||
|
/// @file glm/ext/matrix_double2x2_precision.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
#include "../detail/type_mat2x2.hpp"
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
/// @addtogroup core_matrix_precision
|
||||||
|
/// @{
|
||||||
|
|
||||||
|
/// 2 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 2, double, lowp> lowp_dmat2;
|
||||||
|
|
||||||
|
/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 2, double, mediump> mediump_dmat2;
|
||||||
|
|
||||||
|
/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 2, double, highp> highp_dmat2;
|
||||||
|
|
||||||
|
/// 2 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 2, double, lowp> lowp_dmat2x2;
|
||||||
|
|
||||||
|
/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 2, double, mediump> mediump_dmat2x2;
|
||||||
|
|
||||||
|
/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 2, double, highp> highp_dmat2x2;
|
||||||
|
|
||||||
|
/// @}
|
||||||
|
}//namespace glm
|
||||||
18
vendor/include/glm/ext/matrix_double2x3.hpp
vendored
Normal file
18
vendor/include/glm/ext/matrix_double2x3.hpp
vendored
Normal file
|
|
@ -0,0 +1,18 @@
|
||||||
|
/// @ref core
|
||||||
|
/// @file glm/ext/matrix_double2x3.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
#include "../detail/type_mat2x3.hpp"
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
/// @addtogroup core_matrix
|
||||||
|
/// @{
|
||||||
|
|
||||||
|
/// 2 columns of 3 components matrix of double-precision floating-point numbers.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
typedef mat<2, 3, double, defaultp> dmat2x3;
|
||||||
|
|
||||||
|
/// @}
|
||||||
|
}//namespace glm
|
||||||
31
vendor/include/glm/ext/matrix_double2x3_precision.hpp
vendored
Normal file
31
vendor/include/glm/ext/matrix_double2x3_precision.hpp
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
||||||
|
/// @ref core
|
||||||
|
/// @file glm/ext/matrix_double2x3_precision.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
#include "../detail/type_mat2x3.hpp"
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
/// @addtogroup core_matrix_precision
|
||||||
|
/// @{
|
||||||
|
|
||||||
|
/// 2 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 3, double, lowp> lowp_dmat2x3;
|
||||||
|
|
||||||
|
/// 2 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 3, double, mediump> mediump_dmat2x3;
|
||||||
|
|
||||||
|
/// 2 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 3, double, highp> highp_dmat2x3;
|
||||||
|
|
||||||
|
/// @}
|
||||||
|
}//namespace glm
|
||||||
18
vendor/include/glm/ext/matrix_double2x4.hpp
vendored
Normal file
18
vendor/include/glm/ext/matrix_double2x4.hpp
vendored
Normal file
|
|
@ -0,0 +1,18 @@
|
||||||
|
/// @ref core
|
||||||
|
/// @file glm/ext/matrix_double2x4.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
#include "../detail/type_mat2x4.hpp"
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
/// @addtogroup core_matrix
|
||||||
|
/// @{
|
||||||
|
|
||||||
|
/// 2 columns of 4 components matrix of double-precision floating-point numbers.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
typedef mat<2, 4, double, defaultp> dmat2x4;
|
||||||
|
|
||||||
|
/// @}
|
||||||
|
}//namespace glm
|
||||||
31
vendor/include/glm/ext/matrix_double2x4_precision.hpp
vendored
Normal file
31
vendor/include/glm/ext/matrix_double2x4_precision.hpp
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
||||||
|
/// @ref core
|
||||||
|
/// @file glm/ext/matrix_double2x4_precision.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
#include "../detail/type_mat2x4.hpp"
|
||||||
|
|
||||||
|
namespace glm
|
||||||
|
{
|
||||||
|
/// @addtogroup core_matrix_precision
|
||||||
|
/// @{
|
||||||
|
|
||||||
|
/// 2 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 4, double, lowp> lowp_dmat2x4;
|
||||||
|
|
||||||
|
/// 2 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 4, double, mediump> mediump_dmat2x4;
|
||||||
|
|
||||||
|
/// 2 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
|
||||||
|
///
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
|
||||||
|
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
|
||||||
|
typedef mat<2, 4, double, highp> highp_dmat2x4;
|
||||||
|
|
||||||
|
/// @}
|
||||||
|
}//namespace glm
|
||||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue