diff --git a/.gitattributes b/.gitattributes index 0e3382a1d1e7e40a5a9eae29cd57f0f682bc7f7e..babf6a8429e6dcd0e67efb82349a5b044b10560e 100644 --- a/.gitattributes +++ b/.gitattributes @@ -42,3 +42,4 @@ resources/applications.jpg filter=lfs diff=lfs merge=lfs -text resources/gif/demo-1.gif filter=lfs diff=lfs merge=lfs -text resources/gif/demo-2.gif filter=lfs diff=lfs merge=lfs -text resources/teaser.jpg filter=lfs diff=lfs merge=lfs -text +submodules/diff-gaussian-rasterization/third_party/glm/doc/manual.pdf filter=lfs diff=lfs merge=lfs -text diff --git a/pre-requirements.txt b/pre-requirements.txt index ade5d45ab366c2bf3df68d25ca64b15766950f41..7646c82705c2efcc5eeb1ae5e981fcbb53302bc9 100644 --- a/pre-requirements.txt +++ b/pre-requirements.txt @@ -5,4 +5,16 @@ torch==1.13.1 tqdm mediapipe Pillow -diffusers==0.18.2 \ No newline at end of file +diffusers==0.18.2 +transformers==4.30.2 +fire==0.5.0 +huggingface_hub==0.16.4 +imageio==2.31.1 +imageio-ffmpeg +PyYAML +safetensors +wandb +accelerate +triton +gradio +plyfile==0.8.1 \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index b6ff3ac672fb446c9da44e3a23f43c0c02af8c9f..4e6cc4327f4be0ac9c4186de683b25cbdf937cbd 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,16 +1,4 @@ xformers==0.0.16 -transformers==4.30.2 -fire==0.5.0 -huggingface_hub==0.16.4 -imageio==2.31.1 -imageio-ffmpeg -PyYAML -safetensors -wandb -accelerate -triton -gradio -plyfile==0.8.1 git+https://github.com/openai/point-e.git -git+https://github.com/YixunLiang/simple-knn.git -git+https://github.com/YixunLiang/diff-gaussian-rasterization.git \ No newline at end of file +submodules/simple-knn +submodules/diff-gaussian-rasterization \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/CMakeLists.txt b/submodules/diff-gaussian-rasterization/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..9fdb9cbfdcc0fc2b81595cd616912067291ea0b1 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/CMakeLists.txt @@ -0,0 +1,36 @@ +# +# Copyright (C) 2023, Inria +# GRAPHDECO research group, https://team.inria.fr/graphdeco +# All rights reserved. +# +# This software is free for non-commercial, research and evaluation use +# under the terms of the LICENSE.md file. +# +# For inquiries contact george.drettakis@inria.fr +# + +cmake_minimum_required(VERSION 3.20) + +project(DiffRast LANGUAGES CUDA CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_EXTENSIONS OFF) +set(CMAKE_CUDA_STANDARD 17) + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + +add_library(CudaRasterizer + cuda_rasterizer/backward.h + cuda_rasterizer/backward.cu + cuda_rasterizer/forward.h + cuda_rasterizer/forward.cu + cuda_rasterizer/auxiliary.h + cuda_rasterizer/rasterizer_impl.cu + cuda_rasterizer/rasterizer_impl.h + cuda_rasterizer/rasterizer.h +) + +set_target_properties(CudaRasterizer PROPERTIES CUDA_ARCHITECTURES "75;86") + +target_include_directories(CudaRasterizer PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/cuda_rasterizer) +target_include_directories(CudaRasterizer PRIVATE third_party/glm ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}) diff --git a/submodules/diff-gaussian-rasterization/LICENSE.md b/submodules/diff-gaussian-rasterization/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..c869e695fa63bfde6f887d63a24a2a71f03480ac --- /dev/null +++ b/submodules/diff-gaussian-rasterization/LICENSE.md @@ -0,0 +1,83 @@ +Gaussian-Splatting License +=========================== + +**Inria** and **the Max Planck Institut for Informatik (MPII)** hold all the ownership rights on the *Software* named **gaussian-splatting**. +The *Software* is in the process of being registered with the Agence pour la Protection des +Programmes (APP). + +The *Software* is still being developed by the *Licensor*. + +*Licensor*'s goal is to allow the research community to use, test and evaluate +the *Software*. + +## 1. Definitions + +*Licensee* means any person or entity that uses the *Software* and distributes +its *Work*. + +*Licensor* means the owners of the *Software*, i.e Inria and MPII + +*Software* means the original work of authorship made available under this +License ie gaussian-splatting. + +*Work* means the *Software* and any additions to or derivative works of the +*Software* that are made available under this License. + + +## 2. Purpose +This license is intended to define the rights granted to the *Licensee* by +Licensors under the *Software*. + +## 3. Rights granted + +For the above reasons Licensors have decided to distribute the *Software*. +Licensors grant non-exclusive rights to use the *Software* for research purposes +to research users (both academic and industrial), free of charge, without right +to sublicense.. The *Software* may be used "non-commercially", i.e., for research +and/or evaluation purposes only. + +Subject to the terms and conditions of this License, you are granted a +non-exclusive, royalty-free, license to reproduce, prepare derivative works of, +publicly display, publicly perform and distribute its *Work* and any resulting +derivative works in any form. + +## 4. Limitations + +**4.1 Redistribution.** You may reproduce or distribute the *Work* only if (a) you do +so under this License, (b) you include a complete copy of this License with +your distribution, and (c) you retain without modification any copyright, +patent, trademark, or attribution notices that are present in the *Work*. + +**4.2 Derivative Works.** You may specify that additional or different terms apply +to the use, reproduction, and distribution of your derivative works of the *Work* +("Your Terms") only if (a) Your Terms provide that the use limitation in +Section 2 applies to your derivative works, and (b) you identify the specific +derivative works that are subject to Your Terms. Notwithstanding Your Terms, +this License (including the redistribution requirements in Section 3.1) will +continue to apply to the *Work* itself. + +**4.3** Any other use without of prior consent of Licensors is prohibited. Research +users explicitly acknowledge having received from Licensors all information +allowing to appreciate the adequacy between of the *Software* and their needs and +to undertake all necessary precautions for its execution and use. + +**4.4** The *Software* is provided both as a compiled library file and as source +code. In case of using the *Software* for a publication or other results obtained +through the use of the *Software*, users are strongly encouraged to cite the +corresponding publications as explained in the documentation of the *Software*. + +## 5. Disclaimer + +THE USER CANNOT USE, EXPLOIT OR DISTRIBUTE THE *SOFTWARE* FOR COMMERCIAL PURPOSES +WITHOUT PRIOR AND EXPLICIT CONSENT OF LICENSORS. YOU MUST CONTACT INRIA FOR ANY +UNAUTHORIZED USE: stip-sophia.transfert@inria.fr . ANY SUCH ACTION WILL +CONSTITUTE A FORGERY. THIS *SOFTWARE* IS PROVIDED "AS IS" WITHOUT ANY WARRANTIES +OF ANY NATURE AND ANY EXPRESS OR IMPLIED WARRANTIES, WITH REGARDS TO COMMERCIAL +USE, PROFESSIONNAL USE, LEGAL OR NOT, OR OTHER, OR COMMERCIALISATION OR +ADAPTATION. UNLESS EXPLICITLY PROVIDED BY LAW, IN NO EVENT, SHALL INRIA OR THE +AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE +GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING FROM, OUT OF OR +IN CONNECTION WITH THE *SOFTWARE* OR THE USE OR OTHER DEALINGS IN THE *SOFTWARE*. diff --git a/submodules/diff-gaussian-rasterization/README.md b/submodules/diff-gaussian-rasterization/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6e165b0bb683a987485e2730216d5fa2919288ef --- /dev/null +++ b/submodules/diff-gaussian-rasterization/README.md @@ -0,0 +1,19 @@ +# Differential Gaussian Rasterization + +Used as the rasterization engine for the paper "3D Gaussian Splatting for Real-Time Rendering of Radiance Fields". If you can make use of it in your own research, please be so kind to cite us. + +
+
+

BibTeX

+
@Article{kerbl3Dgaussians,
+      author       = {Kerbl, Bernhard and Kopanas, Georgios and Leimk{\"u}hler, Thomas and Drettakis, George},
+      title        = {3D Gaussian Splatting for Real-Time Radiance Field Rendering},
+      journal      = {ACM Transactions on Graphics},
+      number       = {4},
+      volume       = {42},
+      month        = {July},
+      year         = {2023},
+      url          = {https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/}
+}
+
+
\ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/cuda_rasterizer/auxiliary.h b/submodules/diff-gaussian-rasterization/cuda_rasterizer/auxiliary.h new file mode 100644 index 0000000000000000000000000000000000000000..c7719a15a15b67b23feceadf58a69651096ea113 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/cuda_rasterizer/auxiliary.h @@ -0,0 +1,166 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#ifndef CUDA_RASTERIZER_AUXILIARY_H_INCLUDED +#define CUDA_RASTERIZER_AUXILIARY_H_INCLUDED + +#include "config.h" +#include "stdio.h" + +#define BLOCK_SIZE (BLOCK_X * BLOCK_Y) +#define NUM_WARPS (BLOCK_SIZE/32) + +// Spherical harmonics coefficients +__device__ const float SH_C0 = 0.28209479177387814f; +__device__ const float SH_C1 = 0.4886025119029199f; +__device__ const float SH_C2[] = { + 1.0925484305920792f, + -1.0925484305920792f, + 0.31539156525252005f, + -1.0925484305920792f, + 0.5462742152960396f +}; +__device__ const float SH_C3[] = { + -0.5900435899266435f, + 2.890611442640554f, + -0.4570457994644658f, + 0.3731763325901154f, + -0.4570457994644658f, + 1.445305721320277f, + -0.5900435899266435f +}; + +__forceinline__ __device__ float ndc2Pix(float v, int S) +{ + return ((v + 1.0) * S - 1.0) * 0.5; +} + +__forceinline__ __device__ void getRect(const float2 p, int max_radius, uint2& rect_min, uint2& rect_max, dim3 grid) +{ + rect_min = { + min(grid.x, max((int)0, (int)((p.x - max_radius) / BLOCK_X))), + min(grid.y, max((int)0, (int)((p.y - max_radius) / BLOCK_Y))) + }; + rect_max = { + min(grid.x, max((int)0, (int)((p.x + max_radius + BLOCK_X - 1) / BLOCK_X))), + min(grid.y, max((int)0, (int)((p.y + max_radius + BLOCK_Y - 1) / BLOCK_Y))) + }; +} + +__forceinline__ __device__ float3 transformPoint4x3(const float3& p, const float* matrix) +{ + float3 transformed = { + matrix[0] * p.x + matrix[4] * p.y + matrix[8] * p.z + matrix[12], + matrix[1] * p.x + matrix[5] * p.y + matrix[9] * p.z + matrix[13], + matrix[2] * p.x + matrix[6] * p.y + matrix[10] * p.z + matrix[14], + }; + return transformed; +} + +__forceinline__ __device__ float4 transformPoint4x4(const float3& p, const float* matrix) +{ + float4 transformed = { + matrix[0] * p.x + matrix[4] * p.y + matrix[8] * p.z + matrix[12], + matrix[1] * p.x + matrix[5] * p.y + matrix[9] * p.z + matrix[13], + matrix[2] * p.x + matrix[6] * p.y + matrix[10] * p.z + matrix[14], + matrix[3] * p.x + matrix[7] * p.y + matrix[11] * p.z + matrix[15] + }; + return transformed; +} + +__forceinline__ __device__ float3 transformVec4x3(const float3& p, const float* matrix) +{ + float3 transformed = { + matrix[0] * p.x + matrix[4] * p.y + matrix[8] * p.z, + matrix[1] * p.x + matrix[5] * p.y + matrix[9] * p.z, + matrix[2] * p.x + matrix[6] * p.y + matrix[10] * p.z, + }; + return transformed; +} + +__forceinline__ __device__ float3 transformVec4x3Transpose(const float3& p, const float* matrix) +{ + float3 transformed = { + matrix[0] * p.x + matrix[1] * p.y + matrix[2] * p.z, + matrix[4] * p.x + matrix[5] * p.y + matrix[6] * p.z, + matrix[8] * p.x + matrix[9] * p.y + matrix[10] * p.z, + }; + return transformed; +} + +__forceinline__ __device__ float dnormvdz(float3 v, float3 dv) +{ + float sum2 = v.x * v.x + v.y * v.y + v.z * v.z; + float invsum32 = 1.0f / sqrt(sum2 * sum2 * sum2); + float dnormvdz = (-v.x * v.z * dv.x - v.y * v.z * dv.y + (sum2 - v.z * v.z) * dv.z) * invsum32; + return dnormvdz; +} + +__forceinline__ __device__ float3 dnormvdv(float3 v, float3 dv) +{ + float sum2 = v.x * v.x + v.y * v.y + v.z * v.z; + float invsum32 = 1.0f / sqrt(sum2 * sum2 * sum2); + + float3 dnormvdv; + dnormvdv.x = ((+sum2 - v.x * v.x) * dv.x - v.y * v.x * dv.y - v.z * v.x * dv.z) * invsum32; + dnormvdv.y = (-v.x * v.y * dv.x + (sum2 - v.y * v.y) * dv.y - v.z * v.y * dv.z) * invsum32; + dnormvdv.z = (-v.x * v.z * dv.x - v.y * v.z * dv.y + (sum2 - v.z * v.z) * dv.z) * invsum32; + return dnormvdv; +} + +__forceinline__ __device__ float4 dnormvdv(float4 v, float4 dv) +{ + float sum2 = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w; + float invsum32 = 1.0f / sqrt(sum2 * sum2 * sum2); + + float4 vdv = { v.x * dv.x, v.y * dv.y, v.z * dv.z, v.w * dv.w }; + float vdv_sum = vdv.x + vdv.y + vdv.z + vdv.w; + float4 dnormvdv; + dnormvdv.x = ((sum2 - v.x * v.x) * dv.x - v.x * (vdv_sum - vdv.x)) * invsum32; + dnormvdv.y = ((sum2 - v.y * v.y) * dv.y - v.y * (vdv_sum - vdv.y)) * invsum32; + dnormvdv.z = ((sum2 - v.z * v.z) * dv.z - v.z * (vdv_sum - vdv.z)) * invsum32; + dnormvdv.w = ((sum2 - v.w * v.w) * dv.w - v.w * (vdv_sum - vdv.w)) * invsum32; + return dnormvdv; +} + +__forceinline__ __device__ float sigmoid(float x) +{ + return 1.0f / (1.0f + expf(-x)); +} + +__forceinline__ __device__ bool in_frustum(int idx, + const float* orig_points, + const float* viewmatrix, + const float* projmatrix, + bool prefiltered, + float3& p_view) +{ + float3 p_orig = { orig_points[3 * idx], orig_points[3 * idx + 1], orig_points[3 * idx + 2] }; + + // Bring points to screen space + float4 p_hom = transformPoint4x4(p_orig, projmatrix); + float p_w = 1.0f / (p_hom.w + 0.0000001f); + float3 p_proj = { p_hom.x * p_w, p_hom.y * p_w, p_hom.z * p_w }; + p_view = transformPoint4x3(p_orig, viewmatrix); + + if (p_view.z <= 0.2f)// || ((p_proj.x < -1.3 || p_proj.x > 1.3 || p_proj.y < -1.3 || p_proj.y > 1.3))) + { + if (prefiltered) + { + printf("Point is filtered although prefiltered is set. This shouldn't happen!"); + __trap(); + } + return false; + } + return true; +} + +#endif \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.cu b/submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.cu new file mode 100644 index 0000000000000000000000000000000000000000..fc937af89d9d55ee09662a8eeeb06b8560b6554b --- /dev/null +++ b/submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.cu @@ -0,0 +1,707 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#include "backward.h" +#include "auxiliary.h" +#include +#include +namespace cg = cooperative_groups; + +// Backward pass for conversion of spherical harmonics to RGB for +// each Gaussian. +__device__ void computeColorFromSH(int idx, int deg, int max_coeffs, const glm::vec3* means, glm::vec3 campos, const float* shs, const bool* clamped, const glm::vec3* dL_dcolor, glm::vec3* dL_dmeans, glm::vec3* dL_dshs) +{ + // Compute intermediate values, as it is done during forward + glm::vec3 pos = means[idx]; + glm::vec3 dir_orig = pos - campos; + glm::vec3 dir = dir_orig / glm::length(dir_orig); + + glm::vec3* sh = ((glm::vec3*)shs) + idx * max_coeffs; + + // Use PyTorch rule for clamping: if clamping was applied, + // gradient becomes 0. + glm::vec3 dL_dRGB = dL_dcolor[idx]; + dL_dRGB.x *= clamped[3 * idx + 0] ? 0 : 1; + dL_dRGB.y *= clamped[3 * idx + 1] ? 0 : 1; + dL_dRGB.z *= clamped[3 * idx + 2] ? 0 : 1; + + glm::vec3 dRGBdx(0, 0, 0); + glm::vec3 dRGBdy(0, 0, 0); + glm::vec3 dRGBdz(0, 0, 0); + float x = dir.x; + float y = dir.y; + float z = dir.z; + + // Target location for this Gaussian to write SH gradients to + glm::vec3* dL_dsh = dL_dshs + idx * max_coeffs; + + // No tricks here, just high school-level calculus. + float dRGBdsh0 = SH_C0; + dL_dsh[0] = dRGBdsh0 * dL_dRGB; + if (deg > 0) + { + float dRGBdsh1 = -SH_C1 * y; + float dRGBdsh2 = SH_C1 * z; + float dRGBdsh3 = -SH_C1 * x; + dL_dsh[1] = dRGBdsh1 * dL_dRGB; + dL_dsh[2] = dRGBdsh2 * dL_dRGB; + dL_dsh[3] = dRGBdsh3 * dL_dRGB; + + dRGBdx = -SH_C1 * sh[3]; + dRGBdy = -SH_C1 * sh[1]; + dRGBdz = SH_C1 * sh[2]; + + if (deg > 1) + { + float xx = x * x, yy = y * y, zz = z * z; + float xy = x * y, yz = y * z, xz = x * z; + + float dRGBdsh4 = SH_C2[0] * xy; + float dRGBdsh5 = SH_C2[1] * yz; + float dRGBdsh6 = SH_C2[2] * (2.f * zz - xx - yy); + float dRGBdsh7 = SH_C2[3] * xz; + float dRGBdsh8 = SH_C2[4] * (xx - yy); + dL_dsh[4] = dRGBdsh4 * dL_dRGB; + dL_dsh[5] = dRGBdsh5 * dL_dRGB; + dL_dsh[6] = dRGBdsh6 * dL_dRGB; + dL_dsh[7] = dRGBdsh7 * dL_dRGB; + dL_dsh[8] = dRGBdsh8 * dL_dRGB; + + dRGBdx += SH_C2[0] * y * sh[4] + SH_C2[2] * 2.f * -x * sh[6] + SH_C2[3] * z * sh[7] + SH_C2[4] * 2.f * x * sh[8]; + dRGBdy += SH_C2[0] * x * sh[4] + SH_C2[1] * z * sh[5] + SH_C2[2] * 2.f * -y * sh[6] + SH_C2[4] * 2.f * -y * sh[8]; + dRGBdz += SH_C2[1] * y * sh[5] + SH_C2[2] * 2.f * 2.f * z * sh[6] + SH_C2[3] * x * sh[7]; + + if (deg > 2) + { + float dRGBdsh9 = SH_C3[0] * y * (3.f * xx - yy); + float dRGBdsh10 = SH_C3[1] * xy * z; + float dRGBdsh11 = SH_C3[2] * y * (4.f * zz - xx - yy); + float dRGBdsh12 = SH_C3[3] * z * (2.f * zz - 3.f * xx - 3.f * yy); + float dRGBdsh13 = SH_C3[4] * x * (4.f * zz - xx - yy); + float dRGBdsh14 = SH_C3[5] * z * (xx - yy); + float dRGBdsh15 = SH_C3[6] * x * (xx - 3.f * yy); + dL_dsh[9] = dRGBdsh9 * dL_dRGB; + dL_dsh[10] = dRGBdsh10 * dL_dRGB; + dL_dsh[11] = dRGBdsh11 * dL_dRGB; + dL_dsh[12] = dRGBdsh12 * dL_dRGB; + dL_dsh[13] = dRGBdsh13 * dL_dRGB; + dL_dsh[14] = dRGBdsh14 * dL_dRGB; + dL_dsh[15] = dRGBdsh15 * dL_dRGB; + + dRGBdx += ( + SH_C3[0] * sh[9] * 3.f * 2.f * xy + + SH_C3[1] * sh[10] * yz + + SH_C3[2] * sh[11] * -2.f * xy + + SH_C3[3] * sh[12] * -3.f * 2.f * xz + + SH_C3[4] * sh[13] * (-3.f * xx + 4.f * zz - yy) + + SH_C3[5] * sh[14] * 2.f * xz + + SH_C3[6] * sh[15] * 3.f * (xx - yy)); + + dRGBdy += ( + SH_C3[0] * sh[9] * 3.f * (xx - yy) + + SH_C3[1] * sh[10] * xz + + SH_C3[2] * sh[11] * (-3.f * yy + 4.f * zz - xx) + + SH_C3[3] * sh[12] * -3.f * 2.f * yz + + SH_C3[4] * sh[13] * -2.f * xy + + SH_C3[5] * sh[14] * -2.f * yz + + SH_C3[6] * sh[15] * -3.f * 2.f * xy); + + dRGBdz += ( + SH_C3[1] * sh[10] * xy + + SH_C3[2] * sh[11] * 4.f * 2.f * yz + + SH_C3[3] * sh[12] * 3.f * (2.f * zz - xx - yy) + + SH_C3[4] * sh[13] * 4.f * 2.f * xz + + SH_C3[5] * sh[14] * (xx - yy)); + } + } + } + + // The view direction is an input to the computation. View direction + // is influenced by the Gaussian's mean, so SHs gradients + // must propagate back into 3D position. + glm::vec3 dL_ddir(glm::dot(dRGBdx, dL_dRGB), glm::dot(dRGBdy, dL_dRGB), glm::dot(dRGBdz, dL_dRGB)); + + // Account for normalization of direction + float3 dL_dmean = dnormvdv(float3{ dir_orig.x, dir_orig.y, dir_orig.z }, float3{ dL_ddir.x, dL_ddir.y, dL_ddir.z }); + + // Gradients of loss w.r.t. Gaussian means, but only the portion + // that is caused because the mean affects the view-dependent color. + // Additional mean gradient is accumulated in below methods. + dL_dmeans[idx] += glm::vec3(dL_dmean.x, dL_dmean.y, dL_dmean.z); +} + +// Backward version of INVERSE 2D covariance matrix computation +// (due to length launched as separate kernel before other +// backward steps contained in preprocess) +__global__ void computeCov2DCUDA(int P, + const float3* means, + const int* radii, + const float* cov3Ds, + const float h_x, float h_y, + const float tan_fovx, float tan_fovy, + const float* view_matrix, + const float* dL_dconics, + float3* dL_dmeans, + float* dL_dcov) +{ + auto idx = cg::this_grid().thread_rank(); + if (idx >= P || !(radii[idx] > 0)) + return; + + // Reading location of 3D covariance for this Gaussian + const float* cov3D = cov3Ds + 6 * idx; + + // Fetch gradients, recompute 2D covariance and relevant + // intermediate forward results needed in the backward. + float3 mean = means[idx]; + float3 dL_dconic = { dL_dconics[4 * idx], dL_dconics[4 * idx + 1], dL_dconics[4 * idx + 3] }; + float3 t = transformPoint4x3(mean, view_matrix); + + const float limx = 1.3f * tan_fovx; + const float limy = 1.3f * tan_fovy; + const float txtz = t.x / t.z; + const float tytz = t.y / t.z; + t.x = min(limx, max(-limx, txtz)) * t.z; + t.y = min(limy, max(-limy, tytz)) * t.z; + + const float x_grad_mul = txtz < -limx || txtz > limx ? 0 : 1; + const float y_grad_mul = tytz < -limy || tytz > limy ? 0 : 1; + + glm::mat3 J = glm::mat3(h_x / t.z, 0.0f, -(h_x * t.x) / (t.z * t.z), + 0.0f, h_y / t.z, -(h_y * t.y) / (t.z * t.z), + 0, 0, 0); + + glm::mat3 W = glm::mat3( + view_matrix[0], view_matrix[4], view_matrix[8], + view_matrix[1], view_matrix[5], view_matrix[9], + view_matrix[2], view_matrix[6], view_matrix[10]); + + glm::mat3 Vrk = glm::mat3( + cov3D[0], cov3D[1], cov3D[2], + cov3D[1], cov3D[3], cov3D[4], + cov3D[2], cov3D[4], cov3D[5]); + + glm::mat3 T = W * J; + + glm::mat3 cov2D = glm::transpose(T) * glm::transpose(Vrk) * T; + + // Use helper variables for 2D covariance entries. More compact. + float a = cov2D[0][0] += 0.3f; + float b = cov2D[0][1]; + float c = cov2D[1][1] += 0.3f; + + float denom = a * c - b * b; + float dL_da = 0, dL_db = 0, dL_dc = 0; + float denom2inv = 1.0f / ((denom * denom) + 0.0000001f); + + if (denom2inv != 0) + { + // Gradients of loss w.r.t. entries of 2D covariance matrix, + // given gradients of loss w.r.t. conic matrix (inverse covariance matrix). + // e.g., dL / da = dL / d_conic_a * d_conic_a / d_a + dL_da = denom2inv * (-c * c * dL_dconic.x + 2 * b * c * dL_dconic.y + (denom - a * c) * dL_dconic.z); + dL_dc = denom2inv * (-a * a * dL_dconic.z + 2 * a * b * dL_dconic.y + (denom - a * c) * dL_dconic.x); + dL_db = denom2inv * 2 * (b * c * dL_dconic.x - (denom + 2 * b * b) * dL_dconic.y + a * b * dL_dconic.z); + + // Gradients of loss L w.r.t. each 3D covariance matrix (Vrk) entry, + // given gradients w.r.t. 2D covariance matrix (diagonal). + // cov2D = transpose(T) * transpose(Vrk) * T; + dL_dcov[6 * idx + 0] = (T[0][0] * T[0][0] * dL_da + T[0][0] * T[1][0] * dL_db + T[1][0] * T[1][0] * dL_dc); + dL_dcov[6 * idx + 3] = (T[0][1] * T[0][1] * dL_da + T[0][1] * T[1][1] * dL_db + T[1][1] * T[1][1] * dL_dc); + dL_dcov[6 * idx + 5] = (T[0][2] * T[0][2] * dL_da + T[0][2] * T[1][2] * dL_db + T[1][2] * T[1][2] * dL_dc); + + // Gradients of loss L w.r.t. each 3D covariance matrix (Vrk) entry, + // given gradients w.r.t. 2D covariance matrix (off-diagonal). + // Off-diagonal elements appear twice --> double the gradient. + // cov2D = transpose(T) * transpose(Vrk) * T; + dL_dcov[6 * idx + 1] = 2 * T[0][0] * T[0][1] * dL_da + (T[0][0] * T[1][1] + T[0][1] * T[1][0]) * dL_db + 2 * T[1][0] * T[1][1] * dL_dc; + dL_dcov[6 * idx + 2] = 2 * T[0][0] * T[0][2] * dL_da + (T[0][0] * T[1][2] + T[0][2] * T[1][0]) * dL_db + 2 * T[1][0] * T[1][2] * dL_dc; + dL_dcov[6 * idx + 4] = 2 * T[0][2] * T[0][1] * dL_da + (T[0][1] * T[1][2] + T[0][2] * T[1][1]) * dL_db + 2 * T[1][1] * T[1][2] * dL_dc; + } + else + { + for (int i = 0; i < 6; i++) + dL_dcov[6 * idx + i] = 0; + } + + // Gradients of loss w.r.t. upper 2x3 portion of intermediate matrix T + // cov2D = transpose(T) * transpose(Vrk) * T; + float dL_dT00 = 2 * (T[0][0] * Vrk[0][0] + T[0][1] * Vrk[0][1] + T[0][2] * Vrk[0][2]) * dL_da + + (T[1][0] * Vrk[0][0] + T[1][1] * Vrk[0][1] + T[1][2] * Vrk[0][2]) * dL_db; + float dL_dT01 = 2 * (T[0][0] * Vrk[1][0] + T[0][1] * Vrk[1][1] + T[0][2] * Vrk[1][2]) * dL_da + + (T[1][0] * Vrk[1][0] + T[1][1] * Vrk[1][1] + T[1][2] * Vrk[1][2]) * dL_db; + float dL_dT02 = 2 * (T[0][0] * Vrk[2][0] + T[0][1] * Vrk[2][1] + T[0][2] * Vrk[2][2]) * dL_da + + (T[1][0] * Vrk[2][0] + T[1][1] * Vrk[2][1] + T[1][2] * Vrk[2][2]) * dL_db; + float dL_dT10 = 2 * (T[1][0] * Vrk[0][0] + T[1][1] * Vrk[0][1] + T[1][2] * Vrk[0][2]) * dL_dc + + (T[0][0] * Vrk[0][0] + T[0][1] * Vrk[0][1] + T[0][2] * Vrk[0][2]) * dL_db; + float dL_dT11 = 2 * (T[1][0] * Vrk[1][0] + T[1][1] * Vrk[1][1] + T[1][2] * Vrk[1][2]) * dL_dc + + (T[0][0] * Vrk[1][0] + T[0][1] * Vrk[1][1] + T[0][2] * Vrk[1][2]) * dL_db; + float dL_dT12 = 2 * (T[1][0] * Vrk[2][0] + T[1][1] * Vrk[2][1] + T[1][2] * Vrk[2][2]) * dL_dc + + (T[0][0] * Vrk[2][0] + T[0][1] * Vrk[2][1] + T[0][2] * Vrk[2][2]) * dL_db; + + // Gradients of loss w.r.t. upper 3x2 non-zero entries of Jacobian matrix + // T = W * J + float dL_dJ00 = W[0][0] * dL_dT00 + W[0][1] * dL_dT01 + W[0][2] * dL_dT02; + float dL_dJ02 = W[2][0] * dL_dT00 + W[2][1] * dL_dT01 + W[2][2] * dL_dT02; + float dL_dJ11 = W[1][0] * dL_dT10 + W[1][1] * dL_dT11 + W[1][2] * dL_dT12; + float dL_dJ12 = W[2][0] * dL_dT10 + W[2][1] * dL_dT11 + W[2][2] * dL_dT12; + + float tz = 1.f / t.z; + float tz2 = tz * tz; + float tz3 = tz2 * tz; + + // Gradients of loss w.r.t. transformed Gaussian mean t + float dL_dtx = x_grad_mul * -h_x * tz2 * dL_dJ02; + float dL_dty = y_grad_mul * -h_y * tz2 * dL_dJ12; + float dL_dtz = -h_x * tz2 * dL_dJ00 - h_y * tz2 * dL_dJ11 + (2 * h_x * t.x) * tz3 * dL_dJ02 + (2 * h_y * t.y) * tz3 * dL_dJ12; + + // Account for transformation of mean to t + // t = transformPoint4x3(mean, view_matrix); + float3 dL_dmean = transformVec4x3Transpose({ dL_dtx, dL_dty, dL_dtz }, view_matrix); + + // Gradients of loss w.r.t. Gaussian means, but only the portion + // that is caused because the mean affects the covariance matrix. + // Additional mean gradient is accumulated in BACKWARD::preprocess. + dL_dmeans[idx] = dL_dmean; +} + +// Backward pass for the conversion of scale and rotation to a +// 3D covariance matrix for each Gaussian. +__device__ void computeCov3D(int idx, const glm::vec3 scale, float mod, const glm::vec4 rot, const float* dL_dcov3Ds, glm::vec3* dL_dscales, glm::vec4* dL_drots) +{ + // Recompute (intermediate) results for the 3D covariance computation. + glm::vec4 q = rot;// / glm::length(rot); + float r = q.x; + float x = q.y; + float y = q.z; + float z = q.w; + + glm::mat3 R = glm::mat3( + 1.f - 2.f * (y * y + z * z), 2.f * (x * y - r * z), 2.f * (x * z + r * y), + 2.f * (x * y + r * z), 1.f - 2.f * (x * x + z * z), 2.f * (y * z - r * x), + 2.f * (x * z - r * y), 2.f * (y * z + r * x), 1.f - 2.f * (x * x + y * y) + ); + + glm::mat3 S = glm::mat3(1.0f); + + glm::vec3 s = mod * scale; + S[0][0] = s.x; + S[1][1] = s.y; + S[2][2] = s.z; + + glm::mat3 M = S * R; + + const float* dL_dcov3D = dL_dcov3Ds + 6 * idx; + + glm::vec3 dunc(dL_dcov3D[0], dL_dcov3D[3], dL_dcov3D[5]); + glm::vec3 ounc = 0.5f * glm::vec3(dL_dcov3D[1], dL_dcov3D[2], dL_dcov3D[4]); + + // Convert per-element covariance loss gradients to matrix form + glm::mat3 dL_dSigma = glm::mat3( + dL_dcov3D[0], 0.5f * dL_dcov3D[1], 0.5f * dL_dcov3D[2], + 0.5f * dL_dcov3D[1], dL_dcov3D[3], 0.5f * dL_dcov3D[4], + 0.5f * dL_dcov3D[2], 0.5f * dL_dcov3D[4], dL_dcov3D[5] + ); + + // Compute loss gradient w.r.t. matrix M + // dSigma_dM = 2 * M + glm::mat3 dL_dM = 2.0f * M * dL_dSigma; + + glm::mat3 Rt = glm::transpose(R); + glm::mat3 dL_dMt = glm::transpose(dL_dM); + + // Gradients of loss w.r.t. scale + glm::vec3* dL_dscale = dL_dscales + idx; + dL_dscale->x = glm::dot(Rt[0], dL_dMt[0]); + dL_dscale->y = glm::dot(Rt[1], dL_dMt[1]); + dL_dscale->z = glm::dot(Rt[2], dL_dMt[2]); + + dL_dMt[0] *= s.x; + dL_dMt[1] *= s.y; + dL_dMt[2] *= s.z; + + // Gradients of loss w.r.t. normalized quaternion + glm::vec4 dL_dq; + dL_dq.x = 2 * z * (dL_dMt[0][1] - dL_dMt[1][0]) + 2 * y * (dL_dMt[2][0] - dL_dMt[0][2]) + 2 * x * (dL_dMt[1][2] - dL_dMt[2][1]); + dL_dq.y = 2 * y * (dL_dMt[1][0] + dL_dMt[0][1]) + 2 * z * (dL_dMt[2][0] + dL_dMt[0][2]) + 2 * r * (dL_dMt[1][2] - dL_dMt[2][1]) - 4 * x * (dL_dMt[2][2] + dL_dMt[1][1]); + dL_dq.z = 2 * x * (dL_dMt[1][0] + dL_dMt[0][1]) + 2 * r * (dL_dMt[2][0] - dL_dMt[0][2]) + 2 * z * (dL_dMt[1][2] + dL_dMt[2][1]) - 4 * y * (dL_dMt[2][2] + dL_dMt[0][0]); + dL_dq.w = 2 * r * (dL_dMt[0][1] - dL_dMt[1][0]) + 2 * x * (dL_dMt[2][0] + dL_dMt[0][2]) + 2 * y * (dL_dMt[1][2] + dL_dMt[2][1]) - 4 * z * (dL_dMt[1][1] + dL_dMt[0][0]); + + // Gradients of loss w.r.t. unnormalized quaternion + float4* dL_drot = (float4*)(dL_drots + idx); + *dL_drot = float4{ dL_dq.x, dL_dq.y, dL_dq.z, dL_dq.w };//dnormvdv(float4{ rot.x, rot.y, rot.z, rot.w }, float4{ dL_dq.x, dL_dq.y, dL_dq.z, dL_dq.w }); +} + +// Backward pass of the preprocessing steps, except +// for the covariance computation and inversion +// (those are handled by a previous kernel call) +template +__global__ void preprocessCUDA( + int P, int D, int M, + const float3* means, + const int* radii, + const float* shs, + const bool* clamped, + const glm::vec3* scales, + const glm::vec4* rotations, + const float scale_modifier, + const float* proj, + const glm::vec3* campos, + const float3* dL_dmean2D, + glm::vec3* dL_dmeans, + float* dL_dcolor, + float* dL_dcov3D, + float* dL_dsh, + glm::vec3* dL_dscale, + glm::vec4* dL_drot) +{ + auto idx = cg::this_grid().thread_rank(); + if (idx >= P || !(radii[idx] > 0)) + return; + + float3 m = means[idx]; + + // Taking care of gradients from the screenspace points + float4 m_hom = transformPoint4x4(m, proj); + float m_w = 1.0f / (m_hom.w + 0.0000001f); + + // Compute loss gradient w.r.t. 3D means due to gradients of 2D means + // from rendering procedure + glm::vec3 dL_dmean; + float mul1 = (proj[0] * m.x + proj[4] * m.y + proj[8] * m.z + proj[12]) * m_w * m_w; + float mul2 = (proj[1] * m.x + proj[5] * m.y + proj[9] * m.z + proj[13]) * m_w * m_w; + dL_dmean.x = (proj[0] * m_w - proj[3] * mul1) * dL_dmean2D[idx].x + (proj[1] * m_w - proj[3] * mul2) * dL_dmean2D[idx].y; + dL_dmean.y = (proj[4] * m_w - proj[7] * mul1) * dL_dmean2D[idx].x + (proj[5] * m_w - proj[7] * mul2) * dL_dmean2D[idx].y; + dL_dmean.z = (proj[8] * m_w - proj[11] * mul1) * dL_dmean2D[idx].x + (proj[9] * m_w - proj[11] * mul2) * dL_dmean2D[idx].y; + + // That's the second part of the mean gradient. Previous computation + // of cov2D and following SH conversion also affects it. + dL_dmeans[idx] += dL_dmean; + + // Compute gradient updates due to computing colors from SHs + if (shs) + computeColorFromSH(idx, D, M, (glm::vec3*)means, *campos, shs, clamped, (glm::vec3*)dL_dcolor, (glm::vec3*)dL_dmeans, (glm::vec3*)dL_dsh); + + // Compute gradient updates due to computing covariance from scale/rotation + if (scales) + computeCov3D(idx, scales[idx], scale_modifier, rotations[idx], dL_dcov3D, dL_dscale, dL_drot); +} + +// Backward version of the rendering procedure. +template +__global__ void __launch_bounds__(BLOCK_X * BLOCK_Y) +renderCUDA( + const uint2* __restrict__ ranges, + const uint32_t* __restrict__ point_list, + int W, int H, + const float* __restrict__ bg_color, + const float2* __restrict__ points_xy_image, + const float4* __restrict__ conic_opacity, + const float* __restrict__ colors, + const float* __restrict__ depths, + const float* __restrict__ final_Ts, + const uint32_t* __restrict__ n_contrib, + const float* __restrict__ dL_dpixels, + const float* __restrict__ dL_depths, + float3* __restrict__ dL_dmean2D, + float4* __restrict__ dL_dconic2D, + float* __restrict__ dL_dopacity, + float* __restrict__ dL_dcolors) +{ + // We rasterize again. Compute necessary block info. + auto block = cg::this_thread_block(); + const uint32_t horizontal_blocks = (W + BLOCK_X - 1) / BLOCK_X; + const uint2 pix_min = { block.group_index().x * BLOCK_X, block.group_index().y * BLOCK_Y }; + const uint2 pix_max = { min(pix_min.x + BLOCK_X, W), min(pix_min.y + BLOCK_Y , H) }; + const uint2 pix = { pix_min.x + block.thread_index().x, pix_min.y + block.thread_index().y }; + const uint32_t pix_id = W * pix.y + pix.x; + const float2 pixf = { (float)pix.x, (float)pix.y }; + + const bool inside = pix.x < W&& pix.y < H; + const uint2 range = ranges[block.group_index().y * horizontal_blocks + block.group_index().x]; + + const int rounds = ((range.y - range.x + BLOCK_SIZE - 1) / BLOCK_SIZE); + + bool done = !inside; + int toDo = range.y - range.x; + + __shared__ int collected_id[BLOCK_SIZE]; + __shared__ float2 collected_xy[BLOCK_SIZE]; + __shared__ float4 collected_conic_opacity[BLOCK_SIZE]; + __shared__ float collected_colors[C * BLOCK_SIZE]; + __shared__ float collected_depths[BLOCK_SIZE]; + // __shared__ float collected_alphas[BLOCK_SIZE]; + + // In the forward, we stored the final value for T, the + // product of all (1 - alpha) factors. + const float T_final = inside ? final_Ts[pix_id] : 0; + float T = T_final; + + // We start from the back. The ID of the last contributing + // Gaussian is known from each pixel from the forward. + uint32_t contributor = toDo; + const int last_contributor = inside ? n_contrib[pix_id] : 0; + + float accum_rec[C] = { 0 }; + float dL_dpixel[C]; + float dL_depth; + float dL_dT; + float accum_depth_rec = 0; + float accum_T_rec = T_final; + if (inside) + for (int i = 0; i < C; i++) + dL_dpixel[i] = dL_dpixels[i * H * W + pix_id]; + dL_depth = dL_depths[pix_id]; + dL_dT = dL_depths[H * W + pix_id]; + + float last_alpha = 0; + float last_color[C] = { 0 }; + float last_depth = 0; + + // Gradient of pixel coordinate w.r.t. normalized + // screen-space viewport corrdinates (-1 to 1) + const float ddelx_dx = 0.5 * W; + const float ddely_dy = 0.5 * H; + + // Traverse all Gaussians + for (int i = 0; i < rounds; i++, toDo -= BLOCK_SIZE) + { + // Load auxiliary data into shared memory, start in the BACK + // and load them in revers order. + block.sync(); + const int progress = i * BLOCK_SIZE + block.thread_rank(); + if (range.x + progress < range.y) + { + const int coll_id = point_list[range.y - progress - 1]; + collected_id[block.thread_rank()] = coll_id; + collected_xy[block.thread_rank()] = points_xy_image[coll_id]; + collected_conic_opacity[block.thread_rank()] = conic_opacity[coll_id]; + for (int i = 0; i < C; i++) + collected_colors[i * BLOCK_SIZE + block.thread_rank()] = colors[coll_id * C + i]; + collected_depths[block.thread_rank()] = depths[coll_id]; + } + block.sync(); + + // Iterate over Gaussians + for (int j = 0; !done && j < min(BLOCK_SIZE, toDo); j++) + { + // Keep track of current Gaussian ID. Skip, if this one + // is behind the last contributor for this pixel. + contributor--; + if (contributor >= last_contributor) + continue; + + // Compute blending values, as before. + const float2 xy = collected_xy[j]; + const float2 d = { xy.x - pixf.x, xy.y - pixf.y }; + const float4 con_o = collected_conic_opacity[j]; + const float power = -0.5f * (con_o.x * d.x * d.x + con_o.z * d.y * d.y) - con_o.y * d.x * d.y; + if (power > 0.0f) + continue; + + const float G = exp(power); + const float alpha = min(0.99f, con_o.w * G); + if (alpha < 1.0f / 255.0f) + continue; + + T = T / (1.f - alpha); + const float dchannel_dcolor = alpha * T; + + // Propagate gradients to per-Gaussian colors and keep + // gradients w.r.t. alpha (blending factor for a Gaussian/pixel + // pair). + float dL_dalpha = 0.0f; + const int global_id = collected_id[j]; + for (int ch = 0; ch < C; ch++) + { + const float c = collected_colors[ch * BLOCK_SIZE + j]; + // Update last color (to be used in the next iteration) + accum_rec[ch] = last_alpha * last_color[ch] + (1.f - last_alpha) * accum_rec[ch]; + last_color[ch] = c; + + const float dL_dchannel = dL_dpixel[ch]; + dL_dalpha += (c - accum_rec[ch]) * dL_dchannel; + // Update the gradients w.r.t. color of the Gaussian. + // Atomic, since this pixel is just one of potentially + // many that were affected by this Gaussian. + atomicAdd(&(dL_dcolors[global_id * C + ch]), dchannel_dcolor * dL_dchannel); + } + + // Propagate gradients to per-Gaussian depths + const float c_d = collected_depths[j]; + accum_depth_rec = last_alpha * last_depth + (1.f - last_alpha) * accum_depth_rec; + last_depth = c_d; + dL_dalpha += (c_d - accum_depth_rec) * dL_depth; + // for (int ch = 0; ch < C; ch++) + // { + // atomicAdd(&(dL_dcolors[global_id * C + ch]), dchannel_dcolor * dL_depth); + // } + + dL_dalpha *= T; + + // Propagate gradients from Ts to per-Gaussian alpha + + // in forward: + + // final_T = last_T * (1.f - alpha) + // final_T = (last_last_T * (1.f - last_alpha)) * (1.f - alpha) + + // and here we have: + + // 'T = final_T / (1.f - alpha) = last_T' + // c_T = last_T * (1.f - alpha) + // dT_dalpha = -last_T + // dL_dalpha = dL_dT * dT_dalpha = dL_dT * -last_T + + // and also: + + // dT_dlast_T = (1.f - alpha) + // dL_dlast_T = dL_dT * dT_dlast_T + + dL_dalpha += -T * dL_dT; + dL_dT *= (1.f - alpha); + + // Update last alpha (to be used in the next iteration) + last_alpha = alpha; + + // Account for fact that alpha also influences how much of + // the background color is added if nothing left to blend + float bg_dot_dpixel = 0; + for (int i = 0; i < C; i++) + bg_dot_dpixel += bg_color[i] * dL_dpixel[i]; + dL_dalpha += (-T_final / (1.f - alpha)) * bg_dot_dpixel; + + + // Helpful reusable temporary variables + const float dL_dG = con_o.w * dL_dalpha; + const float gdx = G * d.x; + const float gdy = G * d.y; + const float dG_ddelx = -gdx * con_o.x - gdy * con_o.y; + const float dG_ddely = -gdy * con_o.z - gdx * con_o.y; + + // Update gradients w.r.t. 2D mean position of the Gaussian + atomicAdd(&dL_dmean2D[global_id].x, dL_dG * dG_ddelx * ddelx_dx); + atomicAdd(&dL_dmean2D[global_id].y, dL_dG * dG_ddely * ddely_dy); + + // Update gradients w.r.t. 2D covariance (2x2 matrix, symmetric) + atomicAdd(&dL_dconic2D[global_id].x, -0.5f * gdx * d.x * dL_dG); + atomicAdd(&dL_dconic2D[global_id].y, -0.5f * gdx * d.y * dL_dG); + atomicAdd(&dL_dconic2D[global_id].w, -0.5f * gdy * d.y * dL_dG); + + // Update gradients w.r.t. opacity of the Gaussian + atomicAdd(&(dL_dopacity[global_id]), G * dL_dalpha); + } + } +} + +void BACKWARD::preprocess( + int P, int D, int M, + const float3* means3D, + const int* radii, + const float* shs, + const bool* clamped, + const glm::vec3* scales, + const glm::vec4* rotations, + const float scale_modifier, + const float* cov3Ds, + const float* viewmatrix, + const float* projmatrix, + const float focal_x, float focal_y, + const float tan_fovx, float tan_fovy, + const glm::vec3* campos, + const float3* dL_dmean2D, + const float* dL_dconic, + glm::vec3* dL_dmean3D, + float* dL_dcolor, + float* dL_dcov3D, + float* dL_dsh, + glm::vec3* dL_dscale, + glm::vec4* dL_drot) +{ + // Propagate gradients for the path of 2D conic matrix computation. + // Somewhat long, thus it is its own kernel rather than being part of + // "preprocess". When done, loss gradient w.r.t. 3D means has been + // modified and gradient w.r.t. 3D covariance matrix has been computed. + computeCov2DCUDA << <(P + 255) / 256, 256 >> > ( + P, + means3D, + radii, + cov3Ds, + focal_x, + focal_y, + tan_fovx, + tan_fovy, + viewmatrix, + dL_dconic, + (float3*)dL_dmean3D, + dL_dcov3D); + + // Propagate gradients for remaining steps: finish 3D mean gradients, + // propagate color gradients to SH (if desireD), propagate 3D covariance + // matrix gradients to scale and rotation. + preprocessCUDA << < (P + 255) / 256, 256 >> > ( + P, D, M, + (float3*)means3D, + radii, + shs, + clamped, + (glm::vec3*)scales, + (glm::vec4*)rotations, + scale_modifier, + projmatrix, + campos, + (float3*)dL_dmean2D, + (glm::vec3*)dL_dmean3D, + dL_dcolor, + dL_dcov3D, + dL_dsh, + dL_dscale, + dL_drot); +} + +void BACKWARD::render( + const dim3 grid, const dim3 block, + const uint2* ranges, + const uint32_t* point_list, + int W, int H, + const float* bg_color, + const float2* means2D, + const float4* conic_opacity, + const float* colors, + const float* depths, + const float* final_Ts, + const uint32_t* n_contrib, + const float* dL_dpixels, + const float* dL_depths, + float3* dL_dmean2D, + float4* dL_dconic2D, + float* dL_dopacity, + float* dL_dcolors) +{ + renderCUDA << > >( + ranges, + point_list, + W, H, + bg_color, + means2D, + conic_opacity, + colors, + depths, + final_Ts, + n_contrib, + dL_dpixels, + dL_depths, + dL_dmean2D, + dL_dconic2D, + dL_dopacity, + dL_dcolors + ); +} \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.h b/submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.h new file mode 100644 index 0000000000000000000000000000000000000000..09f84f20f78d70b907a6b9bc0af3778b7ef250ea --- /dev/null +++ b/submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#ifndef CUDA_RASTERIZER_BACKWARD_H_INCLUDED +#define CUDA_RASTERIZER_BACKWARD_H_INCLUDED + +#include +#include "cuda_runtime.h" +#include "device_launch_parameters.h" +#define GLM_FORCE_CUDA +#include + +namespace BACKWARD +{ + void render( + const dim3 grid, dim3 block, + const uint2* ranges, + const uint32_t* point_list, + int W, int H, + const float* bg_color, + const float2* means2D, + const float4* conic_opacity, + const float* colors, + const float* depths, + const float* final_Ts, + const uint32_t* n_contrib, + const float* dL_dpixels, + const float* dL_depths, + float3* dL_dmean2D, + float4* dL_dconic2D, + float* dL_dopacity, + float* dL_dcolors); + + void preprocess( + int P, int D, int M, + const float3* means, + const int* radii, + const float* shs, + const bool* clamped, + const glm::vec3* scales, + const glm::vec4* rotations, + const float scale_modifier, + const float* cov3Ds, + const float* view, + const float* proj, + const float focal_x, float focal_y, + const float tan_fovx, float tan_fovy, + const glm::vec3* campos, + const float3* dL_dmean2D, + const float* dL_dconics, + glm::vec3* dL_dmeans, + float* dL_dcolor, + float* dL_dcov3D, + float* dL_dsh, + glm::vec3* dL_dscale, + glm::vec4* dL_drot); +} + +#endif \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/cuda_rasterizer/config.h b/submodules/diff-gaussian-rasterization/cuda_rasterizer/config.h new file mode 100644 index 0000000000000000000000000000000000000000..2a912fb34824349caadffe435fc1ab4b31e5aa4f --- /dev/null +++ b/submodules/diff-gaussian-rasterization/cuda_rasterizer/config.h @@ -0,0 +1,19 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#ifndef CUDA_RASTERIZER_CONFIG_H_INCLUDED +#define CUDA_RASTERIZER_CONFIG_H_INCLUDED + +#define NUM_CHANNELS 3 // Default 3, RGB +#define BLOCK_X 16 +#define BLOCK_Y 16 + +#endif \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.cu b/submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.cu new file mode 100644 index 0000000000000000000000000000000000000000..00e4071b3eef98a11cf266094b874c1b93e09a4a --- /dev/null +++ b/submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.cu @@ -0,0 +1,476 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#include "forward.h" +#include "auxiliary.h" +#include +#include +namespace cg = cooperative_groups; + +// Forward method for converting the input spherical harmonics +// coefficients of each Gaussian to a simple RGB color. +__device__ glm::vec3 computeColorFromSH(int idx, int deg, int max_coeffs, const glm::vec3* means, glm::vec3 campos, const float* shs, bool* clamped) +{ + // The implementation is loosely based on code for + // "Differentiable Point-Based Radiance Fields for + // Efficient View Synthesis" by Zhang et al. (2022) + glm::vec3 pos = means[idx]; + glm::vec3 dir = pos - campos; + dir = dir / glm::length(dir); + + glm::vec3* sh = ((glm::vec3*)shs) + idx * max_coeffs; + glm::vec3 result = SH_C0 * sh[0]; + + if (deg > 0) + { + float x = dir.x; + float y = dir.y; + float z = dir.z; + result = result - SH_C1 * y * sh[1] + SH_C1 * z * sh[2] - SH_C1 * x * sh[3]; + + if (deg > 1) + { + float xx = x * x, yy = y * y, zz = z * z; + float xy = x * y, yz = y * z, xz = x * z; + result = result + + SH_C2[0] * xy * sh[4] + + SH_C2[1] * yz * sh[5] + + SH_C2[2] * (2.0f * zz - xx - yy) * sh[6] + + SH_C2[3] * xz * sh[7] + + SH_C2[4] * (xx - yy) * sh[8]; + + if (deg > 2) + { + result = result + + SH_C3[0] * y * (3.0f * xx - yy) * sh[9] + + SH_C3[1] * xy * z * sh[10] + + SH_C3[2] * y * (4.0f * zz - xx - yy) * sh[11] + + SH_C3[3] * z * (2.0f * zz - 3.0f * xx - 3.0f * yy) * sh[12] + + SH_C3[4] * x * (4.0f * zz - xx - yy) * sh[13] + + SH_C3[5] * z * (xx - yy) * sh[14] + + SH_C3[6] * x * (xx - 3.0f * yy) * sh[15]; + } + } + } + result += 0.5f; + + // RGB colors are clamped to positive values. If values are + // clamped, we need to keep track of this for the backward pass. + clamped[3 * idx + 0] = (result.x < 0); + clamped[3 * idx + 1] = (result.y < 0); + clamped[3 * idx + 2] = (result.z < 0); + return glm::max(result, 0.0f); +} + +// Forward version of 2D covariance matrix computation +__device__ float3 computeCov2D(const float3& mean, float focal_x, float focal_y, float tan_fovx, float tan_fovy, const float* cov3D, const float* viewmatrix) +{ + // The following models the steps outlined by equations 29 + // and 31 in "EWA Splatting" (Zwicker et al., 2002). + // Additionally considers aspect / scaling of viewport. + // Transposes used to account for row-/column-major conventions. + float3 t = transformPoint4x3(mean, viewmatrix); + + const float limx = 1.3f * tan_fovx; + const float limy = 1.3f * tan_fovy; + const float txtz = t.x / t.z; + const float tytz = t.y / t.z; + t.x = min(limx, max(-limx, txtz)) * t.z; + t.y = min(limy, max(-limy, tytz)) * t.z; + + glm::mat3 J = glm::mat3( + focal_x / t.z, 0.0f, -(focal_x * t.x) / (t.z * t.z), + 0.0f, focal_y / t.z, -(focal_y * t.y) / (t.z * t.z), + 0, 0, 0); + + glm::mat3 W = glm::mat3( + viewmatrix[0], viewmatrix[4], viewmatrix[8], + viewmatrix[1], viewmatrix[5], viewmatrix[9], + viewmatrix[2], viewmatrix[6], viewmatrix[10]); + + glm::mat3 T = W * J; + + glm::mat3 Vrk = glm::mat3( + cov3D[0], cov3D[1], cov3D[2], + cov3D[1], cov3D[3], cov3D[4], + cov3D[2], cov3D[4], cov3D[5]); + + glm::mat3 cov = glm::transpose(T) * glm::transpose(Vrk) * T; + + // Apply low-pass filter: every Gaussian should be at least + // one pixel wide/high. Discard 3rd row and column. + cov[0][0] += 0.3f; + cov[1][1] += 0.3f; + return { float(cov[0][0]), float(cov[0][1]), float(cov[1][1]) }; +} + +// Forward method for converting scale and rotation properties of each +// Gaussian to a 3D covariance matrix in world space. Also takes care +// of quaternion normalization. +__device__ void computeCov3D(const glm::vec3 scale, float mod, const glm::vec4 rot, float* cov3D) +{ + // Create scaling matrix + glm::mat3 S = glm::mat3(1.0f); + S[0][0] = mod * scale.x; + S[1][1] = mod * scale.y; + S[2][2] = mod * scale.z; + + // Normalize quaternion to get valid rotation + glm::vec4 q = rot;// / glm::length(rot); + float r = q.x; + float x = q.y; + float y = q.z; + float z = q.w; + + // Compute rotation matrix from quaternion + glm::mat3 R = glm::mat3( + 1.f - 2.f * (y * y + z * z), 2.f * (x * y - r * z), 2.f * (x * z + r * y), + 2.f * (x * y + r * z), 1.f - 2.f * (x * x + z * z), 2.f * (y * z - r * x), + 2.f * (x * z - r * y), 2.f * (y * z + r * x), 1.f - 2.f * (x * x + y * y) + ); + + glm::mat3 M = S * R; + + // Compute 3D world covariance matrix Sigma + glm::mat3 Sigma = glm::transpose(M) * M; + + // Covariance is symmetric, only store upper right + cov3D[0] = Sigma[0][0]; + cov3D[1] = Sigma[0][1]; + cov3D[2] = Sigma[0][2]; + cov3D[3] = Sigma[1][1]; + cov3D[4] = Sigma[1][2]; + cov3D[5] = Sigma[2][2]; +} + +// Perform initial steps for each Gaussian prior to rasterization. +template +__global__ void preprocessCUDA(int P, int D, int M, + const float* orig_points, + const glm::vec3* scales, + const float scale_modifier, + const glm::vec4* rotations, + const float* opacities, + const float* shs, + bool* clamped, + const float* cov3D_precomp, + const float* colors_precomp, + const float* viewmatrix, + const float* projmatrix, + const glm::vec3* cam_pos, + const int W, int H, + const float tan_fovx, float tan_fovy, + const float focal_x, float focal_y, + int* radii, + float2* points_xy_image, + float* depths, + float* cov3Ds, + float* rgb, + float4* conic_opacity, + const dim3 grid, + uint32_t* tiles_touched, + bool prefiltered) +{ + auto idx = cg::this_grid().thread_rank(); + if (idx >= P) + return; + + // Initialize radius and touched tiles to 0. If this isn't changed, + // this Gaussian will not be processed further. + radii[idx] = 0; + tiles_touched[idx] = 0; + + // Perform near culling, quit if outside. + float3 p_view; + if (!in_frustum(idx, orig_points, viewmatrix, projmatrix, prefiltered, p_view)) + return; + + // Transform point by projecting + float3 p_orig = { orig_points[3 * idx], orig_points[3 * idx + 1], orig_points[3 * idx + 2] }; + float4 p_hom = transformPoint4x4(p_orig, projmatrix); + float p_w = 1.0f / (p_hom.w + 0.0000001f); + float3 p_proj = { p_hom.x * p_w, p_hom.y * p_w, p_hom.z * p_w }; + + // If 3D covariance matrix is precomputed, use it, otherwise compute + // from scaling and rotation parameters. + const float* cov3D; + if (cov3D_precomp != nullptr) + { + cov3D = cov3D_precomp + idx * 6; + } + else + { + computeCov3D(scales[idx], scale_modifier, rotations[idx], cov3Ds + idx * 6); + cov3D = cov3Ds + idx * 6; + } + + // Compute 2D screen-space covariance matrix + float3 cov = computeCov2D(p_orig, focal_x, focal_y, tan_fovx, tan_fovy, cov3D, viewmatrix); + + // Invert covariance (EWA algorithm) + float det = (cov.x * cov.z - cov.y * cov.y); + if (det == 0.0f) + return; + float det_inv = 1.f / det; + float3 conic = { cov.z * det_inv, -cov.y * det_inv, cov.x * det_inv }; + + // Compute extent in screen space (by finding eigenvalues of + // 2D covariance matrix). Use extent to compute a bounding rectangle + // of screen-space tiles that this Gaussian overlaps with. Quit if + // rectangle covers 0 tiles. + float mid = 0.5f * (cov.x + cov.z); + float lambda1 = mid + sqrt(max(0.1f, mid * mid - det)); + float lambda2 = mid - sqrt(max(0.1f, mid * mid - det)); + float my_radius = ceil(3.f * sqrt(max(lambda1, lambda2))); + float2 point_image = { ndc2Pix(p_proj.x, W), ndc2Pix(p_proj.y, H) }; + uint2 rect_min, rect_max; + getRect(point_image, my_radius, rect_min, rect_max, grid); + if ((rect_max.x - rect_min.x) * (rect_max.y - rect_min.y) == 0) + return; + + // If colors have been precomputed, use them, otherwise convert + // spherical harmonics coefficients to RGB color. + if (colors_precomp == nullptr) + { + glm::vec3 result = computeColorFromSH(idx, D, M, (glm::vec3*)orig_points, *cam_pos, shs, clamped); + rgb[idx * C + 0] = result.x; + rgb[idx * C + 1] = result.y; + rgb[idx * C + 2] = result.z; + } + + // Store some useful helper data for the next steps. + depths[idx] = p_view.z; + radii[idx] = my_radius; + points_xy_image[idx] = point_image; + // Inverse 2D covariance and opacity neatly pack into one float4 + conic_opacity[idx] = { conic.x, conic.y, conic.z, opacities[idx] }; + tiles_touched[idx] = (rect_max.y - rect_min.y) * (rect_max.x - rect_min.x); +} + +// Main rasterization method. Collaboratively works on one tile per +// block, each thread treats one pixel. Alternates between fetching +// and rasterizing data. +template +__global__ void __launch_bounds__(BLOCK_X * BLOCK_Y) +renderCUDA( + const uint2* __restrict__ ranges, + const uint32_t* __restrict__ point_list, + int W, int H, + const float2* __restrict__ points_xy_image, + const float* __restrict__ features, + const float* __restrict__ depths, + const float4* __restrict__ conic_opacity, + float* __restrict__ final_T, + uint32_t* __restrict__ n_contrib, + const float* __restrict__ bg_color, + float* __restrict__ out_color, + float* __restrict__ out_depth) +{ + // Identify current tile and associated min/max pixel range. + auto block = cg::this_thread_block(); + uint32_t horizontal_blocks = (W + BLOCK_X - 1) / BLOCK_X; + uint2 pix_min = { block.group_index().x * BLOCK_X, block.group_index().y * BLOCK_Y }; + uint2 pix_max = { min(pix_min.x + BLOCK_X, W), min(pix_min.y + BLOCK_Y , H) }; + uint2 pix = { pix_min.x + block.thread_index().x, pix_min.y + block.thread_index().y }; + uint32_t pix_id = W * pix.y + pix.x; + float2 pixf = { (float)pix.x, (float)pix.y }; + + // Check if this thread is associated with a valid pixel or outside. + bool inside = pix.x < W&& pix.y < H; + // Done threads can help with fetching, but don't rasterize + bool done = !inside; + + // Load start/end range of IDs to process in bit sorted list. + uint2 range = ranges[block.group_index().y * horizontal_blocks + block.group_index().x]; + const int rounds = ((range.y - range.x + BLOCK_SIZE - 1) / BLOCK_SIZE); + int toDo = range.y - range.x; + + // Allocate storage for batches of collectively fetched data. + __shared__ int collected_id[BLOCK_SIZE]; + __shared__ float2 collected_xy[BLOCK_SIZE]; + __shared__ float4 collected_conic_opacity[BLOCK_SIZE]; + + // Initialize helper variables + float T = 1.0f; + uint32_t contributor = 0; + uint32_t last_contributor = 0; + float C[CHANNELS] = { 0 }; + float D = { 0 }; + // float A = { 0 }; + + // Iterate over batches until all done or range is complete + for (int i = 0; i < rounds; i++, toDo -= BLOCK_SIZE) + { + // End if entire block votes that it is done rasterizing + int num_done = __syncthreads_count(done); + if (num_done == BLOCK_SIZE) + break; + + // Collectively fetch per-Gaussian data from global to shared + int progress = i * BLOCK_SIZE + block.thread_rank(); + if (range.x + progress < range.y) + { + int coll_id = point_list[range.x + progress]; + collected_id[block.thread_rank()] = coll_id; + collected_xy[block.thread_rank()] = points_xy_image[coll_id]; + collected_conic_opacity[block.thread_rank()] = conic_opacity[coll_id]; + } + block.sync(); + + // Iterate over current batch + for (int j = 0; !done && j < min(BLOCK_SIZE, toDo); j++) + { + // Keep track of current position in range + contributor++; + + // Resample using conic matrix (cf. "Surface + // Splatting" by Zwicker et al., 2001) + float2 xy = collected_xy[j]; + float2 d = { xy.x - pixf.x, xy.y - pixf.y }; + float4 con_o = collected_conic_opacity[j]; + float power = -0.5f * (con_o.x * d.x * d.x + con_o.z * d.y * d.y) - con_o.y * d.x * d.y; + if (power > 0.0f) + continue; + + // Eq. (2) from 3D Gaussian splatting paper. + // Obtain alpha by multiplying with Gaussian opacity + // and its exponential falloff from mean. + // Avoid numerical instabilities (see paper appendix). + float alpha = min(0.99f, con_o.w * exp(power)); + if (alpha < 1.0f / 255.0f) + continue; + float test_T = T * (1 - alpha); + if (test_T < 0.0001f) + { + done = true; + continue; + } + + // Eq. (3) from 3D Gaussian splatting paper. + for (int ch = 0; ch < CHANNELS; ch++) + C[ch] += features[collected_id[j] * CHANNELS + ch] * alpha * T; + D += depths[collected_id[j]] * alpha * T; + // A += alpha * T; + + T = test_T; + + // Keep track of last range entry to update this + // pixel. + last_contributor = contributor; + } + } + + // All threads that treat valid pixel write out their final + // rendering data to the frame and auxiliary buffers. + if (inside) + { + final_T[pix_id] = T; + n_contrib[pix_id] = last_contributor; + for (int ch = 0; ch < CHANNELS; ch++) + out_color[ch * H * W + pix_id] = C[ch] + T * bg_color[ch]; + out_depth[pix_id] = D; + out_depth[W * H + pix_id] = T; + // if (A > 0.499f) + // { + // out_depth[pix_id] = D; + // } + // else + // { + // out_depth[pix_id] = -1.0f; + // } + + } +} + +void FORWARD::render( + const dim3 grid, dim3 block, + const uint2* ranges, + const uint32_t* point_list, + int W, int H, + const float2* means2D, + const float* colors, + const float* depths, + const float4* conic_opacity, + float* final_T, + uint32_t* n_contrib, + const float* bg_color, + float* out_color, + float* out_depth) +{ + renderCUDA << > > ( + ranges, + point_list, + W, H, + means2D, + colors, + depths, + conic_opacity, + final_T, + n_contrib, + bg_color, + out_color, + out_depth); +} + +void FORWARD::preprocess(int P, int D, int M, + const float* means3D, + const glm::vec3* scales, + const float scale_modifier, + const glm::vec4* rotations, + const float* opacities, + const float* shs, + bool* clamped, + const float* cov3D_precomp, + const float* colors_precomp, + const float* viewmatrix, + const float* projmatrix, + const glm::vec3* cam_pos, + const int W, int H, + const float focal_x, float focal_y, + const float tan_fovx, float tan_fovy, + int* radii, + float2* means2D, + float* depths, + float* cov3Ds, + float* rgb, + float4* conic_opacity, + const dim3 grid, + uint32_t* tiles_touched, + bool prefiltered) +{ + preprocessCUDA << <(P + 255) / 256, 256 >> > ( + P, D, M, + means3D, + scales, + scale_modifier, + rotations, + opacities, + shs, + clamped, + cov3D_precomp, + colors_precomp, + viewmatrix, + projmatrix, + cam_pos, + W, H, + tan_fovx, tan_fovy, + focal_x, focal_y, + radii, + means2D, + depths, + cov3Ds, + rgb, + conic_opacity, + grid, + tiles_touched, + prefiltered + ); +} diff --git a/submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.h b/submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.h new file mode 100644 index 0000000000000000000000000000000000000000..5722e1edba0c93530bf5c4460e31ef189abc9e89 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.h @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#ifndef CUDA_RASTERIZER_FORWARD_H_INCLUDED +#define CUDA_RASTERIZER_FORWARD_H_INCLUDED + +#include +#include "cuda_runtime.h" +#include "device_launch_parameters.h" +#define GLM_FORCE_CUDA +#include + +namespace FORWARD +{ + // Perform initial steps for each Gaussian prior to rasterization. + void preprocess(int P, int D, int M, + const float* orig_points, + const glm::vec3* scales, + const float scale_modifier, + const glm::vec4* rotations, + const float* opacities, + const float* shs, + bool* clamped, + const float* cov3D_precomp, + const float* colors_precomp, + const float* viewmatrix, + const float* projmatrix, + const glm::vec3* cam_pos, + const int W, int H, + const float focal_x, float focal_y, + const float tan_fovx, float tan_fovy, + int* radii, + float2* points_xy_image, + float* depths, + float* cov3Ds, + float* colors, + float4* conic_opacity, + const dim3 grid, + uint32_t* tiles_touched, + bool prefiltered); + + // Main rasterization method. + void render( + const dim3 grid, dim3 block, + const uint2* ranges, + const uint32_t* point_list, + int W, int H, + const float2* points_xy_image, + const float* features, + const float* depths, + const float4* conic_opacity, + float* final_T, + uint32_t* n_contrib, + const float* bg_color, + float* out_color, + float* out_depth); +} + + +#endif \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer.h b/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer.h new file mode 100644 index 0000000000000000000000000000000000000000..5ecdaf82fea2bcb2193d89c39da35cf6ee5b7cf0 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer.h @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#ifndef CUDA_RASTERIZER_H_INCLUDED +#define CUDA_RASTERIZER_H_INCLUDED + +#include +#include + +namespace CudaRasterizer +{ + class Rasterizer + { + public: + + static void markVisible( + int P, + float* means3D, + float* viewmatrix, + float* projmatrix, + bool* present); + + static int forward( + std::function geometryBuffer, + std::function binningBuffer, + std::function imageBuffer, + const int P, int D, int M, + const float* background, + const int width, int height, + const float* means3D, + const float* shs, + const float* colors_precomp, + const float* opacities, + const float* scales, + const float scale_modifier, + const float* rotations, + const float* cov3D_precomp, + const float* viewmatrix, + const float* projmatrix, + const float* cam_pos, + const float tan_fovx, float tan_fovy, + const bool prefiltered, + float* out_color, + float* out_depth, + int* radii = nullptr); + + static void backward( + const int P, int D, int M, int R, + const float* background, + const int width, int height, + const float* means3D, + const float* shs, + const float* colors_precomp, + const float* scales, + const float scale_modifier, + const float* rotations, + const float* cov3D_precomp, + const float* viewmatrix, + const float* projmatrix, + const float* campos, + const float tan_fovx, float tan_fovy, + const int* radii, + char* geom_buffer, + char* binning_buffer, + char* image_buffer, + const float* dL_dpix, + const float* dL_depths, + float* dL_dmean2D, + float* dL_dconic, + float* dL_dopacity, + float* dL_dcolor, + float* dL_dmean3D, + float* dL_dcov3D, + float* dL_dsh, + float* dL_dscale, + float* dL_drot); + }; +}; + +#endif \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.cu b/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.cu new file mode 100644 index 0000000000000000000000000000000000000000..ca287eb6c73dead370977a96a374c9ca9fb2762d --- /dev/null +++ b/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.cu @@ -0,0 +1,440 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#include "rasterizer_impl.h" +#include +#include +#include +#include +#include +#include "cuda_runtime.h" +#include "device_launch_parameters.h" +#include +#include +#define GLM_FORCE_CUDA +#include + +#include +#include +namespace cg = cooperative_groups; + +#include "auxiliary.h" +#include "forward.h" +#include "backward.h" + +// Helper function to find the next-highest bit of the MSB +// on the CPU. +uint32_t getHigherMsb(uint32_t n) +{ + uint32_t msb = sizeof(n) * 4; + uint32_t step = msb; + while (step > 1) + { + step /= 2; + if (n >> msb) + msb += step; + else + msb -= step; + } + if (n >> msb) + msb++; + return msb; +} + +// Wrapper method to call auxiliary coarse frustum containment test. +// Mark all Gaussians that pass it. +__global__ void checkFrustum(int P, + const float* orig_points, + const float* viewmatrix, + const float* projmatrix, + bool* present) +{ + auto idx = cg::this_grid().thread_rank(); + if (idx >= P) + return; + + float3 p_view; + present[idx] = in_frustum(idx, orig_points, viewmatrix, projmatrix, false, p_view); +} + +// Generates one key/value pair for all Gaussian / tile overlaps. +// Run once per Gaussian (1:N mapping). +__global__ void duplicateWithKeys( + int P, + const float2* points_xy, + const float* depths, + const uint32_t* offsets, + uint64_t* gaussian_keys_unsorted, + uint32_t* gaussian_values_unsorted, + int* radii, + dim3 grid) +{ + auto idx = cg::this_grid().thread_rank(); + if (idx >= P) + return; + + // Generate no key/value pair for invisible Gaussians + if (radii[idx] > 0) + { + // Find this Gaussian's offset in buffer for writing keys/values. + uint32_t off = (idx == 0) ? 0 : offsets[idx - 1]; + uint2 rect_min, rect_max; + + getRect(points_xy[idx], radii[idx], rect_min, rect_max, grid); + + // For each tile that the bounding rect overlaps, emit a + // key/value pair. The key is | tile ID | depth |, + // and the value is the ID of the Gaussian. Sorting the values + // with this key yields Gaussian IDs in a list, such that they + // are first sorted by tile and then by depth. + for (int y = rect_min.y; y < rect_max.y; y++) + { + for (int x = rect_min.x; x < rect_max.x; x++) + { + uint64_t key = y * grid.x + x; + key <<= 32; + key |= *((uint32_t*)&depths[idx]); + gaussian_keys_unsorted[off] = key; + gaussian_values_unsorted[off] = idx; + off++; + } + } + } +} + +// Check keys to see if it is at the start/end of one tile's range in +// the full sorted list. If yes, write start/end of this tile. +// Run once per instanced (duplicated) Gaussian ID. +__global__ void identifyTileRanges(int L, uint64_t* point_list_keys, uint2* ranges) +{ + auto idx = cg::this_grid().thread_rank(); + if (idx >= L) + return; + + // Read tile ID from key. Update start/end of tile range if at limit. + uint64_t key = point_list_keys[idx]; + uint32_t currtile = key >> 32; + if (idx == 0) + ranges[currtile].x = 0; + else + { + uint32_t prevtile = point_list_keys[idx - 1] >> 32; + if (currtile != prevtile) + { + ranges[prevtile].y = idx; + ranges[currtile].x = idx; + } + } + if (idx == L - 1) + ranges[currtile].y = L; +} + +// Mark Gaussians as visible/invisible, based on view frustum testing +void CudaRasterizer::Rasterizer::markVisible( + int P, + float* means3D, + float* viewmatrix, + float* projmatrix, + bool* present) +{ + checkFrustum << <(P + 255) / 256, 256 >> > ( + P, + means3D, + viewmatrix, projmatrix, + present); +} + +CudaRasterizer::GeometryState CudaRasterizer::GeometryState::fromChunk(char*& chunk, size_t P) +{ + GeometryState geom; + obtain(chunk, geom.depths, P, 128); + obtain(chunk, geom.clamped, P * 3, 128); + obtain(chunk, geom.internal_radii, P, 128); + obtain(chunk, geom.means2D, P, 128); + obtain(chunk, geom.cov3D, P * 6, 128); + obtain(chunk, geom.conic_opacity, P, 128); + obtain(chunk, geom.rgb, P * 3, 128); + obtain(chunk, geom.tiles_touched, P, 128); + cub::DeviceScan::InclusiveSum(nullptr, geom.scan_size, geom.tiles_touched, geom.tiles_touched, P); + obtain(chunk, geom.scanning_space, geom.scan_size, 128); + obtain(chunk, geom.point_offsets, P, 128); + return geom; +} + +CudaRasterizer::ImageState CudaRasterizer::ImageState::fromChunk(char*& chunk, size_t N) +{ + ImageState img; + obtain(chunk, img.accum_alpha, N, 128); + obtain(chunk, img.n_contrib, N, 128); + obtain(chunk, img.ranges, N, 128); + return img; +} + +CudaRasterizer::BinningState CudaRasterizer::BinningState::fromChunk(char*& chunk, size_t P) +{ + BinningState binning; + obtain(chunk, binning.point_list, P, 128); + obtain(chunk, binning.point_list_unsorted, P, 128); + obtain(chunk, binning.point_list_keys, P, 128); + obtain(chunk, binning.point_list_keys_unsorted, P, 128); + cub::DeviceRadixSort::SortPairs( + nullptr, binning.sorting_size, + binning.point_list_keys_unsorted, binning.point_list_keys, + binning.point_list_unsorted, binning.point_list, P); + obtain(chunk, binning.list_sorting_space, binning.sorting_size, 128); + return binning; +} + +// Forward rendering procedure for differentiable rasterization +// of Gaussians. +int CudaRasterizer::Rasterizer::forward( + std::function geometryBuffer, + std::function binningBuffer, + std::function imageBuffer, + const int P, int D, int M, + const float* background, + const int width, int height, + const float* means3D, + const float* shs, + const float* colors_precomp, + const float* opacities, + const float* scales, + const float scale_modifier, + const float* rotations, + const float* cov3D_precomp, + const float* viewmatrix, + const float* projmatrix, + const float* cam_pos, + const float tan_fovx, float tan_fovy, + const bool prefiltered, + float* out_color, + float* out_depth, + int* radii) +{ + const float focal_y = height / (2.0f * tan_fovy); + const float focal_x = width / (2.0f * tan_fovx); + + size_t chunk_size = required(P); + char* chunkptr = geometryBuffer(chunk_size); + GeometryState geomState = GeometryState::fromChunk(chunkptr, P); + + if (radii == nullptr) + { + radii = geomState.internal_radii; + } + + dim3 tile_grid((width + BLOCK_X - 1) / BLOCK_X, (height + BLOCK_Y - 1) / BLOCK_Y, 1); + dim3 block(BLOCK_X, BLOCK_Y, 1); + + // Dynamically resize image-based auxiliary buffers during training + int img_chunk_size = required(width * height); + char* img_chunkptr = imageBuffer(img_chunk_size); + ImageState imgState = ImageState::fromChunk(img_chunkptr, width * height); + + if (NUM_CHANNELS != 3 && colors_precomp == nullptr) + { + throw std::runtime_error("For non-RGB, provide precomputed Gaussian colors!"); + } + + // Run preprocessing per-Gaussian (transformation, bounding, conversion of SHs to RGB) + FORWARD::preprocess( + P, D, M, + means3D, + (glm::vec3*)scales, + scale_modifier, + (glm::vec4*)rotations, + opacities, + shs, + geomState.clamped, + cov3D_precomp, + colors_precomp, + viewmatrix, projmatrix, + (glm::vec3*)cam_pos, + width, height, + focal_x, focal_y, + tan_fovx, tan_fovy, + radii, + geomState.means2D, + geomState.depths, + geomState.cov3D, + geomState.rgb, + geomState.conic_opacity, + tile_grid, + geomState.tiles_touched, + prefiltered + ); + + // Compute prefix sum over full list of touched tile counts by Gaussians + // E.g., [2, 3, 0, 2, 1] -> [2, 5, 5, 7, 8] + cub::DeviceScan::InclusiveSum(geomState.scanning_space, geomState.scan_size, + geomState.tiles_touched, geomState.point_offsets, P); + + // Retrieve total number of Gaussian instances to launch and resize aux buffers + int num_rendered; + cudaMemcpy(&num_rendered, geomState.point_offsets + P - 1, sizeof(int), cudaMemcpyDeviceToHost); + + int binning_chunk_size = required(num_rendered); + char* binning_chunkptr = binningBuffer(binning_chunk_size); + BinningState binningState = BinningState::fromChunk(binning_chunkptr, num_rendered); + + // For each instance to be rendered, produce adequate [ tile | depth ] key + // and corresponding dublicated Gaussian indices to be sorted + duplicateWithKeys << <(P + 255) / 256, 256 >> > ( + P, + geomState.means2D, + geomState.depths, + geomState.point_offsets, + binningState.point_list_keys_unsorted, + binningState.point_list_unsorted, + radii, + tile_grid + ); + + int bit = getHigherMsb(tile_grid.x * tile_grid.y); + + // Sort complete list of (duplicated) Gaussian indices by keys + cub::DeviceRadixSort::SortPairs( + binningState.list_sorting_space, + binningState.sorting_size, + binningState.point_list_keys_unsorted, binningState.point_list_keys, + binningState.point_list_unsorted, binningState.point_list, + num_rendered, 0, 32 + bit); + + cudaMemset(imgState.ranges, 0, tile_grid.x * tile_grid.y * sizeof(uint2)); + + // Identify start and end of per-tile workloads in sorted list + if (num_rendered > 0) + identifyTileRanges << <(num_rendered + 255) / 256, 256 >> > ( + num_rendered, + binningState.point_list_keys, + imgState.ranges + ); + + // Let each tile blend its range of Gaussians independently in parallel + const float* feature_ptr = colors_precomp != nullptr ? colors_precomp : geomState.rgb; + FORWARD::render( + tile_grid, block, + imgState.ranges, + binningState.point_list, + width, height, + geomState.means2D, + feature_ptr, + geomState.depths, + geomState.conic_opacity, + imgState.accum_alpha, + imgState.n_contrib, + background, + out_color, + out_depth); + + return num_rendered; +} + +// Produce necessary gradients for optimization, corresponding +// to forward render pass +void CudaRasterizer::Rasterizer::backward( + const int P, int D, int M, int R, + const float* background, + const int width, int height, + const float* means3D, + const float* shs, + const float* colors_precomp, + const float* scales, + const float scale_modifier, + const float* rotations, + const float* cov3D_precomp, + const float* viewmatrix, + const float* projmatrix, + const float* campos, + const float tan_fovx, float tan_fovy, + const int* radii, + char* geom_buffer, + char* binning_buffer, + char* img_buffer, + const float* dL_dpix, + const float* dL_depths, + float* dL_dmean2D, + float* dL_dconic, + float* dL_dopacity, + float* dL_dcolor, + float* dL_dmean3D, + float* dL_dcov3D, + float* dL_dsh, + float* dL_dscale, + float* dL_drot) +{ + GeometryState geomState = GeometryState::fromChunk(geom_buffer, P); + BinningState binningState = BinningState::fromChunk(binning_buffer, R); + ImageState imgState = ImageState::fromChunk(img_buffer, width * height); + + if (radii == nullptr) + { + radii = geomState.internal_radii; + } + + const float focal_y = height / (2.0f * tan_fovy); + const float focal_x = width / (2.0f * tan_fovx); + + const dim3 tile_grid((width + BLOCK_X - 1) / BLOCK_X, (height + BLOCK_Y - 1) / BLOCK_Y, 1); + const dim3 block(BLOCK_X, BLOCK_Y, 1); + + // Compute loss gradients w.r.t. 2D mean position, conic matrix, + // opacity and RGB of Gaussians from per-pixel loss gradients. + // If we were given precomputed colors and not SHs, use them. + const float* color_ptr = (colors_precomp != nullptr) ? colors_precomp : geomState.rgb; + const float* depth_ptr = geomState.depths; + BACKWARD::render( + tile_grid, + block, + imgState.ranges, + binningState.point_list, + width, height, + background, + geomState.means2D, + geomState.conic_opacity, + color_ptr, + depth_ptr, + imgState.accum_alpha, + imgState.n_contrib, + dL_dpix, + dL_depths, + (float3*)dL_dmean2D, + (float4*)dL_dconic, + dL_dopacity, + dL_dcolor); + + // Take care of the rest of preprocessing. Was the precomputed covariance + // given to us or a scales/rot pair? If precomputed, pass that. If not, + // use the one we computed ourselves. + const float* cov3D_ptr = (cov3D_precomp != nullptr) ? cov3D_precomp : geomState.cov3D; + BACKWARD::preprocess(P, D, M, + (float3*)means3D, + radii, + shs, + geomState.clamped, + (glm::vec3*)scales, + (glm::vec4*)rotations, + scale_modifier, + cov3D_ptr, + viewmatrix, + projmatrix, + focal_x, focal_y, + tan_fovx, tan_fovy, + (glm::vec3*)campos, + (float3*)dL_dmean2D, + dL_dconic, + (glm::vec3*)dL_dmean3D, + dL_dcolor, + dL_dcov3D, + dL_dsh, + (glm::vec3*)dL_dscale, + (glm::vec4*)dL_drot); +} diff --git a/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.h b/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.h new file mode 100644 index 0000000000000000000000000000000000000000..bc3f0ece7f3eed613be1f95c212b07ac1220b58c --- /dev/null +++ b/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#pragma once + +#include +#include +#include "rasterizer.h" +#include + +namespace CudaRasterizer +{ + template + static void obtain(char*& chunk, T*& ptr, std::size_t count, std::size_t alignment) + { + std::size_t offset = (reinterpret_cast(chunk) + alignment - 1) & ~(alignment - 1); + ptr = reinterpret_cast(offset); + chunk = reinterpret_cast(ptr + count); + } + + struct GeometryState + { + size_t scan_size; + float* depths; + char* scanning_space; + bool* clamped; + int* internal_radii; + float2* means2D; + float* cov3D; + float4* conic_opacity; + float* rgb; + uint32_t* point_offsets; + uint32_t* tiles_touched; + + static GeometryState fromChunk(char*& chunk, size_t P); + }; + + struct ImageState + { + uint2* ranges; + uint32_t* n_contrib; + float* accum_alpha; + + static ImageState fromChunk(char*& chunk, size_t N); + }; + + struct BinningState + { + size_t sorting_size; + uint64_t* point_list_keys_unsorted; + uint64_t* point_list_keys; + uint32_t* point_list_unsorted; + uint32_t* point_list; + char* list_sorting_space; + + static BinningState fromChunk(char*& chunk, size_t P); + }; + + template + size_t required(size_t P) + { + char* size = nullptr; + T::fromChunk(size, P); + return ((size_t)size) + 128; + } +}; \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/diff_gaussian_rasterization/__init__.py b/submodules/diff-gaussian-rasterization/diff_gaussian_rasterization/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..eda2c8e02b7e4a1dc798bc9b75f9b2207e974782 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/diff_gaussian_rasterization/__init__.py @@ -0,0 +1,197 @@ +# +# Copyright (C) 2023, Inria +# GRAPHDECO research group, https://team.inria.fr/graphdeco +# All rights reserved. +# +# This software is free for non-commercial, research and evaluation use +# under the terms of the LICENSE.md file. +# +# For inquiries contact george.drettakis@inria.fr +# + +from typing import NamedTuple +import torch.nn as nn +import torch +from . import _C + +def rasterize_gaussians( + means3D, + means2D, + sh, + colors_precomp, + opacities, + scales, + rotations, + cov3Ds_precomp, + raster_settings, +): + return _RasterizeGaussians.apply( + means3D, + means2D, + sh, + colors_precomp, + opacities, + scales, + rotations, + cov3Ds_precomp, + raster_settings, + ) + +class _RasterizeGaussians(torch.autograd.Function): + @staticmethod + def forward( + ctx, + means3D, + means2D, + sh, + colors_precomp, + opacities, + scales, + rotations, + cov3Ds_precomp, + raster_settings, + ): + + # Restructure arguments the way that the C++ lib expects them + args = ( + raster_settings.bg, + means3D, + colors_precomp, + opacities, + scales, + rotations, + raster_settings.scale_modifier, + cov3Ds_precomp, + raster_settings.viewmatrix, + raster_settings.projmatrix, + raster_settings.tanfovx, + raster_settings.tanfovy, + raster_settings.image_height, + raster_settings.image_width, + sh, + raster_settings.sh_degree, + raster_settings.campos, + raster_settings.prefiltered, + ) + + # Invoke C++/CUDA rasterizer + num_rendered, color, depth, radii, geomBuffer, binningBuffer, imgBuffer = _C.rasterize_gaussians(*args) + + # Keep relevant tensors for backward + ctx.raster_settings = raster_settings + ctx.num_rendered = num_rendered + ctx.save_for_backward(colors_precomp, means3D, scales, rotations, cov3Ds_precomp, radii, sh, geomBuffer, binningBuffer, imgBuffer) + return color, radii, depth + + @staticmethod + def backward(ctx, grad_out_color, grad_radii, grad_depth): + + # Restore necessary values from context + num_rendered = ctx.num_rendered + raster_settings = ctx.raster_settings + colors_precomp, means3D, scales, rotations, cov3Ds_precomp, radii, sh, geomBuffer, binningBuffer, imgBuffer = ctx.saved_tensors + + # Restructure args as C++ method expects them + args = (raster_settings.bg, + means3D, + radii, + colors_precomp, + scales, + rotations, + raster_settings.scale_modifier, + cov3Ds_precomp, + raster_settings.viewmatrix, + raster_settings.projmatrix, + raster_settings.tanfovx, + raster_settings.tanfovy, + grad_out_color, + grad_depth, + sh, + raster_settings.sh_degree, + raster_settings.campos, + geomBuffer, + num_rendered, + binningBuffer, + imgBuffer) + + # Compute gradients for relevant tensors by invoking backward method + grad_means2D, grad_colors_precomp, grad_opacities, grad_means3D, grad_cov3Ds_precomp, grad_sh, grad_scales, grad_rotations = _C.rasterize_gaussians_backward(*args) + + grads = ( + grad_means3D, + grad_means2D, + grad_sh, + grad_colors_precomp, + grad_opacities, + grad_scales, + grad_rotations, + grad_cov3Ds_precomp, + None, + ) + + return grads + +class GaussianRasterizationSettings(NamedTuple): + image_height: int + image_width: int + tanfovx : float + tanfovy : float + bg : torch.Tensor + scale_modifier : float + viewmatrix : torch.Tensor + projmatrix : torch.Tensor + sh_degree : int + campos : torch.Tensor + prefiltered : bool + +class GaussianRasterizer(nn.Module): + def __init__(self, raster_settings): + super().__init__() + self.raster_settings = raster_settings + + def markVisible(self, positions): + # Mark visible points (based on frustum culling for camera) with a boolean + with torch.no_grad(): + raster_settings = self.raster_settings + visible = _C.mark_visible( + positions, + raster_settings.viewmatrix, + raster_settings.projmatrix) + + return visible + + def forward(self, means3D, means2D, opacities, shs = None, colors_precomp = None, scales = None, rotations = None, cov3D_precomp = None): + + raster_settings = self.raster_settings + + if (shs is None and colors_precomp is None) or (shs is not None and colors_precomp is not None): + raise Exception('Please provide excatly one of either SHs or precomputed colors!') + + if ((scales is None or rotations is None) and cov3D_precomp is None) or ((scales is not None or rotations is not None) and cov3D_precomp is not None): + raise Exception('Please provide exactly one of either scale/rotation pair or precomputed 3D covariance!') + + if shs is None: + shs = torch.Tensor([]) + if colors_precomp is None: + colors_precomp = torch.Tensor([]) + + if scales is None: + scales = torch.Tensor([]) + if rotations is None: + rotations = torch.Tensor([]) + if cov3D_precomp is None: + cov3D_precomp = torch.Tensor([]) + + # Invoke C++/CUDA rasterization routine + return rasterize_gaussians( + means3D, + means2D, + shs, + colors_precomp, + opacities, + scales, + rotations, + cov3D_precomp, + raster_settings, + ) + diff --git a/submodules/diff-gaussian-rasterization/ext.cpp b/submodules/diff-gaussian-rasterization/ext.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d768779579761238347972a973fbd1603d44235e --- /dev/null +++ b/submodules/diff-gaussian-rasterization/ext.cpp @@ -0,0 +1,19 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#include +#include "rasterize_points.h" + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("rasterize_gaussians", &RasterizeGaussiansCUDA); + m.def("rasterize_gaussians_backward", &RasterizeGaussiansBackwardCUDA); + m.def("mark_visible", &markVisible); +} \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/rasterize_points.cu b/submodules/diff-gaussian-rasterization/rasterize_points.cu new file mode 100644 index 0000000000000000000000000000000000000000..7a9a1bacdc9d76910ec57bcaa7e8e81a573a70cd --- /dev/null +++ b/submodules/diff-gaussian-rasterization/rasterize_points.cu @@ -0,0 +1,217 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "cuda_rasterizer/config.h" +#include "cuda_rasterizer/rasterizer.h" +#include +#include +#include + +std::function resizeFunctional(torch::Tensor& t) { + auto lambda = [&t](size_t N) { + t.resize_({(long long)N}); + return reinterpret_cast(t.contiguous().data_ptr()); + }; + return lambda; +} + +std::tuple +RasterizeGaussiansCUDA( + const torch::Tensor& background, + const torch::Tensor& means3D, + const torch::Tensor& colors, + const torch::Tensor& opacity, + const torch::Tensor& scales, + const torch::Tensor& rotations, + const float scale_modifier, + const torch::Tensor& cov3D_precomp, + const torch::Tensor& viewmatrix, + const torch::Tensor& projmatrix, + const float tan_fovx, + const float tan_fovy, + const int image_height, + const int image_width, + const torch::Tensor& sh, + const int degree, + const torch::Tensor& campos, + const bool prefiltered) +{ + if (means3D.ndimension() != 2 || means3D.size(1) != 3) { + AT_ERROR("means3D must have dimensions (num_points, 3)"); + } + + const int P = means3D.size(0); + const int H = image_height; + const int W = image_width; + + auto int_opts = means3D.options().dtype(torch::kInt32); + auto float_opts = means3D.options().dtype(torch::kFloat32); + + torch::Tensor out_color = torch::full({NUM_CHANNELS, H, W}, 0.0, float_opts); + torch::Tensor out_depth = torch::full({2, H, W}, 0.0, float_opts); + torch::Tensor radii = torch::full({P}, 0, means3D.options().dtype(torch::kInt32)); + + torch::Device device(torch::kCUDA); + torch::TensorOptions options(torch::kByte); + torch::Tensor geomBuffer = torch::empty({0}, options.device(device)); + torch::Tensor binningBuffer = torch::empty({0}, options.device(device)); + torch::Tensor imgBuffer = torch::empty({0}, options.device(device)); + std::function geomFunc = resizeFunctional(geomBuffer); + std::function binningFunc = resizeFunctional(binningBuffer); + std::function imgFunc = resizeFunctional(imgBuffer); + + int rendered = 0; + if(P != 0) + { + int M = 0; + if(sh.size(0) != 0) + { + M = sh.size(1); + } + + rendered = CudaRasterizer::Rasterizer::forward( + geomFunc, + binningFunc, + imgFunc, + P, degree, M, + background.contiguous().data(), + W, H, + means3D.contiguous().data(), + sh.contiguous().data_ptr(), + colors.contiguous().data(), + opacity.contiguous().data(), + scales.contiguous().data_ptr(), + scale_modifier, + rotations.contiguous().data_ptr(), + cov3D_precomp.contiguous().data(), + viewmatrix.contiguous().data(), + projmatrix.contiguous().data(), + campos.contiguous().data(), + tan_fovx, + tan_fovy, + prefiltered, + out_color.contiguous().data(), + out_depth.contiguous().data(), + radii.contiguous().data()); + } + return std::make_tuple(rendered, out_color, out_depth, radii, geomBuffer, binningBuffer, imgBuffer); +} + +std::tuple + RasterizeGaussiansBackwardCUDA( + const torch::Tensor& background, + const torch::Tensor& means3D, + const torch::Tensor& radii, + const torch::Tensor& colors, + const torch::Tensor& scales, + const torch::Tensor& rotations, + const float scale_modifier, + const torch::Tensor& cov3D_precomp, + const torch::Tensor& viewmatrix, + const torch::Tensor& projmatrix, + const float tan_fovx, + const float tan_fovy, + const torch::Tensor& dL_dout_color, + const torch::Tensor& dL_dout_depth, + const torch::Tensor& sh, + const int degree, + const torch::Tensor& campos, + const torch::Tensor& geomBuffer, + const int R, + const torch::Tensor& binningBuffer, + const torch::Tensor& imageBuffer) +{ + const int P = means3D.size(0); + const int H = dL_dout_color.size(1); + const int W = dL_dout_color.size(2); + + int M = 0; + if(sh.size(0) != 0) + { + M = sh.size(1); + } + + torch::Tensor dL_dmeans3D = torch::zeros({P, 3}, means3D.options()); + torch::Tensor dL_dmeans2D = torch::zeros({P, 3}, means3D.options()); + torch::Tensor dL_dcolors = torch::zeros({P, NUM_CHANNELS}, means3D.options()); + torch::Tensor dL_dconic = torch::zeros({P, 2, 2}, means3D.options()); + torch::Tensor dL_dopacity = torch::zeros({P, 1}, means3D.options()); + torch::Tensor dL_dcov3D = torch::zeros({P, 6}, means3D.options()); + torch::Tensor dL_dsh = torch::zeros({P, M, 3}, means3D.options()); + torch::Tensor dL_dscales = torch::zeros({P, 3}, means3D.options()); + torch::Tensor dL_drotations = torch::zeros({P, 4}, means3D.options()); + + if(P != 0) + { + CudaRasterizer::Rasterizer::backward(P, degree, M, R, + background.contiguous().data(), + W, H, + means3D.contiguous().data(), + sh.contiguous().data(), + colors.contiguous().data(), + scales.data_ptr(), + scale_modifier, + rotations.data_ptr(), + cov3D_precomp.contiguous().data(), + viewmatrix.contiguous().data(), + projmatrix.contiguous().data(), + campos.contiguous().data(), + tan_fovx, + tan_fovy, + radii.contiguous().data(), + reinterpret_cast(geomBuffer.contiguous().data_ptr()), + reinterpret_cast(binningBuffer.contiguous().data_ptr()), + reinterpret_cast(imageBuffer.contiguous().data_ptr()), + dL_dout_color.contiguous().data(), + dL_dout_depth.contiguous().data(), + dL_dmeans2D.contiguous().data(), + dL_dconic.contiguous().data(), + dL_dopacity.contiguous().data(), + dL_dcolors.contiguous().data(), + dL_dmeans3D.contiguous().data(), + dL_dcov3D.contiguous().data(), + dL_dsh.contiguous().data(), + dL_dscales.contiguous().data(), + dL_drotations.contiguous().data()); + } + + return std::make_tuple(dL_dmeans2D, dL_dcolors, dL_dopacity, dL_dmeans3D, dL_dcov3D, dL_dsh, dL_dscales, dL_drotations); +} + +torch::Tensor markVisible( + torch::Tensor& means3D, + torch::Tensor& viewmatrix, + torch::Tensor& projmatrix) +{ + const int P = means3D.size(0); + + torch::Tensor present = torch::full({P}, false, means3D.options().dtype(at::kBool)); + + if(P != 0) + { + CudaRasterizer::Rasterizer::markVisible(P, + means3D.contiguous().data(), + viewmatrix.contiguous().data(), + projmatrix.contiguous().data(), + present.contiguous().data()); + } + + return present; +} \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/rasterize_points.h b/submodules/diff-gaussian-rasterization/rasterize_points.h new file mode 100644 index 0000000000000000000000000000000000000000..446d85c5f72e2d9a1418324fe2c337471b2978a5 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/rasterize_points.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2023, Inria + * GRAPHDECO research group, https://team.inria.fr/graphdeco + * All rights reserved. + * + * This software is free for non-commercial, research and evaluation use + * under the terms of the LICENSE.md file. + * + * For inquiries contact george.drettakis@inria.fr + */ + +#pragma once +#include +#include +#include +#include + +std::tuple +RasterizeGaussiansCUDA( + const torch::Tensor& background, + const torch::Tensor& means3D, + const torch::Tensor& colors, + const torch::Tensor& opacity, + const torch::Tensor& scales, + const torch::Tensor& rotations, + const float scale_modifier, + const torch::Tensor& cov3D_precomp, + const torch::Tensor& viewmatrix, + const torch::Tensor& projmatrix, + const float tan_fovx, + const float tan_fovy, + const int image_height, + const int image_width, + const torch::Tensor& sh, + const int degree, + const torch::Tensor& campos, + const bool prefiltered); + +std::tuple + RasterizeGaussiansBackwardCUDA( + const torch::Tensor& background, + const torch::Tensor& means3D, + const torch::Tensor& radii, + const torch::Tensor& colors, + const torch::Tensor& scales, + const torch::Tensor& rotations, + const float scale_modifier, + const torch::Tensor& cov3D_precomp, + const torch::Tensor& viewmatrix, + const torch::Tensor& projmatrix, + const float tan_fovx, + const float tan_fovy, + const torch::Tensor& dL_dout_color, + const torch::Tensor& dL_dout_depth, + const torch::Tensor& sh, + const int degree, + const torch::Tensor& campos, + const torch::Tensor& geomBuffer, + const int R, + const torch::Tensor& binningBuffer, + const torch::Tensor& imageBuffer); + +torch::Tensor markVisible( + torch::Tensor& means3D, + torch::Tensor& viewmatrix, + torch::Tensor& projmatrix); \ No newline at end of file diff --git a/submodules/diff-gaussian-rasterization/setup.py b/submodules/diff-gaussian-rasterization/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..bb7220d2934d006ea756e35ecb0f391403b43d64 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/setup.py @@ -0,0 +1,34 @@ +# +# Copyright (C) 2023, Inria +# GRAPHDECO research group, https://team.inria.fr/graphdeco +# All rights reserved. +# +# This software is free for non-commercial, research and evaluation use +# under the terms of the LICENSE.md file. +# +# For inquiries contact george.drettakis@inria.fr +# + +from setuptools import setup +from torch.utils.cpp_extension import CUDAExtension, BuildExtension +import os +os.path.dirname(os.path.abspath(__file__)) + +setup( + name="diff_gaussian_rasterization", + packages=['diff_gaussian_rasterization'], + ext_modules=[ + CUDAExtension( + name="diff_gaussian_rasterization._C", + sources=[ + "cuda_rasterizer/rasterizer_impl.cu", + "cuda_rasterizer/forward.cu", + "cuda_rasterizer/backward.cu", + "rasterize_points.cu", + "ext.cpp"], + extra_compile_args={"nvcc": ["-I" + os.path.join(os.path.dirname(os.path.abspath(__file__)), "third_party/glm/")]}) + ], + cmdclass={ + 'build_ext': BuildExtension + } +) diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/.appveyor.yml b/submodules/diff-gaussian-rasterization/third_party/glm/.appveyor.yml new file mode 100644 index 0000000000000000000000000000000000000000..5ce6028184b763af011bd0e325abf45a3370e182 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/.appveyor.yml @@ -0,0 +1,92 @@ +shallow_clone: true + +platform: + - x86 + - x64 + +configuration: + - Debug + - Release + +image: + - Visual Studio 2013 + - Visual Studio 2015 + - Visual Studio 2017 + - Visual Studio 2019 + +environment: + matrix: + - GLM_ARGUMENTS: -DGLM_TEST_FORCE_PURE=ON + - GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON + - GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON + - GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_14=ON + - GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_17=ON + +matrix: + exclude: + - image: Visual Studio 2013 + GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON + - image: Visual Studio 2013 + GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_14=ON + - image: Visual Studio 2013 + GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_17=ON + - image: Visual Studio 2013 + configuration: Debug + - image: Visual Studio 2015 + GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON + - image: Visual Studio 2015 + GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_14=ON + - image: Visual Studio 2015 + GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_17=ON + - image: Visual Studio 2015 + platform: x86 + - image: Visual Studio 2015 + configuration: Debug + - image: Visual Studio 2017 + platform: x86 + - image: Visual Studio 2017 + configuration: Debug + - image: Visual Studio 2019 + platform: x64 + +branches: + only: + - master + +before_build: + - ps: | + mkdir build + cd build + + if ("$env:APPVEYOR_JOB_NAME" -match "Image: Visual Studio 2013") { + $env:generator="Visual Studio 12 2013" + } + if ("$env:APPVEYOR_JOB_NAME" -match "Image: Visual Studio 2015") { + $env:generator="Visual Studio 14 2015" + } + if ("$env:APPVEYOR_JOB_NAME" -match "Image: Visual Studio 2017") { + $env:generator="Visual Studio 15 2017" + } + if ("$env:APPVEYOR_JOB_NAME" -match "Image: Visual Studio 2019") { + $env:generator="Visual Studio 16 2019" + } + if ($env:PLATFORM -eq "x64") { + $env:generator="$env:generator Win64" + } + echo generator="$env:generator" + cmake .. -G "$env:generator" -DCMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER/install" -DGLM_QUIET=ON -DGLM_TEST_ENABLE=ON "$env:GLM_ARGUMENTS" + +build_script: + - cmake --build . --parallel --config %CONFIGURATION% -- /m /v:minimal + - cmake --build . --target install --parallel --config %CONFIGURATION% -- /m /v:minimal + +test_script: + - ctest --parallel 4 --verbose -C %CONFIGURATION% + - cd .. + - ps: | + mkdir build_test_cmake + cd build_test_cmake + cmake ..\test\cmake\ -G "$env:generator" -DCMAKE_PREFIX_PATH="$env:APPVEYOR_BUILD_FOLDER/install" + - cmake --build . --parallel --config %CONFIGURATION% -- /m /v:minimal + +deploy: off diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/.travis.yml b/submodules/diff-gaussian-rasterization/third_party/glm/.travis.yml new file mode 100644 index 0000000000000000000000000000000000000000..1660ec0c59d213b94ff7925503b2caff73567aeb --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/.travis.yml @@ -0,0 +1,388 @@ +language: cpp + +branches: + only: + - master + - stable + +jobs: + include: + - name: "Xcode 7.3 C++98 pure release" + os: osx + osx_image: xcode7.3 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_FORCE_PURE=ON" + + - name: "Xcode 7.3 C++98 sse2 release" + os: osx + osx_image: xcode7.3 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE2=ON" + + - name: "Xcode 7.3 C++98 ms release" + os: osx + osx_image: xcode7.3 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON" + + - name: "XCode 7.3 C++11 pure release" + os: osx + osx_image: xcode7.3 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_FORCE_PURE=ON" + + - name: "XCode 7.3 C++11 sse2 release" + os: osx + osx_image: xcode7.3 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE3=ON" + + - name: "XCode 10.3 C++11 sse2 release" + os: osx + osx_image: xcode10.3 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE3=ON" + + - name: "XCode 12.2 C++11 sse2 release" + os: osx + osx_image: xcode12.2 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE3=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "XCode 12.2 C++11 sse2 debug" + os: osx + osx_image: xcode12.2 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE3=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "XCode 12.2 C++11 avx debug" + os: osx + osx_image: xcode12.2 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_AVX=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "XCode 12.2 C++14 avx debug" + os: osx + osx_image: xcode12.2 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_AVX=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "XCode 12.2 C++14 pure debug" + os: osx + osx_image: xcode12.2 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "XCode 12.2 C++17 pure debug" + os: osx + osx_image: xcode12.2 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "XCode 12.2 C++17 sse2 debug" + os: osx + osx_image: xcode12.2 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE2=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "XCode 12.2 C++17 sse2 release" + os: osx + osx_image: xcode12.2 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE2=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "XCode 12.2 C++17 avx release" + os: osx + osx_image: xcode12.2 + env: + - MATRIX_EVAL="" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_AVX=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 4.9 C++98 pure release" + os: linux + dist: Xenial + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-4.9 + env: + - MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 4.9 C++98 pure debug" + os: linux + dist: Xenial + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-4.9 + env: + - MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 4.9 C++98 ms debug" + os: linux + dist: Xenial + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-4.9 + env: + - MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 4.9 C++11 ms debug" + os: linux + dist: Xenial + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-4.9 + env: + - MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 4.9 C++11 pure debug" + os: linux + dist: Xenial + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-4.9 + env: + - MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 6 C++14 pure debug" + os: linux + dist: bionic + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-6 + env: + - MATRIX_EVAL="CC=gcc-6 && CXX=g++-6" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 6 C++14 ms debug" + os: linux + dist: bionic + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-6 + env: + - MATRIX_EVAL="CC=gcc-6 && CXX=g++-6" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 7 C++17 ms debug" + os: linux + dist: bionic + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-7 + env: + - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 7 C++17 pure debug" + os: linux + dist: bionic + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-7 + env: + - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 10 C++17 pure debug" + os: linux + dist: bionic + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-10 + env: + - MATRIX_EVAL="CC=gcc-10 && CXX=g++-10" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "GCC 10 C++17 pure release" + os: linux + dist: bionic + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - g++-10 + env: + - MATRIX_EVAL="CC=gcc-10 && CXX=g++-10" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "Clang C++14 pure release" + os: linux + dist: Xenial + env: + - MATRIX_EVAL="CC=clang && CXX=clang++" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "Clang C++14 pure debug" + os: linux + dist: Xenial + env: + - MATRIX_EVAL="CC=clang && CXX=clang++" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "Clang C++14 sse2 debug" + os: linux + dist: Xenial + env: + - MATRIX_EVAL="CC=clang && CXX=clang++" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE2=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "Clang C++14 sse2 debug" + os: linux + dist: focal + env: + - MATRIX_EVAL="CC=clang && CXX=clang++" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE2=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "Clang C++17 sse2 debug" + os: linux + dist: focal + env: + - MATRIX_EVAL="CC=clang && CXX=clang++" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE2=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "Clang C++17 avx2 debug" + os: linux + dist: focal + env: + - MATRIX_EVAL="CC=clang && CXX=clang++" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_AVX2=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "Clang C++17 pure debug" + os: linux + dist: focal + env: + - MATRIX_EVAL="CC=clang && CXX=clang++" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + + - name: "Clang C++17 pure release" + os: linux + dist: focal + env: + - MATRIX_EVAL="CC=clang && CXX=clang++" + - CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_FORCE_PURE=ON" + - CTEST_ENV="--parallel 4 --output-on-failure" + - CMAKE_ENV="--parallel" + +before_script: + - cmake --version + - eval "${MATRIX_EVAL}" + +script: + - ${CC} --version + - mkdir ./build + - cd ./build + - cmake -DCMAKE_INSTALL_PREFIX=$TRAVIS_BUILD_DIR/install -DCMAKE_CXX_COMPILER=$COMPILER ${CMAKE_BUILD_ENV} .. + - cmake --build . ${CMAKE_ENV} + - ctest ${CTEST_ENV} + - cmake --build . --target install ${CMAKE_ENV} + - cd $TRAVIS_BUILD_DIR + - mkdir ./build_test_cmake + - cd ./build_test_cmake + - cmake -DCMAKE_CXX_COMPILER=$COMPILER $TRAVIS_BUILD_DIR/test/cmake/ -DCMAKE_PREFIX_PATH=$TRAVIS_BUILD_DIR/install + - cmake --build . + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/CMakeLists.txt b/submodules/diff-gaussian-rasterization/third_party/glm/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..b7641a28699119f1a87e563c8dc1b449dd6e6b8f --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/CMakeLists.txt @@ -0,0 +1,45 @@ +cmake_minimum_required(VERSION 3.2 FATAL_ERROR) +cmake_policy(VERSION 3.2) + + +file(READ "glm/detail/setup.hpp" GLM_SETUP_FILE) +string(REGEX MATCH "#define[ ]+GLM_VERSION_MAJOR[ ]+([0-9]+)" _ ${GLM_SETUP_FILE}) +set(GLM_VERSION_MAJOR "${CMAKE_MATCH_1}") +string(REGEX MATCH "#define[ ]+GLM_VERSION_MINOR[ ]+([0-9]+)" _ ${GLM_SETUP_FILE}) +set(GLM_VERSION_MINOR "${CMAKE_MATCH_1}") +string(REGEX MATCH "#define[ ]+GLM_VERSION_PATCH[ ]+([0-9]+)" _ ${GLM_SETUP_FILE}) +set(GLM_VERSION_PATCH "${CMAKE_MATCH_1}") +string(REGEX MATCH "#define[ ]+GLM_VERSION_REVISION[ ]+([0-9]+)" _ ${GLM_SETUP_FILE}) +set(GLM_VERSION_REVISION "${CMAKE_MATCH_1}") + +set(GLM_VERSION ${GLM_VERSION_MAJOR}.${GLM_VERSION_MINOR}.${GLM_VERSION_PATCH}.${GLM_VERSION_REVISION}) +project(glm VERSION ${GLM_VERSION} LANGUAGES CXX) +message(STATUS "GLM: Version " ${GLM_VERSION}) + +add_subdirectory(glm) +add_library(glm::glm ALIAS glm) + +if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}) + + include(CPack) + install(DIRECTORY glm DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} PATTERN "CMakeLists.txt" EXCLUDE) + install(EXPORT glm FILE glmConfig.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/glm NAMESPACE glm::) + include(CMakePackageConfigHelpers) + write_basic_package_version_file("glmConfigVersion.cmake" COMPATIBILITY AnyNewerVersion) + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/glmConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/glm) + + include(CTest) + if(BUILD_TESTING) + add_subdirectory(test) + endif() + +endif(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}) + +if (NOT TARGET uninstall) +configure_file(cmake/cmake_uninstall.cmake.in + cmake_uninstall.cmake IMMEDIATE @ONLY) + +add_custom_target(uninstall + "${CMAKE_COMMAND}" -P + "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake") +endif() diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/cmake/cmake_uninstall.cmake.in b/submodules/diff-gaussian-rasterization/third_party/glm/cmake/cmake_uninstall.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..c2d34d4796d9e2abd8aa0e7aca99a558a1e0366b --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/cmake/cmake_uninstall.cmake.in @@ -0,0 +1,21 @@ +if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") + message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt") +endif() + +file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files) +string(REGEX REPLACE "\n" ";" files "${files}") +foreach(file ${files}) + message(STATUS "Uninstalling $ENV{DESTDIR}${file}") + if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + exec_program( + "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" + OUTPUT_VARIABLE rm_out + RETURN_VALUE rm_retval + ) + if(NOT "${rm_retval}" STREQUAL 0) + message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") + endif() + else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + message(STATUS "File $ENV{DESTDIR}${file} does not exist.") + endif() +endforeach() diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/copying.txt b/submodules/diff-gaussian-rasterization/third_party/glm/copying.txt new file mode 100644 index 0000000000000000000000000000000000000000..779c32fb9afef1180798d46f08b4373e427ac693 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/copying.txt @@ -0,0 +1,54 @@ +================================================================================ +OpenGL Mathematics (GLM) +-------------------------------------------------------------------------------- +GLM is licensed under The Happy Bunny License or MIT License + +================================================================================ +The Happy Bunny License (Modified MIT License) +-------------------------------------------------------------------------------- +Copyright (c) 2005 - G-Truc Creation + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +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 Software. + +Restrictions: + By making use of the Software for military purposes, you choose to make a + Bunny unhappy. + +THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +================================================================================ +The MIT License +-------------------------------------------------------------------------------- +Copyright (c) 2005 - G-Truc Creation + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +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 Software. + +THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00001_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00001_source.html new file mode 100644 index 0000000000000000000000000000000000000000..36d74cebfc73c0f48f1afa7025923f58257a6c14 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00001_source.html @@ -0,0 +1,493 @@ + + + + + + +0.9.9 API documentation: _features.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
_features.hpp
+
+
+
1 #pragma once
+
2 
+
3 // #define GLM_CXX98_EXCEPTIONS
+
4 // #define GLM_CXX98_RTTI
+
5 
+
6 // #define GLM_CXX11_RVALUE_REFERENCES
+
7 // Rvalue references - GCC 4.3
+
8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html
+
9 
+
10 // GLM_CXX11_TRAILING_RETURN
+
11 // Rvalue references for *this - GCC not supported
+
12 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm
+
13 
+
14 // GLM_CXX11_NONSTATIC_MEMBER_INIT
+
15 // Initialization of class objects by rvalues - GCC any
+
16 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html
+
17 
+
18 // GLM_CXX11_NONSTATIC_MEMBER_INIT
+
19 // Non-static data member initializers - GCC 4.7
+
20 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm
+
21 
+
22 // #define GLM_CXX11_VARIADIC_TEMPLATE
+
23 // Variadic templates - GCC 4.3
+
24 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf
+
25 
+
26 //
+
27 // Extending variadic template template parameters - GCC 4.4
+
28 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
+
29 
+
30 // #define GLM_CXX11_GENERALIZED_INITIALIZERS
+
31 // Initializer lists - GCC 4.4
+
32 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
+
33 
+
34 // #define GLM_CXX11_STATIC_ASSERT
+
35 // Static assertions - GCC 4.3
+
36 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html
+
37 
+
38 // #define GLM_CXX11_AUTO_TYPE
+
39 // auto-typed variables - GCC 4.4
+
40 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf
+
41 
+
42 // #define GLM_CXX11_AUTO_TYPE
+
43 // Multi-declarator auto - GCC 4.4
+
44 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf
+
45 
+
46 // #define GLM_CXX11_AUTO_TYPE
+
47 // Removal of auto as a storage-class specifier - GCC 4.4
+
48 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm
+
49 
+
50 // #define GLM_CXX11_AUTO_TYPE
+
51 // New function declarator syntax - GCC 4.4
+
52 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm
+
53 
+
54 // #define GLM_CXX11_LAMBDAS
+
55 // New wording for C++0x lambdas - GCC 4.5
+
56 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf
+
57 
+
58 // #define GLM_CXX11_DECLTYPE
+
59 // Declared type of an expression - GCC 4.3
+
60 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf
+
61 
+
62 //
+
63 // Right angle brackets - GCC 4.3
+
64 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html
+
65 
+
66 //
+
67 // Default template arguments for function templates DR226 GCC 4.3
+
68 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226
+
69 
+
70 //
+
71 // Solving the SFINAE problem for expressions DR339 GCC 4.4
+
72 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html
+
73 
+
74 // #define GLM_CXX11_ALIAS_TEMPLATE
+
75 // Template aliases N2258 GCC 4.7
+
76 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
+
77 
+
78 //
+
79 // Extern templates N1987 Yes
+
80 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm
+
81 
+
82 // #define GLM_CXX11_NULLPTR
+
83 // Null pointer constant N2431 GCC 4.6
+
84 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
+
85 
+
86 // #define GLM_CXX11_STRONG_ENUMS
+
87 // Strongly-typed enums N2347 GCC 4.4
+
88 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf
+
89 
+
90 //
+
91 // Forward declarations for enums N2764 GCC 4.6
+
92 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf
+
93 
+
94 //
+
95 // Generalized attributes N2761 GCC 4.8
+
96 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf
+
97 
+
98 //
+
99 // Generalized constant expressions N2235 GCC 4.6
+
100 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
+
101 
+
102 //
+
103 // Alignment support N2341 GCC 4.8
+
104 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
+
105 
+
106 // #define GLM_CXX11_DELEGATING_CONSTRUCTORS
+
107 // Delegating constructors N1986 GCC 4.7
+
108 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
+
109 
+
110 //
+
111 // Inheriting constructors N2540 GCC 4.8
+
112 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm
+
113 
+
114 // #define GLM_CXX11_EXPLICIT_CONVERSIONS
+
115 // Explicit conversion operators N2437 GCC 4.5
+
116 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
+
117 
+
118 //
+
119 // New character types N2249 GCC 4.4
+
120 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html
+
121 
+
122 //
+
123 // Unicode string literals N2442 GCC 4.5
+
124 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
125 
+
126 //
+
127 // Raw string literals N2442 GCC 4.5
+
128 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
129 
+
130 //
+
131 // Universal character name literals N2170 GCC 4.5
+
132 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html
+
133 
+
134 // #define GLM_CXX11_USER_LITERALS
+
135 // User-defined literals N2765 GCC 4.7
+
136 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf
+
137 
+
138 //
+
139 // Standard Layout Types N2342 GCC 4.5
+
140 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm
+
141 
+
142 // #define GLM_CXX11_DEFAULTED_FUNCTIONS
+
143 // #define GLM_CXX11_DELETED_FUNCTIONS
+
144 // Defaulted and deleted functions N2346 GCC 4.4
+
145 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm
+
146 
+
147 //
+
148 // Extended friend declarations N1791 GCC 4.7
+
149 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
+
150 
+
151 //
+
152 // Extending sizeof N2253 GCC 4.4
+
153 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html
+
154 
+
155 // #define GLM_CXX11_INLINE_NAMESPACES
+
156 // Inline namespaces N2535 GCC 4.4
+
157 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm
+
158 
+
159 // #define GLM_CXX11_UNRESTRICTED_UNIONS
+
160 // Unrestricted unions N2544 GCC 4.6
+
161 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+
162 
+
163 // #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+
164 // Local and unnamed types as template arguments N2657 GCC 4.5
+
165 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm
+
166 
+
167 // #define GLM_CXX11_RANGE_FOR
+
168 // Range-based for N2930 GCC 4.6
+
169 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html
+
170 
+
171 // #define GLM_CXX11_OVERRIDE_CONTROL
+
172 // Explicit virtual overrides N2928 N3206 N3272 GCC 4.7
+
173 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm
+
174 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm
+
175 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm
+
176 
+
177 //
+
178 // Minimal support for garbage collection and reachability-based leak detection N2670 No
+
179 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm
+
180 
+
181 // #define GLM_CXX11_NOEXCEPT
+
182 // Allowing move constructors to throw [noexcept] N3050 GCC 4.6 (core language only)
+
183 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html
+
184 
+
185 //
+
186 // Defining move special member functions N3053 GCC 4.6
+
187 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html
+
188 
+
189 //
+
190 // Sequence points N2239 Yes
+
191 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
192 
+
193 //
+
194 // Atomic operations N2427 GCC 4.4
+
195 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
196 
+
197 //
+
198 // Strong Compare and Exchange N2748 GCC 4.5
+
199 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
+
200 
+
201 //
+
202 // Bidirectional Fences N2752 GCC 4.8
+
203 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm
+
204 
+
205 //
+
206 // Memory model N2429 GCC 4.8
+
207 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm
+
208 
+
209 //
+
210 // Data-dependency ordering: atomics and memory model N2664 GCC 4.4
+
211 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm
+
212 
+
213 //
+
214 // Propagating exceptions N2179 GCC 4.4
+
215 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html
+
216 
+
217 //
+
218 // Abandoning a process and at_quick_exit N2440 GCC 4.8
+
219 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm
+
220 
+
221 //
+
222 // Allow atomics use in signal handlers N2547 Yes
+
223 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm
+
224 
+
225 //
+
226 // Thread-local storage N2659 GCC 4.8
+
227 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm
+
228 
+
229 //
+
230 // Dynamic initialization and destruction with concurrency N2660 GCC 4.3
+
231 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm
+
232 
+
233 //
+
234 // __func__ predefined identifier N2340 GCC 4.3
+
235 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm
+
236 
+
237 //
+
238 // C99 preprocessor N1653 GCC 4.3
+
239 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
+
240 
+
241 //
+
242 // long long N1811 GCC 4.3
+
243 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf
+
244 
+
245 //
+
246 // Extended integral types N1988 Yes
+
247 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf
+
248 
+
249 #if(GLM_COMPILER & GLM_COMPILER_GCC)
+
250 
+
251 # define GLM_CXX11_STATIC_ASSERT
+
252 
+
253 #elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+
254 # if(__has_feature(cxx_exceptions))
+
255 # define GLM_CXX98_EXCEPTIONS
+
256 # endif
+
257 
+
258 # if(__has_feature(cxx_rtti))
+
259 # define GLM_CXX98_RTTI
+
260 # endif
+
261 
+
262 # if(__has_feature(cxx_access_control_sfinae))
+
263 # define GLM_CXX11_ACCESS_CONTROL_SFINAE
+
264 # endif
+
265 
+
266 # if(__has_feature(cxx_alias_templates))
+
267 # define GLM_CXX11_ALIAS_TEMPLATE
+
268 # endif
+
269 
+
270 # if(__has_feature(cxx_alignas))
+
271 # define GLM_CXX11_ALIGNAS
+
272 # endif
+
273 
+
274 # if(__has_feature(cxx_attributes))
+
275 # define GLM_CXX11_ATTRIBUTES
+
276 # endif
+
277 
+
278 # if(__has_feature(cxx_constexpr))
+
279 # define GLM_CXX11_CONSTEXPR
+
280 # endif
+
281 
+
282 # if(__has_feature(cxx_decltype))
+
283 # define GLM_CXX11_DECLTYPE
+
284 # endif
+
285 
+
286 # if(__has_feature(cxx_default_function_template_args))
+
287 # define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS
+
288 # endif
+
289 
+
290 # if(__has_feature(cxx_defaulted_functions))
+
291 # define GLM_CXX11_DEFAULTED_FUNCTIONS
+
292 # endif
+
293 
+
294 # if(__has_feature(cxx_delegating_constructors))
+
295 # define GLM_CXX11_DELEGATING_CONSTRUCTORS
+
296 # endif
+
297 
+
298 # if(__has_feature(cxx_deleted_functions))
+
299 # define GLM_CXX11_DELETED_FUNCTIONS
+
300 # endif
+
301 
+
302 # if(__has_feature(cxx_explicit_conversions))
+
303 # define GLM_CXX11_EXPLICIT_CONVERSIONS
+
304 # endif
+
305 
+
306 # if(__has_feature(cxx_generalized_initializers))
+
307 # define GLM_CXX11_GENERALIZED_INITIALIZERS
+
308 # endif
+
309 
+
310 # if(__has_feature(cxx_implicit_moves))
+
311 # define GLM_CXX11_IMPLICIT_MOVES
+
312 # endif
+
313 
+
314 # if(__has_feature(cxx_inheriting_constructors))
+
315 # define GLM_CXX11_INHERITING_CONSTRUCTORS
+
316 # endif
+
317 
+
318 # if(__has_feature(cxx_inline_namespaces))
+
319 # define GLM_CXX11_INLINE_NAMESPACES
+
320 # endif
+
321 
+
322 # if(__has_feature(cxx_lambdas))
+
323 # define GLM_CXX11_LAMBDAS
+
324 # endif
+
325 
+
326 # if(__has_feature(cxx_local_type_template_args))
+
327 # define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+
328 # endif
+
329 
+
330 # if(__has_feature(cxx_noexcept))
+
331 # define GLM_CXX11_NOEXCEPT
+
332 # endif
+
333 
+
334 # if(__has_feature(cxx_nonstatic_member_init))
+
335 # define GLM_CXX11_NONSTATIC_MEMBER_INIT
+
336 # endif
+
337 
+
338 # if(__has_feature(cxx_nullptr))
+
339 # define GLM_CXX11_NULLPTR
+
340 # endif
+
341 
+
342 # if(__has_feature(cxx_override_control))
+
343 # define GLM_CXX11_OVERRIDE_CONTROL
+
344 # endif
+
345 
+
346 # if(__has_feature(cxx_reference_qualified_functions))
+
347 # define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS
+
348 # endif
+
349 
+
350 # if(__has_feature(cxx_range_for))
+
351 # define GLM_CXX11_RANGE_FOR
+
352 # endif
+
353 
+
354 # if(__has_feature(cxx_raw_string_literals))
+
355 # define GLM_CXX11_RAW_STRING_LITERALS
+
356 # endif
+
357 
+
358 # if(__has_feature(cxx_rvalue_references))
+
359 # define GLM_CXX11_RVALUE_REFERENCES
+
360 # endif
+
361 
+
362 # if(__has_feature(cxx_static_assert))
+
363 # define GLM_CXX11_STATIC_ASSERT
+
364 # endif
+
365 
+
366 # if(__has_feature(cxx_auto_type))
+
367 # define GLM_CXX11_AUTO_TYPE
+
368 # endif
+
369 
+
370 # if(__has_feature(cxx_strong_enums))
+
371 # define GLM_CXX11_STRONG_ENUMS
+
372 # endif
+
373 
+
374 # if(__has_feature(cxx_trailing_return))
+
375 # define GLM_CXX11_TRAILING_RETURN
+
376 # endif
+
377 
+
378 # if(__has_feature(cxx_unicode_literals))
+
379 # define GLM_CXX11_UNICODE_LITERALS
+
380 # endif
+
381 
+
382 # if(__has_feature(cxx_unrestricted_unions))
+
383 # define GLM_CXX11_UNRESTRICTED_UNIONS
+
384 # endif
+
385 
+
386 # if(__has_feature(cxx_user_literals))
+
387 # define GLM_CXX11_USER_LITERALS
+
388 # endif
+
389 
+
390 # if(__has_feature(cxx_variadic_templates))
+
391 # define GLM_CXX11_VARIADIC_TEMPLATES
+
392 # endif
+
393 
+
394 #endif//(GLM_COMPILER & GLM_COMPILER_CLANG)
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00002_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00002_source.html new file mode 100644 index 0000000000000000000000000000000000000000..b38783549b04b8e60129273f6e6c2c926bc778c9 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00002_source.html @@ -0,0 +1,121 @@ + + + + + + +0.9.9 API documentation: _fixes.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
_fixes.hpp
+
+
+
1 #include <cmath>
+
2 
+
4 #ifdef max
+
5 #undef max
+
6 #endif
+
7 
+
9 #ifdef min
+
10 #undef min
+
11 #endif
+
12 
+
14 #ifdef isnan
+
15 #undef isnan
+
16 #endif
+
17 
+
19 #ifdef isinf
+
20 #undef isinf
+
21 #endif
+
22 
+
24 #ifdef log2
+
25 #undef log2
+
26 #endif
+
27 
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00003_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00003_source.html new file mode 100644 index 0000000000000000000000000000000000000000..4e90ac88bb08d7430ad6972a81c3c8f26b49319c --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00003_source.html @@ -0,0 +1,182 @@ + + + + + + +0.9.9 API documentation: _noise.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
_noise.hpp
+
+
+
1 #pragma once
+
2 
+
3 #include "../common.hpp"
+
4 
+
5 namespace glm{
+
6 namespace detail
+
7 {
+
8  template<typename T>
+
9  GLM_FUNC_QUALIFIER T mod289(T const& x)
+
10  {
+
11  return x - floor(x * (static_cast<T>(1.0) / static_cast<T>(289.0))) * static_cast<T>(289.0);
+
12  }
+
13 
+
14  template<typename T>
+
15  GLM_FUNC_QUALIFIER T permute(T const& x)
+
16  {
+
17  return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+
18  }
+
19 
+
20  template<typename T, qualifier Q>
+
21  GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x)
+
22  {
+
23  return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+
24  }
+
25 
+
26  template<typename T, qualifier Q>
+
27  GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x)
+
28  {
+
29  return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+
30  }
+
31 
+
32  template<typename T, qualifier Q>
+
33  GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x)
+
34  {
+
35  return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+
36  }
+
37 
+
38  template<typename T>
+
39  GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r)
+
40  {
+
41  return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+
42  }
+
43 
+
44  template<typename T, qualifier Q>
+
45  GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r)
+
46  {
+
47  return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+
48  }
+
49 
+
50  template<typename T, qualifier Q>
+
51  GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r)
+
52  {
+
53  return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+
54  }
+
55 
+
56  template<typename T, qualifier Q>
+
57  GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r)
+
58  {
+
59  return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+
60  }
+
61 
+
62  template<typename T, qualifier Q>
+
63  GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t)
+
64  {
+
65  return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+
66  }
+
67 
+
68  template<typename T, qualifier Q>
+
69  GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t)
+
70  {
+
71  return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+
72  }
+
73 
+
74  template<typename T, qualifier Q>
+
75  GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t)
+
76  {
+
77  return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+
78  }
+
79 }//namespace detail
+
80 }//namespace glm
+
81 
+
GLM_FUNC_DECL vec< L, T, Q > floor(vec< L, T, Q > const &x)
Returns a value equal to the nearest integer that is less then or equal to x.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00004_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00004_source.html new file mode 100644 index 0000000000000000000000000000000000000000..a2a5ebb623fe88841ada1abf10b81e7714ed72ce --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00004_source.html @@ -0,0 +1,905 @@ + + + + + + +0.9.9 API documentation: _swizzle.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
_swizzle.hpp
+
+
+
1 #pragma once
+
2 
+
3 namespace glm{
+
4 namespace detail
+
5 {
+
6  // Internal class for implementing swizzle operators
+
7  template<typename T, int N>
+
8  struct _swizzle_base0
+
9  {
+
10  protected:
+
11  GLM_FUNC_QUALIFIER T& elem(size_t i){ return (reinterpret_cast<T*>(_buffer))[i]; }
+
12  GLM_FUNC_QUALIFIER T const& elem(size_t i) const{ return (reinterpret_cast<const T*>(_buffer))[i]; }
+
13 
+
14  // Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
+
15  // The size 1 buffer is assumed to aligned to the actual members so that the
+
16  // elem()
+
17  char _buffer[1];
+
18  };
+
19 
+
20  template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, bool Aligned>
+
21  struct _swizzle_base1 : public _swizzle_base0<T, N>
+
22  {
+
23  };
+
24 
+
25  template<typename T, qualifier Q, int E0, int E1, bool Aligned>
+
26  struct _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2>
+
27  {
+
28  GLM_FUNC_QUALIFIER vec<2, T, Q> operator ()() const { return vec<2, T, Q>(this->elem(E0), this->elem(E1)); }
+
29  };
+
30 
+
31  template<typename T, qualifier Q, int E0, int E1, int E2, bool Aligned>
+
32  struct _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> : public _swizzle_base0<T, 3>
+
33  {
+
34  GLM_FUNC_QUALIFIER vec<3, T, Q> operator ()() const { return vec<3, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2)); }
+
35  };
+
36 
+
37  template<typename T, qualifier Q, int E0, int E1, int E2, int E3, bool Aligned>
+
38  struct _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> : public _swizzle_base0<T, 4>
+
39  {
+
40  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)); }
+
41  };
+
42 
+
43  // Internal class for implementing swizzle operators
+
44  /*
+
45  Template parameters:
+
46 
+
47  T = type of scalar values (e.g. float, double)
+
48  N = number of components in the vector (e.g. 3)
+
49  E0...3 = what index the n-th element of this swizzle refers to in the unswizzled vec
+
50 
+
51  DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
+
52  containing duplicate elements so that they cannot be used as r-values).
+
53  */
+
54  template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
+
55  struct _swizzle_base2 : public _swizzle_base1<N, T, Q, E0,E1,E2,E3, detail::is_aligned<Q>::value>
+
56  {
+
57  struct op_equal
+
58  {
+
59  GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e = t; }
+
60  };
+
61 
+
62  struct op_minus
+
63  {
+
64  GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e -= t; }
+
65  };
+
66 
+
67  struct op_plus
+
68  {
+
69  GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e += t; }
+
70  };
+
71 
+
72  struct op_mul
+
73  {
+
74  GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e *= t; }
+
75  };
+
76 
+
77  struct op_div
+
78  {
+
79  GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e /= t; }
+
80  };
+
81 
+
82  public:
+
83  GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t)
+
84  {
+
85  for (int i = 0; i < N; ++i)
+
86  (*this)[i] = t;
+
87  return *this;
+
88  }
+
89 
+
90  GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec<N, T, Q> const& that)
+
91  {
+
92  _apply_op(that, op_equal());
+
93  return *this;
+
94  }
+
95 
+
96  GLM_FUNC_QUALIFIER void operator -= (vec<N, T, Q> const& that)
+
97  {
+
98  _apply_op(that, op_minus());
+
99  }
+
100 
+
101  GLM_FUNC_QUALIFIER void operator += (vec<N, T, Q> const& that)
+
102  {
+
103  _apply_op(that, op_plus());
+
104  }
+
105 
+
106  GLM_FUNC_QUALIFIER void operator *= (vec<N, T, Q> const& that)
+
107  {
+
108  _apply_op(that, op_mul());
+
109  }
+
110 
+
111  GLM_FUNC_QUALIFIER void operator /= (vec<N, T, Q> const& that)
+
112  {
+
113  _apply_op(that, op_div());
+
114  }
+
115 
+
116  GLM_FUNC_QUALIFIER T& operator[](size_t i)
+
117  {
+
118  const int offset_dst[4] = { E0, E1, E2, E3 };
+
119  return this->elem(offset_dst[i]);
+
120  }
+
121  GLM_FUNC_QUALIFIER T operator[](size_t i) const
+
122  {
+
123  const int offset_dst[4] = { E0, E1, E2, E3 };
+
124  return this->elem(offset_dst[i]);
+
125  }
+
126 
+
127  protected:
+
128  template<typename U>
+
129  GLM_FUNC_QUALIFIER void _apply_op(vec<N, T, Q> const& that, const U& op)
+
130  {
+
131  // Make a copy of the data in this == &that.
+
132  // The copier should optimize out the copy in cases where the function is
+
133  // properly inlined and the copy is not necessary.
+
134  T t[N];
+
135  for (int i = 0; i < N; ++i)
+
136  t[i] = that[i];
+
137  for (int i = 0; i < N; ++i)
+
138  op( (*this)[i], t[i] );
+
139  }
+
140  };
+
141 
+
142  // Specialization for swizzles containing duplicate elements. These cannot be modified.
+
143  template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+
144  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>
+
145  {
+
146  struct Stub {};
+
147 
+
148  GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const&) { return *this; }
+
149 
+
150  GLM_FUNC_QUALIFIER T operator[] (size_t i) const
+
151  {
+
152  const int offset_dst[4] = { E0, E1, E2, E3 };
+
153  return this->elem(offset_dst[i]);
+
154  }
+
155  };
+
156 
+
157  template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+
158  struct _swizzle : public _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)>
+
159  {
+
160  typedef _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)> base_type;
+
161 
+
162  using base_type::operator=;
+
163 
+
164  GLM_FUNC_QUALIFIER operator vec<N, T, Q> () const { return (*this)(); }
+
165  };
+
166 
+
167 //
+
168 // To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
+
169 //
+
170 #define GLM_SWIZZLE_TEMPLATE1 template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+
171 #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>
+
172 #define GLM_SWIZZLE_TYPE1 _swizzle<N, T, Q, E0, E1, E2, E3>
+
173 #define GLM_SWIZZLE_TYPE2 _swizzle<N, T, Q, F0, F1, F2, F3>
+
174 
+
175 //
+
176 // Wrapper for a binary operator (e.g. u.yy + v.zy)
+
177 //
+
178 #define GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
+
179  GLM_SWIZZLE_TEMPLATE2 \
+
180  GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \
+
181  { \
+
182  return a() OPERAND b(); \
+
183  } \
+
184  GLM_SWIZZLE_TEMPLATE1 \
+
185  GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const vec<N, T, Q>& b) \
+
186  { \
+
187  return a() OPERAND b; \
+
188  } \
+
189  GLM_SWIZZLE_TEMPLATE1 \
+
190  GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const vec<N, T, Q>& a, const GLM_SWIZZLE_TYPE1& b) \
+
191  { \
+
192  return a OPERAND b(); \
+
193  }
+
194 
+
195 //
+
196 // Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
+
197 //
+
198 #define GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
+
199  GLM_SWIZZLE_TEMPLATE1 \
+
200  GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const T& b) \
+
201  { \
+
202  return a() OPERAND b; \
+
203  } \
+
204  GLM_SWIZZLE_TEMPLATE1 \
+
205  GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const T& a, const GLM_SWIZZLE_TYPE1& b) \
+
206  { \
+
207  return a OPERAND b(); \
+
208  }
+
209 
+
210 //
+
211 // Macro for wrapping a function taking one argument (e.g. abs())
+
212 //
+
213 #define GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \
+
214  GLM_SWIZZLE_TEMPLATE1 \
+
215  GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a) \
+
216  { \
+
217  return FUNCTION(a()); \
+
218  }
+
219 
+
220 //
+
221 // Macro for wrapping a function taking two vector arguments (e.g. dot()).
+
222 //
+
223 #define GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \
+
224  GLM_SWIZZLE_TEMPLATE2 \
+
225  GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \
+
226  { \
+
227  return FUNCTION(a(), b()); \
+
228  } \
+
229  GLM_SWIZZLE_TEMPLATE1 \
+
230  GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b) \
+
231  { \
+
232  return FUNCTION(a(), b()); \
+
233  } \
+
234  GLM_SWIZZLE_TEMPLATE1 \
+
235  GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename V& b) \
+
236  { \
+
237  return FUNCTION(a(), b); \
+
238  } \
+
239  GLM_SWIZZLE_TEMPLATE1 \
+
240  GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const GLM_SWIZZLE_TYPE1& b) \
+
241  { \
+
242  return FUNCTION(a, b()); \
+
243  }
+
244 
+
245 //
+
246 // Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
+
247 //
+
248 #define GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION) \
+
249  GLM_SWIZZLE_TEMPLATE2 \
+
250  GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b, const T& c) \
+
251  { \
+
252  return FUNCTION(a(), b(), c); \
+
253  } \
+
254  GLM_SWIZZLE_TEMPLATE1 \
+
255  GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b, const T& c) \
+
256  { \
+
257  return FUNCTION(a(), b(), c); \
+
258  } \
+
259  GLM_SWIZZLE_TEMPLATE1 \
+
260  GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
+
261  { \
+
262  return FUNCTION(a(), b, c); \
+
263  } \
+
264  GLM_SWIZZLE_TEMPLATE1 \
+
265  GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const GLM_SWIZZLE_TYPE1& b, const T& c) \
+
266  { \
+
267  return FUNCTION(a, b(), c); \
+
268  }
+
269 
+
270 }//namespace detail
+
271 }//namespace glm
+
272 
+
273 namespace glm
+
274 {
+
275  namespace detail
+
276  {
+
277  GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
+
278  GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
+
279  GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
+
280  GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
+
281  GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
+
282  GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
+
283  }
+
284 
+
285  //
+
286  // Swizzles are distinct types from the unswizzled type. The below macros will
+
287  // provide template specializations for the swizzle types for the given functions
+
288  // so that the compiler does not have any ambiguity to choosing how to handle
+
289  // the function.
+
290  //
+
291  // The alternative is to use the operator()() when calling the function in order
+
292  // to explicitly convert the swizzled type to the unswizzled type.
+
293  //
+
294 
+
295  //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, abs);
+
296  //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acos);
+
297  //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acosh);
+
298  //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, all);
+
299  //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, any);
+
300 
+
301  //GLM_SWIZZLE_FUNCTION_2_ARGS(value_type, dot);
+
302  //GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, cross);
+
303  //GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, step);
+
304  //GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
+
305 }
+
306 
+
307 #define GLM_SWIZZLE2_2_MEMBERS(T, Q, E0,E1) \
+
308  struct { detail::_swizzle<2, T, Q, 0,0,-1,-2> E0 ## E0; }; \
+
309  struct { detail::_swizzle<2, T, Q, 0,1,-1,-2> E0 ## E1; }; \
+
310  struct { detail::_swizzle<2, T, Q, 1,0,-1,-2> E1 ## E0; }; \
+
311  struct { detail::_swizzle<2, T, Q, 1,1,-1,-2> E1 ## E1; };
+
312 
+
313 #define GLM_SWIZZLE2_3_MEMBERS(T, Q, E0,E1) \
+
314  struct { detail::_swizzle<3,T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+
315  struct { detail::_swizzle<3,T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+
316  struct { detail::_swizzle<3,T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+
317  struct { detail::_swizzle<3,T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+
318  struct { detail::_swizzle<3,T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+
319  struct { detail::_swizzle<3,T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+
320  struct { detail::_swizzle<3,T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+
321  struct { detail::_swizzle<3,T, Q, 1,1,1,-1> E1 ## E1 ## E1; };
+
322 
+
323 #define GLM_SWIZZLE2_4_MEMBERS(T, Q, E0,E1) \
+
324  struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+
325  struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+
326  struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+
327  struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+
328  struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+
329  struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+
330  struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+
331  struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+
332  struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+
333  struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+
334  struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+
335  struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+
336  struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+
337  struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+
338  struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+
339  struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; };
+
340 
+
341 #define GLM_SWIZZLE3_2_MEMBERS(T, Q, E0,E1,E2) \
+
342  struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \
+
343  struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \
+
344  struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \
+
345  struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \
+
346  struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \
+
347  struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \
+
348  struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \
+
349  struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \
+
350  struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; };
+
351 
+
352 #define GLM_SWIZZLE3_3_MEMBERS(T, Q ,E0,E1,E2) \
+
353  struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+
354  struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+
355  struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \
+
356  struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+
357  struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+
358  struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \
+
359  struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \
+
360  struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \
+
361  struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \
+
362  struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+
363  struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+
364  struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \
+
365  struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+
366  struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \
+
367  struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \
+
368  struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \
+
369  struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \
+
370  struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \
+
371  struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \
+
372  struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \
+
373  struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \
+
374  struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \
+
375  struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \
+
376  struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \
+
377  struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \
+
378  struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \
+
379  struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; };
+
380 
+
381 #define GLM_SWIZZLE3_4_MEMBERS(T, Q, E0,E1,E2) \
+
382  struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+
383  struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+
384  struct { detail::_swizzle<4,T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+
385  struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+
386  struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+
387  struct { detail::_swizzle<4,T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+
388  struct { detail::_swizzle<4,T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+
389  struct { detail::_swizzle<4,T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+
390  struct { detail::_swizzle<4,T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+
391  struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+
392  struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+
393  struct { detail::_swizzle<4,T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+
394  struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+
395  struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+
396  struct { detail::_swizzle<4,T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+
397  struct { detail::_swizzle<4,T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+
398  struct { detail::_swizzle<4,T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+
399  struct { detail::_swizzle<4,T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+
400  struct { detail::_swizzle<4,T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+
401  struct { detail::_swizzle<4,T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+
402  struct { detail::_swizzle<4,T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+
403  struct { detail::_swizzle<4,T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+
404  struct { detail::_swizzle<4,T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+
405  struct { detail::_swizzle<4,T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+
406  struct { detail::_swizzle<4,T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+
407  struct { detail::_swizzle<4,T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+
408  struct { detail::_swizzle<4,T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+
409  struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+
410  struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+
411  struct { detail::_swizzle<4,T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+
412  struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+
413  struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+
414  struct { detail::_swizzle<4,T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+
415  struct { detail::_swizzle<4,T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+
416  struct { detail::_swizzle<4,T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+
417  struct { detail::_swizzle<4,T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+
418  struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+
419  struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+
420  struct { detail::_swizzle<4,T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+
421  struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+
422  struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+
423  struct { detail::_swizzle<4,T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+
424  struct { detail::_swizzle<4,T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+
425  struct { detail::_swizzle<4,T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+
426  struct { detail::_swizzle<4,T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+
427  struct { detail::_swizzle<4,T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+
428  struct { detail::_swizzle<4,T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+
429  struct { detail::_swizzle<4,T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+
430  struct { detail::_swizzle<4,T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+
431  struct { detail::_swizzle<4,T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+
432  struct { detail::_swizzle<4,T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+
433  struct { detail::_swizzle<4,T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+
434  struct { detail::_swizzle<4,T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+
435  struct { detail::_swizzle<4,T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+
436  struct { detail::_swizzle<4,T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+
437  struct { detail::_swizzle<4,T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+
438  struct { detail::_swizzle<4,T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+
439  struct { detail::_swizzle<4,T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+
440  struct { detail::_swizzle<4,T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+
441  struct { detail::_swizzle<4,T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+
442  struct { detail::_swizzle<4,T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+
443  struct { detail::_swizzle<4,T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+
444  struct { detail::_swizzle<4,T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+
445  struct { detail::_swizzle<4,T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+
446  struct { detail::_swizzle<4,T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+
447  struct { detail::_swizzle<4,T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+
448  struct { detail::_swizzle<4,T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+
449  struct { detail::_swizzle<4,T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+
450  struct { detail::_swizzle<4,T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+
451  struct { detail::_swizzle<4,T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+
452  struct { detail::_swizzle<4,T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+
453  struct { detail::_swizzle<4,T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+
454  struct { detail::_swizzle<4,T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+
455  struct { detail::_swizzle<4,T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+
456  struct { detail::_swizzle<4,T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+
457  struct { detail::_swizzle<4,T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+
458  struct { detail::_swizzle<4,T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+
459  struct { detail::_swizzle<4,T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+
460  struct { detail::_swizzle<4,T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+
461  struct { detail::_swizzle<4,T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+
462  struct { detail::_swizzle<4,T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; };
+
463 
+
464 #define GLM_SWIZZLE4_2_MEMBERS(T, Q, E0,E1,E2,E3) \
+
465  struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \
+
466  struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \
+
467  struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \
+
468  struct { detail::_swizzle<2,T, Q, 0,3,-1,-2> E0 ## E3; }; \
+
469  struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \
+
470  struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \
+
471  struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \
+
472  struct { detail::_swizzle<2,T, Q, 1,3,-1,-2> E1 ## E3; }; \
+
473  struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \
+
474  struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \
+
475  struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; }; \
+
476  struct { detail::_swizzle<2,T, Q, 2,3,-1,-2> E2 ## E3; }; \
+
477  struct { detail::_swizzle<2,T, Q, 3,0,-1,-2> E3 ## E0; }; \
+
478  struct { detail::_swizzle<2,T, Q, 3,1,-1,-2> E3 ## E1; }; \
+
479  struct { detail::_swizzle<2,T, Q, 3,2,-1,-2> E3 ## E2; }; \
+
480  struct { detail::_swizzle<2,T, Q, 3,3,-1,-2> E3 ## E3; };
+
481 
+
482 #define GLM_SWIZZLE4_3_MEMBERS(T, Q, E0,E1,E2,E3) \
+
483  struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+
484  struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+
485  struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \
+
486  struct { detail::_swizzle<3, T, Q, 0,0,3,-1> E0 ## E0 ## E3; }; \
+
487  struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+
488  struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+
489  struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \
+
490  struct { detail::_swizzle<3, T, Q, 0,1,3,-1> E0 ## E1 ## E3; }; \
+
491  struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \
+
492  struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \
+
493  struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \
+
494  struct { detail::_swizzle<3, T, Q, 0,2,3,-1> E0 ## E2 ## E3; }; \
+
495  struct { detail::_swizzle<3, T, Q, 0,3,0,-1> E0 ## E3 ## E0; }; \
+
496  struct { detail::_swizzle<3, T, Q, 0,3,1,-1> E0 ## E3 ## E1; }; \
+
497  struct { detail::_swizzle<3, T, Q, 0,3,2,-1> E0 ## E3 ## E2; }; \
+
498  struct { detail::_swizzle<3, T, Q, 0,3,3,-1> E0 ## E3 ## E3; }; \
+
499  struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+
500  struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+
501  struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \
+
502  struct { detail::_swizzle<3, T, Q, 1,0,3,-1> E1 ## E0 ## E3; }; \
+
503  struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+
504  struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \
+
505  struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \
+
506  struct { detail::_swizzle<3, T, Q, 1,1,3,-1> E1 ## E1 ## E3; }; \
+
507  struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \
+
508  struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \
+
509  struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \
+
510  struct { detail::_swizzle<3, T, Q, 1,2,3,-1> E1 ## E2 ## E3; }; \
+
511  struct { detail::_swizzle<3, T, Q, 1,3,0,-1> E1 ## E3 ## E0; }; \
+
512  struct { detail::_swizzle<3, T, Q, 1,3,1,-1> E1 ## E3 ## E1; }; \
+
513  struct { detail::_swizzle<3, T, Q, 1,3,2,-1> E1 ## E3 ## E2; }; \
+
514  struct { detail::_swizzle<3, T, Q, 1,3,3,-1> E1 ## E3 ## E3; }; \
+
515  struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \
+
516  struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \
+
517  struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \
+
518  struct { detail::_swizzle<3, T, Q, 2,0,3,-1> E2 ## E0 ## E3; }; \
+
519  struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \
+
520  struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \
+
521  struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \
+
522  struct { detail::_swizzle<3, T, Q, 2,1,3,-1> E2 ## E1 ## E3; }; \
+
523  struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \
+
524  struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \
+
525  struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; }; \
+
526  struct { detail::_swizzle<3, T, Q, 2,2,3,-1> E2 ## E2 ## E3; }; \
+
527  struct { detail::_swizzle<3, T, Q, 2,3,0,-1> E2 ## E3 ## E0; }; \
+
528  struct { detail::_swizzle<3, T, Q, 2,3,1,-1> E2 ## E3 ## E1; }; \
+
529  struct { detail::_swizzle<3, T, Q, 2,3,2,-1> E2 ## E3 ## E2; }; \
+
530  struct { detail::_swizzle<3, T, Q, 2,3,3,-1> E2 ## E3 ## E3; }; \
+
531  struct { detail::_swizzle<3, T, Q, 3,0,0,-1> E3 ## E0 ## E0; }; \
+
532  struct { detail::_swizzle<3, T, Q, 3,0,1,-1> E3 ## E0 ## E1; }; \
+
533  struct { detail::_swizzle<3, T, Q, 3,0,2,-1> E3 ## E0 ## E2; }; \
+
534  struct { detail::_swizzle<3, T, Q, 3,0,3,-1> E3 ## E0 ## E3; }; \
+
535  struct { detail::_swizzle<3, T, Q, 3,1,0,-1> E3 ## E1 ## E0; }; \
+
536  struct { detail::_swizzle<3, T, Q, 3,1,1,-1> E3 ## E1 ## E1; }; \
+
537  struct { detail::_swizzle<3, T, Q, 3,1,2,-1> E3 ## E1 ## E2; }; \
+
538  struct { detail::_swizzle<3, T, Q, 3,1,3,-1> E3 ## E1 ## E3; }; \
+
539  struct { detail::_swizzle<3, T, Q, 3,2,0,-1> E3 ## E2 ## E0; }; \
+
540  struct { detail::_swizzle<3, T, Q, 3,2,1,-1> E3 ## E2 ## E1; }; \
+
541  struct { detail::_swizzle<3, T, Q, 3,2,2,-1> E3 ## E2 ## E2; }; \
+
542  struct { detail::_swizzle<3, T, Q, 3,2,3,-1> E3 ## E2 ## E3; }; \
+
543  struct { detail::_swizzle<3, T, Q, 3,3,0,-1> E3 ## E3 ## E0; }; \
+
544  struct { detail::_swizzle<3, T, Q, 3,3,1,-1> E3 ## E3 ## E1; }; \
+
545  struct { detail::_swizzle<3, T, Q, 3,3,2,-1> E3 ## E3 ## E2; }; \
+
546  struct { detail::_swizzle<3, T, Q, 3,3,3,-1> E3 ## E3 ## E3; };
+
547 
+
548 #define GLM_SWIZZLE4_4_MEMBERS(T, Q, E0,E1,E2,E3) \
+
549  struct { detail::_swizzle<4, T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+
550  struct { detail::_swizzle<4, T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+
551  struct { detail::_swizzle<4, T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+
552  struct { detail::_swizzle<4, T, Q, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
+
553  struct { detail::_swizzle<4, T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+
554  struct { detail::_swizzle<4, T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+
555  struct { detail::_swizzle<4, T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+
556  struct { detail::_swizzle<4, T, Q, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
+
557  struct { detail::_swizzle<4, T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+
558  struct { detail::_swizzle<4, T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+
559  struct { detail::_swizzle<4, T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+
560  struct { detail::_swizzle<4, T, Q, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
+
561  struct { detail::_swizzle<4, T, Q, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
+
562  struct { detail::_swizzle<4, T, Q, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
+
563  struct { detail::_swizzle<4, T, Q, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
+
564  struct { detail::_swizzle<4, T, Q, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
+
565  struct { detail::_swizzle<4, T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+
566  struct { detail::_swizzle<4, T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+
567  struct { detail::_swizzle<4, T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+
568  struct { detail::_swizzle<4, T, Q, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
+
569  struct { detail::_swizzle<4, T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+
570  struct { detail::_swizzle<4, T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+
571  struct { detail::_swizzle<4, T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+
572  struct { detail::_swizzle<4, T, Q, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
+
573  struct { detail::_swizzle<4, T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+
574  struct { detail::_swizzle<4, T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+
575  struct { detail::_swizzle<4, T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+
576  struct { detail::_swizzle<4, T, Q, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
+
577  struct { detail::_swizzle<4, T, Q, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
+
578  struct { detail::_swizzle<4, T, Q, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
+
579  struct { detail::_swizzle<4, T, Q, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
+
580  struct { detail::_swizzle<4, T, Q, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
+
581  struct { detail::_swizzle<4, T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+
582  struct { detail::_swizzle<4, T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+
583  struct { detail::_swizzle<4, T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+
584  struct { detail::_swizzle<4, T, Q, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
+
585  struct { detail::_swizzle<4, T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+
586  struct { detail::_swizzle<4, T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+
587  struct { detail::_swizzle<4, T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+
588  struct { detail::_swizzle<4, T, Q, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
+
589  struct { detail::_swizzle<4, T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+
590  struct { detail::_swizzle<4, T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+
591  struct { detail::_swizzle<4, T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+
592  struct { detail::_swizzle<4, T, Q, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
+
593  struct { detail::_swizzle<4, T, Q, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
+
594  struct { detail::_swizzle<4, T, Q, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
+
595  struct { detail::_swizzle<4, T, Q, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
+
596  struct { detail::_swizzle<4, T, Q, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
+
597  struct { detail::_swizzle<4, T, Q, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
+
598  struct { detail::_swizzle<4, T, Q, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
+
599  struct { detail::_swizzle<4, T, Q, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
+
600  struct { detail::_swizzle<4, T, Q, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
+
601  struct { detail::_swizzle<4, T, Q, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
+
602  struct { detail::_swizzle<4, T, Q, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
+
603  struct { detail::_swizzle<4, T, Q, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
+
604  struct { detail::_swizzle<4, T, Q, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
+
605  struct { detail::_swizzle<4, T, Q, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
+
606  struct { detail::_swizzle<4, T, Q, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
+
607  struct { detail::_swizzle<4, T, Q, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
+
608  struct { detail::_swizzle<4, T, Q, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
+
609  struct { detail::_swizzle<4, T, Q, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
+
610  struct { detail::_swizzle<4, T, Q, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
+
611  struct { detail::_swizzle<4, T, Q, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
+
612  struct { detail::_swizzle<4, T, Q, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
+
613  struct { detail::_swizzle<4, T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+
614  struct { detail::_swizzle<4, T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+
615  struct { detail::_swizzle<4, T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+
616  struct { detail::_swizzle<4, T, Q, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
+
617  struct { detail::_swizzle<4, T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+
618  struct { detail::_swizzle<4, T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+
619  struct { detail::_swizzle<4, T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+
620  struct { detail::_swizzle<4, T, Q, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
+
621  struct { detail::_swizzle<4, T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+
622  struct { detail::_swizzle<4, T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+
623  struct { detail::_swizzle<4, T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+
624  struct { detail::_swizzle<4, T, Q, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
+
625  struct { detail::_swizzle<4, T, Q, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
+
626  struct { detail::_swizzle<4, T, Q, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
+
627  struct { detail::_swizzle<4, T, Q, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
+
628  struct { detail::_swizzle<4, T, Q, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
+
629  struct { detail::_swizzle<4, T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+
630  struct { detail::_swizzle<4, T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+
631  struct { detail::_swizzle<4, T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+
632  struct { detail::_swizzle<4, T, Q, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
+
633  struct { detail::_swizzle<4, T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+
634  struct { detail::_swizzle<4, T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+
635  struct { detail::_swizzle<4, T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+
636  struct { detail::_swizzle<4, T, Q, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
+
637  struct { detail::_swizzle<4, T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+
638  struct { detail::_swizzle<4, T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+
639  struct { detail::_swizzle<4, T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+
640  struct { detail::_swizzle<4, T, Q, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
+
641  struct { detail::_swizzle<4, T, Q, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
+
642  struct { detail::_swizzle<4, T, Q, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
+
643  struct { detail::_swizzle<4, T, Q, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
+
644  struct { detail::_swizzle<4, T, Q, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
+
645  struct { detail::_swizzle<4, T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+
646  struct { detail::_swizzle<4, T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+
647  struct { detail::_swizzle<4, T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+
648  struct { detail::_swizzle<4, T, Q, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
+
649  struct { detail::_swizzle<4, T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+
650  struct { detail::_swizzle<4, T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+
651  struct { detail::_swizzle<4, T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+
652  struct { detail::_swizzle<4, T, Q, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
+
653  struct { detail::_swizzle<4, T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+
654  struct { detail::_swizzle<4, T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+
655  struct { detail::_swizzle<4, T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+
656  struct { detail::_swizzle<4, T, Q, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
+
657  struct { detail::_swizzle<4, T, Q, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
+
658  struct { detail::_swizzle<4, T, Q, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
+
659  struct { detail::_swizzle<4, T, Q, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
+
660  struct { detail::_swizzle<4, T, Q, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
+
661  struct { detail::_swizzle<4, T, Q, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
+
662  struct { detail::_swizzle<4, T, Q, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
+
663  struct { detail::_swizzle<4, T, Q, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
+
664  struct { detail::_swizzle<4, T, Q, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
+
665  struct { detail::_swizzle<4, T, Q, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
+
666  struct { detail::_swizzle<4, T, Q, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
+
667  struct { detail::_swizzle<4, T, Q, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
+
668  struct { detail::_swizzle<4, T, Q, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
+
669  struct { detail::_swizzle<4, T, Q, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
+
670  struct { detail::_swizzle<4, T, Q, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
+
671  struct { detail::_swizzle<4, T, Q, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
+
672  struct { detail::_swizzle<4, T, Q, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
+
673  struct { detail::_swizzle<4, T, Q, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
+
674  struct { detail::_swizzle<4, T, Q, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
+
675  struct { detail::_swizzle<4, T, Q, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
+
676  struct { detail::_swizzle<4, T, Q, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
+
677  struct { detail::_swizzle<4, T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+
678  struct { detail::_swizzle<4, T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+
679  struct { detail::_swizzle<4, T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+
680  struct { detail::_swizzle<4, T, Q, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
+
681  struct { detail::_swizzle<4, T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+
682  struct { detail::_swizzle<4, T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+
683  struct { detail::_swizzle<4, T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+
684  struct { detail::_swizzle<4, T, Q, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
+
685  struct { detail::_swizzle<4, T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+
686  struct { detail::_swizzle<4, T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+
687  struct { detail::_swizzle<4, T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+
688  struct { detail::_swizzle<4, T, Q, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
+
689  struct { detail::_swizzle<4, T, Q, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
+
690  struct { detail::_swizzle<4, T, Q, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
+
691  struct { detail::_swizzle<4, T, Q, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
+
692  struct { detail::_swizzle<4, T, Q, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
+
693  struct { detail::_swizzle<4, T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+
694  struct { detail::_swizzle<4, T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+
695  struct { detail::_swizzle<4, T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+
696  struct { detail::_swizzle<4, T, Q, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
+
697  struct { detail::_swizzle<4, T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+
698  struct { detail::_swizzle<4, T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+
699  struct { detail::_swizzle<4, T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+
700  struct { detail::_swizzle<4, T, Q, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
+
701  struct { detail::_swizzle<4, T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+
702  struct { detail::_swizzle<4, T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+
703  struct { detail::_swizzle<4, T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+
704  struct { detail::_swizzle<4, T, Q, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
+
705  struct { detail::_swizzle<4, T, Q, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
+
706  struct { detail::_swizzle<4, T, Q, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
+
707  struct { detail::_swizzle<4, T, Q, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
+
708  struct { detail::_swizzle<4, T, Q, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
+
709  struct { detail::_swizzle<4, T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+
710  struct { detail::_swizzle<4, T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+
711  struct { detail::_swizzle<4, T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+
712  struct { detail::_swizzle<4, T, Q, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
+
713  struct { detail::_swizzle<4, T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+
714  struct { detail::_swizzle<4, T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+
715  struct { detail::_swizzle<4, T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+
716  struct { detail::_swizzle<4, T, Q, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
+
717  struct { detail::_swizzle<4, T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+
718  struct { detail::_swizzle<4, T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+
719  struct { detail::_swizzle<4, T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
+
720  struct { detail::_swizzle<4, T, Q, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
+
721  struct { detail::_swizzle<4, T, Q, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
+
722  struct { detail::_swizzle<4, T, Q, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
+
723  struct { detail::_swizzle<4, T, Q, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
+
724  struct { detail::_swizzle<4, T, Q, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
+
725  struct { detail::_swizzle<4, T, Q, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
+
726  struct { detail::_swizzle<4, T, Q, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
+
727  struct { detail::_swizzle<4, T, Q, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
+
728  struct { detail::_swizzle<4, T, Q, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
+
729  struct { detail::_swizzle<4, T, Q, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
+
730  struct { detail::_swizzle<4, T, Q, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
+
731  struct { detail::_swizzle<4, T, Q, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
+
732  struct { detail::_swizzle<4, T, Q, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
+
733  struct { detail::_swizzle<4, T, Q, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
+
734  struct { detail::_swizzle<4, T, Q, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
+
735  struct { detail::_swizzle<4, T, Q, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
+
736  struct { detail::_swizzle<4, T, Q, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
+
737  struct { detail::_swizzle<4, T, Q, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
+
738  struct { detail::_swizzle<4, T, Q, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
+
739  struct { detail::_swizzle<4, T, Q, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
+
740  struct { detail::_swizzle<4, T, Q, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
+
741  struct { detail::_swizzle<4, T, Q, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
+
742  struct { detail::_swizzle<4, T, Q, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
+
743  struct { detail::_swizzle<4, T, Q, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
+
744  struct { detail::_swizzle<4, T, Q, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
+
745  struct { detail::_swizzle<4, T, Q, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
+
746  struct { detail::_swizzle<4, T, Q, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
+
747  struct { detail::_swizzle<4, T, Q, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
+
748  struct { detail::_swizzle<4, T, Q, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
+
749  struct { detail::_swizzle<4, T, Q, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
+
750  struct { detail::_swizzle<4, T, Q, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
+
751  struct { detail::_swizzle<4, T, Q, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
+
752  struct { detail::_swizzle<4, T, Q, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
+
753  struct { detail::_swizzle<4, T, Q, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
+
754  struct { detail::_swizzle<4, T, Q, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
+
755  struct { detail::_swizzle<4, T, Q, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
+
756  struct { detail::_swizzle<4, T, Q, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
+
757  struct { detail::_swizzle<4, T, Q, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
+
758  struct { detail::_swizzle<4, T, Q, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
+
759  struct { detail::_swizzle<4, T, Q, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
+
760  struct { detail::_swizzle<4, T, Q, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
+
761  struct { detail::_swizzle<4, T, Q, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
+
762  struct { detail::_swizzle<4, T, Q, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
+
763  struct { detail::_swizzle<4, T, Q, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
+
764  struct { detail::_swizzle<4, T, Q, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
+
765  struct { detail::_swizzle<4, T, Q, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
+
766  struct { detail::_swizzle<4, T, Q, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
+
767  struct { detail::_swizzle<4, T, Q, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
+
768  struct { detail::_swizzle<4, T, Q, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
+
769  struct { detail::_swizzle<4, T, Q, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
+
770  struct { detail::_swizzle<4, T, Q, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
+
771  struct { detail::_swizzle<4, T, Q, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
+
772  struct { detail::_swizzle<4, T, Q, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
+
773  struct { detail::_swizzle<4, T, Q, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
+
774  struct { detail::_swizzle<4, T, Q, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
+
775  struct { detail::_swizzle<4, T, Q, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
+
776  struct { detail::_swizzle<4, T, Q, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
+
777  struct { detail::_swizzle<4, T, Q, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
+
778  struct { detail::_swizzle<4, T, Q, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
+
779  struct { detail::_swizzle<4, T, Q, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
+
780  struct { detail::_swizzle<4, T, Q, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
+
781  struct { detail::_swizzle<4, T, Q, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
+
782  struct { detail::_swizzle<4, T, Q, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
+
783  struct { detail::_swizzle<4, T, Q, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
+
784  struct { detail::_swizzle<4, T, Q, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
+
785  struct { detail::_swizzle<4, T, Q, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
+
786  struct { detail::_swizzle<4, T, Q, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
+
787  struct { detail::_swizzle<4, T, Q, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
+
788  struct { detail::_swizzle<4, T, Q, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
+
789  struct { detail::_swizzle<4, T, Q, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
+
790  struct { detail::_swizzle<4, T, Q, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
+
791  struct { detail::_swizzle<4, T, Q, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
+
792  struct { detail::_swizzle<4, T, Q, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
+
793  struct { detail::_swizzle<4, T, Q, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
+
794  struct { detail::_swizzle<4, T, Q, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
+
795  struct { detail::_swizzle<4, T, Q, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
+
796  struct { detail::_swizzle<4, T, Q, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
+
797  struct { detail::_swizzle<4, T, Q, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
+
798  struct { detail::_swizzle<4, T, Q, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
+
799  struct { detail::_swizzle<4, T, Q, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
+
800  struct { detail::_swizzle<4, T, Q, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
+
801  struct { detail::_swizzle<4, T, Q, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
+
802  struct { detail::_swizzle<4, T, Q, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
+
803  struct { detail::_swizzle<4, T, Q, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
+
804  struct { detail::_swizzle<4, T, Q, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
+
GLM_FUNC_DECL GLM_CONSTEXPR genType e()
Return e constant.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00005_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00005_source.html new file mode 100644 index 0000000000000000000000000000000000000000..5ef1455ec2fa5392c87ea69914a47c5bd367ffc9 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00005_source.html @@ -0,0 +1,781 @@ + + + + + + +0.9.9 API documentation: _swizzle_func.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
_swizzle_func.hpp
+
+
+
1 #pragma once
+
2 
+
3 #define GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, CONST, A, B) \
+
4  vec<2, T, Q> A ## B() CONST \
+
5  { \
+
6  return vec<2, T, Q>(this->A, this->B); \
+
7  }
+
8 
+
9 #define GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, CONST, A, B, C) \
+
10  vec<3, T, Q> A ## B ## C() CONST \
+
11  { \
+
12  return vec<3, T, Q>(this->A, this->B, this->C); \
+
13  }
+
14 
+
15 #define GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, CONST, A, B, C, D) \
+
16  vec<4, T, Q> A ## B ## C ## D() CONST \
+
17  { \
+
18  return vec<4, T, Q>(this->A, this->B, this->C, this->D); \
+
19  }
+
20 
+
21 #define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(T, P, L, CONST, A, B) \
+
22  template<typename T> \
+
23  vec<L, T, Q> vec<L, T, Q>::A ## B() CONST \
+
24  { \
+
25  return vec<2, T, Q>(this->A, this->B); \
+
26  }
+
27 
+
28 #define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(T, P, L, CONST, A, B, C) \
+
29  template<typename T> \
+
30  vec<3, T, Q> vec<L, T, Q>::A ## B ## C() CONST \
+
31  { \
+
32  return vec<3, T, Q>(this->A, this->B, this->C); \
+
33  }
+
34 
+
35 #define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(T, P, L, CONST, A, B, C, D) \
+
36  template<typename T> \
+
37  vec<4, T, Q> vec<L, T, Q>::A ## B ## C ## D() CONST \
+
38  { \
+
39  return vec<4, T, Q>(this->A, this->B, this->C, this->D); \
+
40  }
+
41 
+
42 #define GLM_MUTABLE
+
43 
+
44 #define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+
45  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, A, B) \
+
46  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, B, A)
+
47 
+
48 #define GLM_SWIZZLE_GEN_REF_FROM_VEC2(T, P) \
+
49  GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, x, y) \
+
50  GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, r, g) \
+
51  GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, s, t)
+
52 
+
53 #define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+
54  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+
55  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+
56  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+
57  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+
58  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+
59  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B)
+
60 
+
61 #define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+
62  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, B, C) \
+
63  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, C, B) \
+
64  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, A, C) \
+
65  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, C, A) \
+
66  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, A, B) \
+
67  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, B, A)
+
68 
+
69 #define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, A, B, C) \
+
70  GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+
71  GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C)
+
72 
+
73 #define GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P) \
+
74  GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, x, y, z) \
+
75  GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, r, g, b) \
+
76  GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, s, t, p)
+
77 
+
78 #define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
79  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+
80  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+
81  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, D) \
+
82  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+
83  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+
84  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, D) \
+
85  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+
86  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B) \
+
87  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, D) \
+
88  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, A) \
+
89  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, B) \
+
90  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, C)
+
91 
+
92 #define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
93  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, C) \
+
94  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, D) \
+
95  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, B) \
+
96  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, D) \
+
97  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, B) \
+
98  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, C) \
+
99  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, C) \
+
100  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, D) \
+
101  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, A) \
+
102  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, D) \
+
103  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, A) \
+
104  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, C) \
+
105  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, B) \
+
106  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, D) \
+
107  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, A) \
+
108  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, D) \
+
109  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, A) \
+
110  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, B) \
+
111  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, B) \
+
112  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, C) \
+
113  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, A) \
+
114  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, C) \
+
115  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, A) \
+
116  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, B)
+
117 
+
118 #define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
119  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, B, D) \
+
120  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, D, B) \
+
121  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, B, C) \
+
122  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, C, B) \
+
123  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, D, C) \
+
124  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, C, D) \
+
125  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, A, D) \
+
126  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, D, A) \
+
127  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, A, C) \
+
128  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, C, A) \
+
129  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, D, C) \
+
130  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, C, D) \
+
131  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, A, D) \
+
132  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, D, A) \
+
133  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, A, B) \
+
134  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, B, A) \
+
135  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, D, B) \
+
136  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, B, D) \
+
137  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, B, A) \
+
138  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, A, B) \
+
139  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, B, C) \
+
140  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, C, B) \
+
141  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, A, C) \
+
142  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, C, A)
+
143 
+
144 #define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, A, B, C, D) \
+
145  GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
146  GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
147  GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
+
148 
+
149 #define GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P) \
+
150  GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, x, y, z, w) \
+
151  GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, r, g, b, a) \
+
152  GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, s, t, p, q)
+
153 
+
154 #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+
155  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+
156  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+
157  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+
158  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B)
+
159 
+
160 #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+
161  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+
162  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+
163  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+
164  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+
165  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+
166  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+
167  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+
168  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B)
+
169 
+
170 #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B) \
+
171  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+
172  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+
173  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+
174  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+
175  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+
176  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+
177  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+
178  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+
179  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+
180  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+
181  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+
182  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+
183  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+
184  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+
185  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+
186  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B)
+
187 
+
188 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, A, B) \
+
189  GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+
190  GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+
191  GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B)
+
192 
+
193 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P) \
+
194  GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, x, y) \
+
195  GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, r, g) \
+
196  GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, s, t)
+
197 
+
198 #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+
199  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+
200  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+
201  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+
202  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+
203  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+
204  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+
205  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+
206  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+
207  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C)
+
208 
+
209 #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+
210  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+
211  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+
212  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+
213  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+
214  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+
215  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+
216  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+
217  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+
218  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+
219  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+
220  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+
221  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+
222  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+
223  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+
224  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+
225  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+
226  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+
227  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+
228  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+
229  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+
230  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+
231  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+
232  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+
233  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+
234  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+
235  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+
236  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C)
+
237 
+
238 #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+
239  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+
240  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+
241  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+
242  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+
243  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+
244  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+
245  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+
246  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+
247  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+
248  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+
249  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+
250  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+
251  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+
252  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+
253  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+
254  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+
255  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+
256  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+
257  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+
258  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+
259  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+
260  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+
261  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+
262  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+
263  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+
264  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+
265  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+
266  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+
267  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+
268  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+
269  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+
270  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+
271  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+
272  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+
273  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+
274  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+
275  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+
276  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+
277  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+
278  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+
279  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+
280  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+
281  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+
282  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+
283  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+
284  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+
285  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+
286  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+
287  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+
288  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+
289  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+
290  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+
291  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+
292  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+
293  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+
294  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+
295  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+
296  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+
297  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+
298  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+
299  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+
300  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+
301  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+
302  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+
303  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+
304  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+
305  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+
306  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+
307  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+
308  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+
309  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+
310  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+
311  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+
312  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+
313  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+
314  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+
315  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+
316  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+
317  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+
318  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+
319  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C)
+
320 
+
321 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, A, B, C) \
+
322  GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+
323  GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+
324  GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C)
+
325 
+
326 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P) \
+
327  GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, x, y, z) \
+
328  GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, r, g, b) \
+
329  GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, s, t, p)
+
330 
+
331 #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
332  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+
333  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+
334  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+
335  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, D) \
+
336  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+
337  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+
338  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+
339  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, D) \
+
340  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+
341  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+
342  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C) \
+
343  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, D) \
+
344  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, A) \
+
345  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, B) \
+
346  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, C) \
+
347  GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, D)
+
348 
+
349 #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
350  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+
351  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+
352  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+
353  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, D) \
+
354  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+
355  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+
356  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+
357  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, D) \
+
358  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+
359  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+
360  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+
361  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, D) \
+
362  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, A) \
+
363  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, B) \
+
364  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, C) \
+
365  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, D) \
+
366  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+
367  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+
368  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+
369  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, D) \
+
370  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+
371  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+
372  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+
373  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, D) \
+
374  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+
375  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+
376  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+
377  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, D) \
+
378  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, A) \
+
379  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, B) \
+
380  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, C) \
+
381  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, D) \
+
382  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+
383  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+
384  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+
385  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, D) \
+
386  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+
387  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+
388  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+
389  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, D) \
+
390  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+
391  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+
392  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C) \
+
393  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, D) \
+
394  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, A) \
+
395  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, B) \
+
396  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, C) \
+
397  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, D) \
+
398  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, A) \
+
399  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, B) \
+
400  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, C) \
+
401  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, D) \
+
402  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, A) \
+
403  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, B) \
+
404  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, C) \
+
405  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, D) \
+
406  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, A) \
+
407  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, B) \
+
408  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, C) \
+
409  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, D) \
+
410  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, A) \
+
411  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, B) \
+
412  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, C) \
+
413  GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, D)
+
414 
+
415 #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
416  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+
417  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+
418  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+
419  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, D) \
+
420  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+
421  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+
422  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+
423  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, D) \
+
424  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+
425  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+
426  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+
427  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, D) \
+
428  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, A) \
+
429  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, B) \
+
430  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, C) \
+
431  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, D) \
+
432  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+
433  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+
434  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+
435  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, D) \
+
436  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+
437  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+
438  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+
439  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, D) \
+
440  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+
441  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+
442  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+
443  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, D) \
+
444  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, A) \
+
445  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, B) \
+
446  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, C) \
+
447  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, D) \
+
448  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+
449  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+
450  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+
451  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, D) \
+
452  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+
453  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+
454  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+
455  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, D) \
+
456  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+
457  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+
458  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+
459  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, D) \
+
460  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, A) \
+
461  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, B) \
+
462  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, C) \
+
463  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, D) \
+
464  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, A) \
+
465  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, B) \
+
466  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, C) \
+
467  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, D) \
+
468  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, A) \
+
469  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, B) \
+
470  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, C) \
+
471  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, D) \
+
472  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, A) \
+
473  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, B) \
+
474  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, C) \
+
475  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, D) \
+
476  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, A) \
+
477  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, B) \
+
478  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, C) \
+
479  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, D) \
+
480  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+
481  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+
482  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+
483  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, D) \
+
484  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+
485  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+
486  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+
487  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, D) \
+
488  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+
489  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+
490  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+
491  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, D) \
+
492  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, A) \
+
493  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, B) \
+
494  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, C) \
+
495  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, D) \
+
496  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+
497  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+
498  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+
499  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, D) \
+
500  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+
501  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+
502  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+
503  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, D) \
+
504  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+
505  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+
506  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+
507  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, D) \
+
508  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, A) \
+
509  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, B) \
+
510  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, C) \
+
511  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, D) \
+
512  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+
513  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+
514  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+
515  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, D) \
+
516  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+
517  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+
518  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+
519  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, D) \
+
520  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+
521  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+
522  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+
523  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, D) \
+
524  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, A) \
+
525  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, B) \
+
526  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, C) \
+
527  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, D) \
+
528  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, A) \
+
529  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, B) \
+
530  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, C) \
+
531  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, D) \
+
532  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, A) \
+
533  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, B) \
+
534  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, C) \
+
535  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, D) \
+
536  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, A) \
+
537  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, B) \
+
538  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, C) \
+
539  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, D) \
+
540  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, A) \
+
541  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, B) \
+
542  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, C) \
+
543  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, D) \
+
544  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+
545  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+
546  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+
547  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, D) \
+
548  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+
549  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+
550  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+
551  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, D) \
+
552  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+
553  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+
554  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+
555  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, D) \
+
556  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, A) \
+
557  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, B) \
+
558  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, C) \
+
559  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, D) \
+
560  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+
561  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+
562  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+
563  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, D) \
+
564  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+
565  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+
566  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+
567  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, D) \
+
568  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+
569  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+
570  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+
571  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, D) \
+
572  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, A) \
+
573  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, B) \
+
574  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, C) \
+
575  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, D) \
+
576  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+
577  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+
578  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+
579  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, D) \
+
580  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+
581  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+
582  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+
583  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, D) \
+
584  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+
585  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+
586  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C) \
+
587  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, D) \
+
588  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, A) \
+
589  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, B) \
+
590  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, C) \
+
591  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, D) \
+
592  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, A) \
+
593  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, B) \
+
594  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, C) \
+
595  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, D) \
+
596  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, A) \
+
597  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, B) \
+
598  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, C) \
+
599  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, D) \
+
600  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, A) \
+
601  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, B) \
+
602  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, C) \
+
603  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, D) \
+
604  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, A) \
+
605  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, B) \
+
606  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, C) \
+
607  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, D) \
+
608  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, A) \
+
609  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, B) \
+
610  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, C) \
+
611  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, D) \
+
612  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, A) \
+
613  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, B) \
+
614  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, C) \
+
615  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, D) \
+
616  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, A) \
+
617  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, B) \
+
618  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, C) \
+
619  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, D) \
+
620  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, A) \
+
621  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, B) \
+
622  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, C) \
+
623  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, D) \
+
624  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, A) \
+
625  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, B) \
+
626  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, C) \
+
627  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, D) \
+
628  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, A) \
+
629  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, B) \
+
630  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, C) \
+
631  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, D) \
+
632  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, A) \
+
633  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, B) \
+
634  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, C) \
+
635  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, D) \
+
636  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, A) \
+
637  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, B) \
+
638  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, C) \
+
639  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, D) \
+
640  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, A) \
+
641  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, B) \
+
642  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, C) \
+
643  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, D) \
+
644  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, A) \
+
645  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, B) \
+
646  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, C) \
+
647  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, D) \
+
648  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, A) \
+
649  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, B) \
+
650  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, C) \
+
651  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, D) \
+
652  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, A) \
+
653  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, B) \
+
654  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, C) \
+
655  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, D) \
+
656  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, A) \
+
657  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, B) \
+
658  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, C) \
+
659  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, D) \
+
660  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, A) \
+
661  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, B) \
+
662  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, C) \
+
663  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, D) \
+
664  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, A) \
+
665  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, B) \
+
666  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, C) \
+
667  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, D) \
+
668  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, A) \
+
669  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, B) \
+
670  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, C) \
+
671  GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, D)
+
672 
+
673 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, A, B, C, D) \
+
674  GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
675  GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+
676  GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
+
677 
+
678 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P) \
+
679  GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, x, y, z, w) \
+
680  GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, r, g, b, a) \
+
681  GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, s, t, p, q)
+
682 
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00006_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00006_source.html new file mode 100644 index 0000000000000000000000000000000000000000..96923b3b4081c76313a7610bfa99f2a59b8bf879 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00006_source.html @@ -0,0 +1,262 @@ + + + + + + +0.9.9 API documentation: _vectorize.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
_vectorize.hpp
+
+
+
1 #pragma once
+
2 
+
3 namespace glm{
+
4 namespace detail
+
5 {
+
6  template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename R, typename T, qualifier Q>
+
7  struct functor1{};
+
8 
+
9  template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+
10  struct functor1<vec, 1, R, T, Q>
+
11  {
+
12  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<1, R, Q> call(R (*Func) (T x), vec<1, T, Q> const& v)
+
13  {
+
14  return vec<1, R, Q>(Func(v.x));
+
15  }
+
16  };
+
17 
+
18  template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+
19  struct functor1<vec, 2, R, T, Q>
+
20  {
+
21  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<2, R, Q> call(R (*Func) (T x), vec<2, T, Q> const& v)
+
22  {
+
23  return vec<2, R, Q>(Func(v.x), Func(v.y));
+
24  }
+
25  };
+
26 
+
27  template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+
28  struct functor1<vec, 3, R, T, Q>
+
29  {
+
30  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<3, R, Q> call(R (*Func) (T x), vec<3, T, Q> const& v)
+
31  {
+
32  return vec<3, R, Q>(Func(v.x), Func(v.y), Func(v.z));
+
33  }
+
34  };
+
35 
+
36  template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+
37  struct functor1<vec, 4, R, T, Q>
+
38  {
+
39  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, R, Q> call(R (*Func) (T x), vec<4, T, Q> const& v)
+
40  {
+
41  return vec<4, R, Q>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
+
42  }
+
43  };
+
44 
+
45  template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+
46  struct functor2{};
+
47 
+
48  template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+
49  struct functor2<vec, 1, T, Q>
+
50  {
+
51  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)
+
52  {
+
53  return vec<1, T, Q>(Func(a.x, b.x));
+
54  }
+
55  };
+
56 
+
57  template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+
58  struct functor2<vec, 2, T, Q>
+
59  {
+
60  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)
+
61  {
+
62  return vec<2, T, Q>(Func(a.x, b.x), Func(a.y, b.y));
+
63  }
+
64  };
+
65 
+
66  template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+
67  struct functor2<vec, 3, T, Q>
+
68  {
+
69  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)
+
70  {
+
71  return vec<3, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+
72  }
+
73  };
+
74 
+
75  template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+
76  struct functor2<vec, 4, T, Q>
+
77  {
+
78  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)
+
79  {
+
80  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));
+
81  }
+
82  };
+
83 
+
84  template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+
85  struct functor2_vec_sca{};
+
86 
+
87  template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+
88  struct functor2_vec_sca<vec, 1, T, Q>
+
89  {
+
90  GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, T b)
+
91  {
+
92  return vec<1, T, Q>(Func(a.x, b));
+
93  }
+
94  };
+
95 
+
96  template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+
97  struct functor2_vec_sca<vec, 2, T, Q>
+
98  {
+
99  GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, T b)
+
100  {
+
101  return vec<2, T, Q>(Func(a.x, b), Func(a.y, b));
+
102  }
+
103  };
+
104 
+
105  template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+
106  struct functor2_vec_sca<vec, 3, T, Q>
+
107  {
+
108  GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, T b)
+
109  {
+
110  return vec<3, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
+
111  }
+
112  };
+
113 
+
114  template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+
115  struct functor2_vec_sca<vec, 4, T, Q>
+
116  {
+
117  GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, T b)
+
118  {
+
119  return vec<4, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
+
120  }
+
121  };
+
122 
+
123  template<length_t L, typename T, qualifier Q>
+
124  struct functor2_vec_int {};
+
125 
+
126  template<typename T, qualifier Q>
+
127  struct functor2_vec_int<1, T, Q>
+
128  {
+
129  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)
+
130  {
+
131  return vec<1, int, Q>(Func(a.x, b.x));
+
132  }
+
133  };
+
134 
+
135  template<typename T, qualifier Q>
+
136  struct functor2_vec_int<2, T, Q>
+
137  {
+
138  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)
+
139  {
+
140  return vec<2, int, Q>(Func(a.x, b.x), Func(a.y, b.y));
+
141  }
+
142  };
+
143 
+
144  template<typename T, qualifier Q>
+
145  struct functor2_vec_int<3, T, Q>
+
146  {
+
147  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)
+
148  {
+
149  return vec<3, int, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+
150  }
+
151  };
+
152 
+
153  template<typename T, qualifier Q>
+
154  struct functor2_vec_int<4, T, Q>
+
155  {
+
156  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)
+
157  {
+
158  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));
+
159  }
+
160  };
+
161 }//namespace detail
+
162 }//namespace glm
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00007.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00007.html new file mode 100644 index 0000000000000000000000000000000000000000..bd708c8f97cc84c8aebc1961602d1b06d7b4fc09 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00007.html @@ -0,0 +1,205 @@ + + + + + + +0.9.9 API documentation: associated_min_max.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
associated_min_max.hpp File Reference
+
+
+ +

GLM_GTX_associated_min_max +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename T , typename U >
GLM_FUNC_DECL U associatedMax (T x, U a, T y, U b)
 Maximum comparison between 2 variables and returns 2 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< 2, U, Q > associatedMax (vec< L, T, Q > const &x, vec< L, U, Q > const &a, vec< L, T, Q > const &y, vec< L, U, Q > const &b)
 Maximum comparison between 2 variables and returns 2 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > associatedMax (T x, vec< L, U, Q > const &a, T y, vec< L, U, Q > const &b)
 Maximum comparison between 2 variables and returns 2 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMax (vec< L, T, Q > const &x, U a, vec< L, T, Q > const &y, U b)
 Maximum comparison between 2 variables and returns 2 associated variable values. More...
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMax (T x, U a, T y, U b, T z, U c)
 Maximum comparison between 3 variables and returns 3 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMax (vec< L, T, Q > const &x, vec< L, U, Q > const &a, vec< L, T, Q > const &y, vec< L, U, Q > const &b, vec< L, T, Q > const &z, vec< L, U, Q > const &c)
 Maximum comparison between 3 variables and returns 3 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > associatedMax (T x, vec< L, U, Q > const &a, T y, vec< L, U, Q > const &b, T z, vec< L, U, Q > const &c)
 Maximum comparison between 3 variables and returns 3 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMax (vec< L, T, Q > const &x, U a, vec< L, T, Q > const &y, U b, vec< L, T, Q > const &z, U c)
 Maximum comparison between 3 variables and returns 3 associated variable values. More...
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMax (T x, U a, T y, U b, T z, U c, T w, U d)
 Maximum comparison between 4 variables and returns 4 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMax (vec< L, T, Q > const &x, vec< L, U, Q > const &a, vec< L, T, Q > const &y, vec< L, U, Q > const &b, vec< L, T, Q > const &z, vec< L, U, Q > const &c, vec< L, T, Q > const &w, vec< L, U, Q > const &d)
 Maximum comparison between 4 variables and returns 4 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMax (T x, vec< L, U, Q > const &a, T y, vec< L, U, Q > const &b, T z, vec< L, U, Q > const &c, T w, vec< L, U, Q > const &d)
 Maximum comparison between 4 variables and returns 4 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMax (vec< L, T, Q > const &x, U a, vec< L, T, Q > const &y, U b, vec< L, T, Q > const &z, U c, vec< L, T, Q > const &w, U d)
 Maximum comparison between 4 variables and returns 4 associated variable values. More...
 
template<typename T , typename U , qualifier Q>
GLM_FUNC_DECL U associatedMin (T x, U a, T y, U b)
 Minimum comparison between 2 variables and returns 2 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< 2, U, Q > associatedMin (vec< L, T, Q > const &x, vec< L, U, Q > const &a, vec< L, T, Q > const &y, vec< L, U, Q > const &b)
 Minimum comparison between 2 variables and returns 2 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMin (T x, const vec< L, U, Q > &a, T y, const vec< L, U, Q > &b)
 Minimum comparison between 2 variables and returns 2 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMin (vec< L, T, Q > const &x, U a, vec< L, T, Q > const &y, U b)
 Minimum comparison between 2 variables and returns 2 associated variable values. More...
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMin (T x, U a, T y, U b, T z, U c)
 Minimum comparison between 3 variables and returns 3 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMin (vec< L, T, Q > const &x, vec< L, U, Q > const &a, vec< L, T, Q > const &y, vec< L, U, Q > const &b, vec< L, T, Q > const &z, vec< L, U, Q > const &c)
 Minimum comparison between 3 variables and returns 3 associated variable values. More...
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMin (T x, U a, T y, U b, T z, U c, T w, U d)
 Minimum comparison between 4 variables and returns 4 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMin (vec< L, T, Q > const &x, vec< L, U, Q > const &a, vec< L, T, Q > const &y, vec< L, U, Q > const &b, vec< L, T, Q > const &z, vec< L, U, Q > const &c, vec< L, T, Q > const &w, vec< L, U, Q > const &d)
 Minimum comparison between 4 variables and returns 4 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMin (T x, vec< L, U, Q > const &a, T y, vec< L, U, Q > const &b, T z, vec< L, U, Q > const &c, T w, vec< L, U, Q > const &d)
 Minimum comparison between 4 variables and returns 4 associated variable values. More...
 
template<length_t L, typename T , typename U , qualifier Q>
GLM_FUNC_DECL vec< L, U, Q > associatedMin (vec< L, T, Q > const &x, U a, vec< L, T, Q > const &y, U b, vec< L, T, Q > const &z, U c, vec< L, T, Q > const &w, U d)
 Minimum comparison between 4 variables and returns 4 associated variable values. More...
 
+

Detailed Description

+

GLM_GTX_associated_min_max

+
See also
Core features (dependence)
+
+gtx_extented_min_max (dependence)
+ +

Definition in file associated_min_max.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00007_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00007_source.html new file mode 100644 index 0000000000000000000000000000000000000000..45d76a2d85ed1ce3dbb8eed838b61a30a47ecf95 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00007_source.html @@ -0,0 +1,250 @@ + + + + + + +0.9.9 API documentation: associated_min_max.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
associated_min_max.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependency:
+
17 #include "../glm.hpp"
+
18 
+
19 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
20 # ifndef GLM_ENABLE_EXPERIMENTAL
+
21 # pragma message("GLM: GLM_GTX_associated_min_max is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
22 # else
+
23 # pragma message("GLM: GLM_GTX_associated_min_max extension included")
+
24 # endif
+
25 #endif
+
26 
+
27 namespace glm
+
28 {
+
31 
+
34  template<typename T, typename U, qualifier Q>
+
35  GLM_FUNC_DECL U associatedMin(T x, U a, T y, U b);
+
36 
+
39  template<length_t L, typename T, typename U, qualifier Q>
+
40  GLM_FUNC_DECL vec<2, U, Q> associatedMin(
+
41  vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+
42  vec<L, T, Q> const& y, vec<L, U, Q> const& b);
+
43 
+
46  template<length_t L, typename T, typename U, qualifier Q>
+
47  GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+
48  T x, const vec<L, U, Q>& a,
+
49  T y, const vec<L, U, Q>& b);
+
50 
+
53  template<length_t L, typename T, typename U, qualifier Q>
+
54  GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+
55  vec<L, T, Q> const& x, U a,
+
56  vec<L, T, Q> const& y, U b);
+
57 
+
60  template<typename T, typename U>
+
61  GLM_FUNC_DECL U associatedMin(
+
62  T x, U a,
+
63  T y, U b,
+
64  T z, U c);
+
65 
+
68  template<length_t L, typename T, typename U, qualifier Q>
+
69  GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+
70  vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+
71  vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+
72  vec<L, T, Q> const& z, vec<L, U, Q> const& c);
+
73 
+
76  template<typename T, typename U>
+
77  GLM_FUNC_DECL U associatedMin(
+
78  T x, U a,
+
79  T y, U b,
+
80  T z, U c,
+
81  T w, U d);
+
82 
+
85  template<length_t L, typename T, typename U, qualifier Q>
+
86  GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+
87  vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+
88  vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+
89  vec<L, T, Q> const& z, vec<L, U, Q> const& c,
+
90  vec<L, T, Q> const& w, vec<L, U, Q> const& d);
+
91 
+
94  template<length_t L, typename T, typename U, qualifier Q>
+
95  GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+
96  T x, vec<L, U, Q> const& a,
+
97  T y, vec<L, U, Q> const& b,
+
98  T z, vec<L, U, Q> const& c,
+
99  T w, vec<L, U, Q> const& d);
+
100 
+
103  template<length_t L, typename T, typename U, qualifier Q>
+
104  GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+
105  vec<L, T, Q> const& x, U a,
+
106  vec<L, T, Q> const& y, U b,
+
107  vec<L, T, Q> const& z, U c,
+
108  vec<L, T, Q> const& w, U d);
+
109 
+
112  template<typename T, typename U>
+
113  GLM_FUNC_DECL U associatedMax(T x, U a, T y, U b);
+
114 
+
117  template<length_t L, typename T, typename U, qualifier Q>
+
118  GLM_FUNC_DECL vec<2, U, Q> associatedMax(
+
119  vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+
120  vec<L, T, Q> const& y, vec<L, U, Q> const& b);
+
121 
+
124  template<length_t L, typename T, typename U, qualifier Q>
+
125  GLM_FUNC_DECL vec<L, T, Q> associatedMax(
+
126  T x, vec<L, U, Q> const& a,
+
127  T y, vec<L, U, Q> const& b);
+
128 
+
131  template<length_t L, typename T, typename U, qualifier Q>
+
132  GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+
133  vec<L, T, Q> const& x, U a,
+
134  vec<L, T, Q> const& y, U b);
+
135 
+
138  template<typename T, typename U>
+
139  GLM_FUNC_DECL U associatedMax(
+
140  T x, U a,
+
141  T y, U b,
+
142  T z, U c);
+
143 
+
146  template<length_t L, typename T, typename U, qualifier Q>
+
147  GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+
148  vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+
149  vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+
150  vec<L, T, Q> const& z, vec<L, U, Q> const& c);
+
151 
+
154  template<length_t L, typename T, typename U, qualifier Q>
+
155  GLM_FUNC_DECL vec<L, T, Q> associatedMax(
+
156  T x, vec<L, U, Q> const& a,
+
157  T y, vec<L, U, Q> const& b,
+
158  T z, vec<L, U, Q> const& c);
+
159 
+
162  template<length_t L, typename T, typename U, qualifier Q>
+
163  GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+
164  vec<L, T, Q> const& x, U a,
+
165  vec<L, T, Q> const& y, U b,
+
166  vec<L, T, Q> const& z, U c);
+
167 
+
170  template<typename T, typename U>
+
171  GLM_FUNC_DECL U associatedMax(
+
172  T x, U a,
+
173  T y, U b,
+
174  T z, U c,
+
175  T w, U d);
+
176 
+
179  template<length_t L, typename T, typename U, qualifier Q>
+
180  GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+
181  vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+
182  vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+
183  vec<L, T, Q> const& z, vec<L, U, Q> const& c,
+
184  vec<L, T, Q> const& w, vec<L, U, Q> const& d);
+
185 
+
188  template<length_t L, typename T, typename U, qualifier Q>
+
189  GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+
190  T x, vec<L, U, Q> const& a,
+
191  T y, vec<L, U, Q> const& b,
+
192  T z, vec<L, U, Q> const& c,
+
193  T w, vec<L, U, Q> const& d);
+
194 
+
197  template<length_t L, typename T, typename U, qualifier Q>
+
198  GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+
199  vec<L, T, Q> const& x, U a,
+
200  vec<L, T, Q> const& y, U b,
+
201  vec<L, T, Q> const& z, U c,
+
202  vec<L, T, Q> const& w, U d);
+
203 
+
205 } //namespace glm
+
206 
+
207 #include "associated_min_max.inl"
+
GLM_FUNC_DECL vec< L, U, Q > associatedMax(vec< L, T, Q > const &x, U a, vec< L, T, Q > const &y, U b, vec< L, T, Q > const &z, U c, vec< L, T, Q > const &w, U d)
Maximum comparison between 4 variables and returns 4 associated variable values.
+
GLM_FUNC_DECL vec< L, U, Q > associatedMin(vec< L, T, Q > const &x, U a, vec< L, T, Q > const &y, U b, vec< L, T, Q > const &z, U c, vec< L, T, Q > const &w, U d)
Minimum comparison between 4 variables and returns 4 associated variable values.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00008.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00008.html new file mode 100644 index 0000000000000000000000000000000000000000..481484f37b5387e2ffd9c3ee15389128077ffd81 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00008.html @@ -0,0 +1,149 @@ + + + + + + +0.9.9 API documentation: bit.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
bit.hpp File Reference
+
+
+ +

GLM_GTX_bit +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genIUType >
GLM_FUNC_DECL genIUType highestBitValue (genIUType Value)
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > highestBitValue (vec< L, T, Q > const &value)
 Find the highest bit set to 1 in a integer variable and return its value. More...
 
template<typename genIUType >
GLM_FUNC_DECL genIUType lowestBitValue (genIUType Value)
 
template<typename genIUType >
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove (genIUType Value)
 Return the power of two number which value is just higher the input value. More...
 
template<length_t L, typename T , qualifier Q>
GLM_DEPRECATED GLM_FUNC_DECL vec< L, T, Q > powerOfTwoAbove (vec< L, T, Q > const &value)
 Return the power of two number which value is just higher the input value. More...
 
template<typename genIUType >
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow (genIUType Value)
 Return the power of two number which value is just lower the input value. More...
 
template<length_t L, typename T , qualifier Q>
GLM_DEPRECATED GLM_FUNC_DECL vec< L, T, Q > powerOfTwoBelow (vec< L, T, Q > const &value)
 Return the power of two number which value is just lower the input value. More...
 
template<typename genIUType >
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest (genIUType Value)
 Return the power of two number which value is the closet to the input value. More...
 
template<length_t L, typename T , qualifier Q>
GLM_DEPRECATED GLM_FUNC_DECL vec< L, T, Q > powerOfTwoNearest (vec< L, T, Q > const &value)
 Return the power of two number which value is the closet to the input value. More...
 
+

Detailed Description

+

GLM_GTX_bit

+
See also
Core features (dependence)
+ +

Definition in file bit.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00008_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00008_source.html new file mode 100644 index 0000000000000000000000000000000000000000..ea56523dd7a86ef0ca796ffc65b38221d81d18f1 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00008_source.html @@ -0,0 +1,154 @@ + + + + + + +0.9.9 API documentation: bit.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
bit.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependencies
+
16 #include "../gtc/bitfield.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # ifndef GLM_ENABLE_EXPERIMENTAL
+
20 # pragma message("GLM: GLM_GTX_bit is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
21 # else
+
22 # pragma message("GLM: GLM_GTX_bit extension included")
+
23 # endif
+
24 #endif
+
25 
+
26 namespace glm
+
27 {
+
30 
+
32  template<typename genIUType>
+
33  GLM_FUNC_DECL genIUType highestBitValue(genIUType Value);
+
34 
+
36  template<typename genIUType>
+
37  GLM_FUNC_DECL genIUType lowestBitValue(genIUType Value);
+
38 
+
42  template<length_t L, typename T, qualifier Q>
+
43  GLM_FUNC_DECL vec<L, T, Q> highestBitValue(vec<L, T, Q> const& value);
+
44 
+
50  template<typename genIUType>
+
51  GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove(genIUType Value);
+
52 
+
58  template<length_t L, typename T, qualifier Q>
+
59  GLM_DEPRECATED GLM_FUNC_DECL vec<L, T, Q> powerOfTwoAbove(vec<L, T, Q> const& value);
+
60 
+
66  template<typename genIUType>
+
67  GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow(genIUType Value);
+
68 
+
74  template<length_t L, typename T, qualifier Q>
+
75  GLM_DEPRECATED GLM_FUNC_DECL vec<L, T, Q> powerOfTwoBelow(vec<L, T, Q> const& value);
+
76 
+
82  template<typename genIUType>
+
83  GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest(genIUType Value);
+
84 
+
90  template<length_t L, typename T, qualifier Q>
+
91  GLM_DEPRECATED GLM_FUNC_DECL vec<L, T, Q> powerOfTwoNearest(vec<L, T, Q> const& value);
+
92 
+
94 } //namespace glm
+
95 
+
96 
+
97 #include "bit.inl"
+
98 
+
GLM_FUNC_DECL vec< L, T, Q > highestBitValue(vec< L, T, Q > const &value)
Find the highest bit set to 1 in a integer variable and return its value.
+
GLM_DEPRECATED GLM_FUNC_DECL vec< L, T, Q > powerOfTwoBelow(vec< L, T, Q > const &value)
Return the power of two number which value is just lower the input value.
+
GLM_DEPRECATED GLM_FUNC_DECL vec< L, T, Q > powerOfTwoAbove(vec< L, T, Q > const &value)
Return the power of two number which value is just higher the input value.
+
GLM_DEPRECATED GLM_FUNC_DECL vec< L, T, Q > powerOfTwoNearest(vec< L, T, Q > const &value)
Return the power of two number which value is the closet to the input value.
+
GLM_FUNC_DECL genIUType lowestBitValue(genIUType Value)
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00009.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00009.html new file mode 100644 index 0000000000000000000000000000000000000000..429ccf045702d560fb06391efb0f5cedeb86f783 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00009.html @@ -0,0 +1,223 @@ + + + + + + +0.9.9 API documentation: bitfield.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
bitfield.hpp File Reference
+
+
+ +

GLM_GTC_bitfield +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

GLM_FUNC_DECL glm::u8vec2 bitfieldDeinterleave (glm::uint16 x)
 Deinterleaves the bits of x. More...
 
GLM_FUNC_DECL glm::u16vec2 bitfieldDeinterleave (glm::uint32 x)
 Deinterleaves the bits of x. More...
 
GLM_FUNC_DECL glm::u32vec2 bitfieldDeinterleave (glm::uint64 x)
 Deinterleaves the bits of x. More...
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldFillOne (genIUType Value, int FirstBit, int BitCount)
 Set to 1 a range of bits. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > bitfieldFillOne (vec< L, T, Q > const &Value, int FirstBit, int BitCount)
 Set to 1 a range of bits. More...
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldFillZero (genIUType Value, int FirstBit, int BitCount)
 Set to 0 a range of bits. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > bitfieldFillZero (vec< L, T, Q > const &Value, int FirstBit, int BitCount)
 Set to 0 a range of bits. More...
 
GLM_FUNC_DECL int16 bitfieldInterleave (int8 x, int8 y)
 Interleaves the bits of x and y. More...
 
GLM_FUNC_DECL uint16 bitfieldInterleave (uint8 x, uint8 y)
 Interleaves the bits of x and y. More...
 
GLM_FUNC_DECL uint16 bitfieldInterleave (u8vec2 const &v)
 Interleaves the bits of x and y. More...
 
GLM_FUNC_DECL int32 bitfieldInterleave (int16 x, int16 y)
 Interleaves the bits of x and y. More...
 
GLM_FUNC_DECL uint32 bitfieldInterleave (uint16 x, uint16 y)
 Interleaves the bits of x and y. More...
 
GLM_FUNC_DECL uint32 bitfieldInterleave (u16vec2 const &v)
 Interleaves the bits of x and y. More...
 
GLM_FUNC_DECL int64 bitfieldInterleave (int32 x, int32 y)
 Interleaves the bits of x and y. More...
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint32 x, uint32 y)
 Interleaves the bits of x and y. More...
 
GLM_FUNC_DECL uint64 bitfieldInterleave (u32vec2 const &v)
 Interleaves the bits of x and y. More...
 
GLM_FUNC_DECL int32 bitfieldInterleave (int8 x, int8 y, int8 z)
 Interleaves the bits of x, y and z. More...
 
GLM_FUNC_DECL uint32 bitfieldInterleave (uint8 x, uint8 y, uint8 z)
 Interleaves the bits of x, y and z. More...
 
GLM_FUNC_DECL int64 bitfieldInterleave (int16 x, int16 y, int16 z)
 Interleaves the bits of x, y and z. More...
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint16 x, uint16 y, uint16 z)
 Interleaves the bits of x, y and z. More...
 
GLM_FUNC_DECL int64 bitfieldInterleave (int32 x, int32 y, int32 z)
 Interleaves the bits of x, y and z. More...
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint32 x, uint32 y, uint32 z)
 Interleaves the bits of x, y and z. More...
 
GLM_FUNC_DECL int32 bitfieldInterleave (int8 x, int8 y, int8 z, int8 w)
 Interleaves the bits of x, y, z and w. More...
 
GLM_FUNC_DECL uint32 bitfieldInterleave (uint8 x, uint8 y, uint8 z, uint8 w)
 Interleaves the bits of x, y, z and w. More...
 
GLM_FUNC_DECL int64 bitfieldInterleave (int16 x, int16 y, int16 z, int16 w)
 Interleaves the bits of x, y, z and w. More...
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint16 x, uint16 y, uint16 z, uint16 w)
 Interleaves the bits of x, y, z and w. More...
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldRotateLeft (genIUType In, int Shift)
 Rotate all bits to the left. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > bitfieldRotateLeft (vec< L, T, Q > const &In, int Shift)
 Rotate all bits to the left. More...
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldRotateRight (genIUType In, int Shift)
 Rotate all bits to the right. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > bitfieldRotateRight (vec< L, T, Q > const &In, int Shift)
 Rotate all bits to the right. More...
 
template<typename genIUType >
GLM_FUNC_DECL genIUType mask (genIUType Bits)
 Build a mask of 'count' bits. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > mask (vec< L, T, Q > const &v)
 Build a mask of 'count' bits. More...
 
+

Detailed Description

+

GLM_GTC_bitfield

+
See also
Core features (dependence)
+
+GLM_GTC_bitfield (dependence)
+ +

Definition in file bitfield.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00009_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00009_source.html new file mode 100644 index 0000000000000000000000000000000000000000..ba21496124e311c7be22a7f5cace6aa94bce8dbe --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00009_source.html @@ -0,0 +1,212 @@ + + + + + + +0.9.9 API documentation: bitfield.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
bitfield.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #include "../detail/setup.hpp"
+
15 
+
16 #pragma once
+
17 
+
18 // Dependencies
+
19 #include "../ext/scalar_int_sized.hpp"
+
20 #include "../ext/scalar_uint_sized.hpp"
+
21 #include "../detail/qualifier.hpp"
+
22 #include "../detail/_vectorize.hpp"
+
23 #include "type_precision.hpp"
+
24 #include <limits>
+
25 
+
26 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
27 # pragma message("GLM: GLM_GTC_bitfield extension included")
+
28 #endif
+
29 
+
30 namespace glm
+
31 {
+
34 
+
38  template<typename genIUType>
+
39  GLM_FUNC_DECL genIUType mask(genIUType Bits);
+
40 
+
48  template<length_t L, typename T, qualifier Q>
+
49  GLM_FUNC_DECL vec<L, T, Q> mask(vec<L, T, Q> const& v);
+
50 
+
54  template<typename genIUType>
+
55  GLM_FUNC_DECL genIUType bitfieldRotateRight(genIUType In, int Shift);
+
56 
+
64  template<length_t L, typename T, qualifier Q>
+
65  GLM_FUNC_DECL vec<L, T, Q> bitfieldRotateRight(vec<L, T, Q> const& In, int Shift);
+
66 
+
70  template<typename genIUType>
+
71  GLM_FUNC_DECL genIUType bitfieldRotateLeft(genIUType In, int Shift);
+
72 
+
80  template<length_t L, typename T, qualifier Q>
+
81  GLM_FUNC_DECL vec<L, T, Q> bitfieldRotateLeft(vec<L, T, Q> const& In, int Shift);
+
82 
+
86  template<typename genIUType>
+
87  GLM_FUNC_DECL genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount);
+
88 
+
96  template<length_t L, typename T, qualifier Q>
+
97  GLM_FUNC_DECL vec<L, T, Q> bitfieldFillOne(vec<L, T, Q> const& Value, int FirstBit, int BitCount);
+
98 
+
102  template<typename genIUType>
+
103  GLM_FUNC_DECL genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount);
+
104 
+
112  template<length_t L, typename T, qualifier Q>
+
113  GLM_FUNC_DECL vec<L, T, Q> bitfieldFillZero(vec<L, T, Q> const& Value, int FirstBit, int BitCount);
+
114 
+
120  GLM_FUNC_DECL int16 bitfieldInterleave(int8 x, int8 y);
+
121 
+
127  GLM_FUNC_DECL uint16 bitfieldInterleave(uint8 x, uint8 y);
+
128 
+
134  GLM_FUNC_DECL uint16 bitfieldInterleave(u8vec2 const& v);
+
135 
+ +
140 
+
146  GLM_FUNC_DECL int32 bitfieldInterleave(int16 x, int16 y);
+
147 
+
153  GLM_FUNC_DECL uint32 bitfieldInterleave(uint16 x, uint16 y);
+
154 
+
160  GLM_FUNC_DECL uint32 bitfieldInterleave(u16vec2 const& v);
+
161 
+ +
166 
+
172  GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y);
+
173 
+
179  GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y);
+
180 
+
186  GLM_FUNC_DECL uint64 bitfieldInterleave(u32vec2 const& v);
+
187 
+ +
192 
+
198  GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z);
+
199 
+
205  GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z);
+
206 
+
212  GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z);
+
213 
+
219  GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z);
+
220 
+
226  GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y, int32 z);
+
227 
+
233  GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z);
+
234 
+
240  GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w);
+
241 
+
247  GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w);
+
248 
+
254  GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w);
+
255 
+
261  GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w);
+
262 
+
264 } //namespace glm
+
265 
+
266 #include "bitfield.inl"
+
detail::uint32 uint32
32 bit unsigned integer type.
+
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)
Interleaves the bits of x, y, z and w.
+
GLM_FUNC_DECL glm::u32vec2 bitfieldDeinterleave(glm::uint64 x)
Deinterleaves the bits of x.
+
GLM_FUNC_DECL vec< L, T, Q > bitfieldFillZero(vec< L, T, Q > const &Value, int FirstBit, int BitCount)
Set to 0 a range of bits.
+
detail::uint16 uint16
16 bit unsigned integer type.
+
vec< 2, u8, defaultp > u8vec2
Default qualifier 8 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:340
+
GLM_FUNC_DECL vec< L, T, Q > bitfieldRotateLeft(vec< L, T, Q > const &In, int Shift)
Rotate all bits to the left.
+
GLM_FUNC_DECL vec< L, T, Q > mask(vec< L, T, Q > const &v)
Build a mask of 'count' bits.
+
detail::uint64 uint64
64 bit unsigned integer type.
+
GLM_FUNC_DECL vec< L, T, Q > bitfieldFillOne(vec< L, T, Q > const &Value, int FirstBit, int BitCount)
Set to 1 a range of bits.
+
GLM_GTC_type_precision
+
detail::int64 int64
64 bit signed integer type.
+
vec< 2, u32, defaultp > u32vec2
Default qualifier 32 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:380
+
GLM_FUNC_DECL vec< L, T, Q > bitfieldRotateRight(vec< L, T, Q > const &In, int Shift)
Rotate all bits to the right.
+
vec< 2, u16, defaultp > u16vec2
Default qualifier 16 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:360
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00010.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00010.html new file mode 100644 index 0000000000000000000000000000000000000000..427c3ad1a25a9de8cb66e8657cf16dc307d39720 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00010.html @@ -0,0 +1,124 @@ + + + + + + +0.9.9 API documentation: closest_point.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
closest_point.hpp File Reference
+
+
+ +

GLM_GTX_closest_point +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + +

+Functions

template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > closestPointOnLine (vec< 3, T, Q > const &point, vec< 3, T, Q > const &a, vec< 3, T, Q > const &b)
 Find the point on a straight line which is the closet of a point. More...
 
+template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 2, T, Q > closestPointOnLine (vec< 2, T, Q > const &point, vec< 2, T, Q > const &a, vec< 2, T, Q > const &b)
 2d lines work as well
 
+

Detailed Description

+

GLM_GTX_closest_point

+
See also
Core features (dependence)
+ +

Definition in file closest_point.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00010_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00010_source.html new file mode 100644 index 0000000000000000000000000000000000000000..57de3ceb74e17b7ff8279f2f530cb857b73213a3 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00010_source.html @@ -0,0 +1,133 @@ + + + + + + +0.9.9 API documentation: closest_point.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
closest_point.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../glm.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # ifndef GLM_ENABLE_EXPERIMENTAL
+
20 # pragma message("GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
21 # else
+
22 # pragma message("GLM: GLM_GTX_closest_point extension included")
+
23 # endif
+
24 #endif
+
25 
+
26 namespace glm
+
27 {
+
30 
+
33  template<typename T, qualifier Q>
+
34  GLM_FUNC_DECL vec<3, T, Q> closestPointOnLine(
+
35  vec<3, T, Q> const& point,
+
36  vec<3, T, Q> const& a,
+
37  vec<3, T, Q> const& b);
+
38 
+
40  template<typename T, qualifier Q>
+
41  GLM_FUNC_DECL vec<2, T, Q> closestPointOnLine(
+
42  vec<2, T, Q> const& point,
+
43  vec<2, T, Q> const& a,
+
44  vec<2, T, Q> const& b);
+
45 
+
47 }// namespace glm
+
48 
+
49 #include "closest_point.inl"
+
GLM_FUNC_DECL vec< 2, T, Q > closestPointOnLine(vec< 2, T, Q > const &point, vec< 2, T, Q > const &a, vec< 2, T, Q > const &b)
2d lines work as well
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00011.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00011.html new file mode 100644 index 0000000000000000000000000000000000000000..fc81397e7ea7a268e46571d248a229c2a847a6ce --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00011.html @@ -0,0 +1,137 @@ + + + + + + +0.9.9 API documentation: color_encoding.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
color_encoding.hpp File Reference
+
+
+ +

GLM_GTX_color_encoding +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + +

+Functions

+template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > convertD65XYZToD50XYZ (vec< 3, T, Q > const &ColorD65XYZ)
 Convert a D65 YUV color to D50 YUV.
 
+template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > convertD65XYZToLinearSRGB (vec< 3, T, Q > const &ColorD65XYZ)
 Convert a D65 YUV color to linear sRGB.
 
+template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > convertLinearSRGBToD50XYZ (vec< 3, T, Q > const &ColorLinearSRGB)
 Convert a linear sRGB color to D50 YUV.
 
+template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > convertLinearSRGBToD65XYZ (vec< 3, T, Q > const &ColorLinearSRGB)
 Convert a linear sRGB color to D65 YUV.
 
+

Detailed Description

+

GLM_GTX_color_encoding

+
See also
Core features (dependence)
+
+GLM_GTX_color_encoding (dependence)
+ +

Definition in file color_encoding.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00011_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00011_source.html new file mode 100644 index 0000000000000000000000000000000000000000..0deaac4561b2f7ecdcb70120196f42eca0ef149b --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00011_source.html @@ -0,0 +1,139 @@ + + + + + + +0.9.9 API documentation: color_encoding.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
color_encoding.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependencies
+
17 #include "../detail/setup.hpp"
+
18 #include "../detail/qualifier.hpp"
+
19 #include "../vec3.hpp"
+
20 #include <limits>
+
21 
+
22 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
23 # ifndef GLM_ENABLE_EXPERIMENTAL
+
24 # pragma message("GLM: GLM_GTC_color_encoding is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
25 # else
+
26 # pragma message("GLM: GLM_GTC_color_encoding extension included")
+
27 # endif
+
28 #endif
+
29 
+
30 namespace glm
+
31 {
+
34 
+
36  template<typename T, qualifier Q>
+
37  GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB);
+
38 
+
40  template<typename T, qualifier Q>
+
41  GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB);
+
42 
+
44  template<typename T, qualifier Q>
+
45  GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ);
+
46 
+
48  template<typename T, qualifier Q>
+
49  GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ);
+
50 
+
52 } //namespace glm
+
53 
+
54 #include "color_encoding.inl"
+
GLM_FUNC_DECL vec< 3, T, Q > convertD65XYZToLinearSRGB(vec< 3, T, Q > const &ColorD65XYZ)
Convert a D65 YUV color to linear sRGB.
+
GLM_FUNC_DECL vec< 3, T, Q > convertLinearSRGBToD50XYZ(vec< 3, T, Q > const &ColorLinearSRGB)
Convert a linear sRGB color to D50 YUV.
+
GLM_FUNC_DECL vec< 3, T, Q > convertLinearSRGBToD65XYZ(vec< 3, T, Q > const &ColorLinearSRGB)
Convert a linear sRGB color to D65 YUV.
+
GLM_FUNC_DECL vec< 3, T, Q > convertD65XYZToD50XYZ(vec< 3, T, Q > const &ColorD65XYZ)
Convert a D65 YUV color to D50 YUV.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00012.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00012.html new file mode 100644 index 0000000000000000000000000000000000000000..4262e1e95256213c5e04ff9a0ac223f12a46d499 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00012.html @@ -0,0 +1,134 @@ + + + + + + +0.9.9 API documentation: color_space.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
gtc/color_space.hpp File Reference
+
+
+ +

GLM_GTC_color_space +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + +

+Functions

template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > convertLinearToSRGB (vec< L, T, Q > const &ColorLinear)
 Convert a linear color to sRGB color using a standard gamma correction. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > convertLinearToSRGB (vec< L, T, Q > const &ColorLinear, T Gamma)
 Convert a linear color to sRGB color using a custom gamma correction. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > convertSRGBToLinear (vec< L, T, Q > const &ColorSRGB)
 Convert a sRGB color to linear color using a standard gamma correction. More...
 
+template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > convertSRGBToLinear (vec< L, T, Q > const &ColorSRGB, T Gamma)
 Convert a sRGB color to linear color using a custom gamma correction.
 
+

Detailed Description

+

GLM_GTC_color_space

+
See also
Core features (dependence)
+
+GLM_GTC_color_space (dependence)
+ +

Definition in file gtc/color_space.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00012_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00012_source.html new file mode 100644 index 0000000000000000000000000000000000000000..8f864b9f51152b704930f5a0a8ea1b2035713a11 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00012_source.html @@ -0,0 +1,136 @@ + + + + + + +0.9.9 API documentation: color_space.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
gtc/color_space.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependencies
+
17 #include "../detail/setup.hpp"
+
18 #include "../detail/qualifier.hpp"
+
19 #include "../exponential.hpp"
+
20 #include "../vec3.hpp"
+
21 #include "../vec4.hpp"
+
22 #include <limits>
+
23 
+
24 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
25 # pragma message("GLM: GLM_GTC_color_space extension included")
+
26 #endif
+
27 
+
28 namespace glm
+
29 {
+
32 
+
35  template<length_t L, typename T, qualifier Q>
+
36  GLM_FUNC_DECL vec<L, T, Q> convertLinearToSRGB(vec<L, T, Q> const& ColorLinear);
+
37 
+
40  template<length_t L, typename T, qualifier Q>
+
41  GLM_FUNC_DECL vec<L, T, Q> convertLinearToSRGB(vec<L, T, Q> const& ColorLinear, T Gamma);
+
42 
+
45  template<length_t L, typename T, qualifier Q>
+
46  GLM_FUNC_DECL vec<L, T, Q> convertSRGBToLinear(vec<L, T, Q> const& ColorSRGB);
+
47 
+
49  // IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
+
50  template<length_t L, typename T, qualifier Q>
+
51  GLM_FUNC_DECL vec<L, T, Q> convertSRGBToLinear(vec<L, T, Q> const& ColorSRGB, T Gamma);
+
52 
+
54 } //namespace glm
+
55 
+
56 #include "color_space.inl"
+
GLM_FUNC_DECL vec< L, T, Q > convertLinearToSRGB(vec< L, T, Q > const &ColorLinear, T Gamma)
Convert a linear color to sRGB color using a custom gamma correction.
+
GLM_FUNC_DECL vec< L, T, Q > convertSRGBToLinear(vec< L, T, Q > const &ColorSRGB, T Gamma)
Convert a sRGB color to linear color using a custom gamma correction.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00013.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00013.html new file mode 100644 index 0000000000000000000000000000000000000000..0c20995098783a442341dd98625ae5dfc03ec23e --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00013.html @@ -0,0 +1,139 @@ + + + + + + +0.9.9 API documentation: color_space.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
gtx/color_space.hpp File Reference
+
+
+ +

GLM_GTX_color_space +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > hsvColor (vec< 3, T, Q > const &rgbValue)
 Converts a color from RGB color space to its color in HSV color space. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL T luminosity (vec< 3, T, Q > const &color)
 Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > rgbColor (vec< 3, T, Q > const &hsvValue)
 Converts a color from HSV color space to its color in RGB color space. More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > saturation (T const s)
 Build a saturation matrix. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > saturation (T const s, vec< 3, T, Q > const &color)
 Modify the saturation of a color. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 4, T, Q > saturation (T const s, vec< 4, T, Q > const &color)
 Modify the saturation of a color. More...
 
+

Detailed Description

+

GLM_GTX_color_space

+
See also
Core features (dependence)
+ +

Definition in file gtx/color_space.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00013_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00013_source.html new file mode 100644 index 0000000000000000000000000000000000000000..e85a56589f1232038d495ff7e8da42f14c63f816 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00013_source.html @@ -0,0 +1,150 @@ + + + + + + +0.9.9 API documentation: color_space.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
gtx/color_space.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../glm.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # ifndef GLM_ENABLE_EXPERIMENTAL
+
20 # pragma message("GLM: GLM_GTX_color_space is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
21 # else
+
22 # pragma message("GLM: GLM_GTX_color_space extension included")
+
23 # endif
+
24 #endif
+
25 
+
26 namespace glm
+
27 {
+
30 
+
33  template<typename T, qualifier Q>
+
34  GLM_FUNC_DECL vec<3, T, Q> rgbColor(
+
35  vec<3, T, Q> const& hsvValue);
+
36 
+
39  template<typename T, qualifier Q>
+
40  GLM_FUNC_DECL vec<3, T, Q> hsvColor(
+
41  vec<3, T, Q> const& rgbValue);
+
42 
+
45  template<typename T>
+
46  GLM_FUNC_DECL mat<4, 4, T, defaultp> saturation(
+
47  T const s);
+
48 
+
51  template<typename T, qualifier Q>
+
52  GLM_FUNC_DECL vec<3, T, Q> saturation(
+
53  T const s,
+
54  vec<3, T, Q> const& color);
+
55 
+
58  template<typename T, qualifier Q>
+
59  GLM_FUNC_DECL vec<4, T, Q> saturation(
+
60  T const s,
+
61  vec<4, T, Q> const& color);
+
62 
+
65  template<typename T, qualifier Q>
+
66  GLM_FUNC_DECL T luminosity(
+
67  vec<3, T, Q> const& color);
+
68 
+
70 }//namespace glm
+
71 
+
72 #include "color_space.inl"
+
GLM_FUNC_DECL T luminosity(vec< 3, T, Q > const &color)
Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
+
GLM_FUNC_DECL vec< 4, T, Q > saturation(T const s, vec< 4, T, Q > const &color)
Modify the saturation of a color.
+
GLM_FUNC_DECL vec< 3, T, Q > rgbColor(vec< 3, T, Q > const &hsvValue)
Converts a color from HSV color space to its color in RGB color space.
+
GLM_FUNC_DECL vec< 3, T, Q > hsvColor(vec< 3, T, Q > const &rgbValue)
Converts a color from RGB color space to its color in HSV color space.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00014.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00014.html new file mode 100644 index 0000000000000000000000000000000000000000..5e838b7a09eaed5e326e3824e2c8ebf193b2ee1f --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00014.html @@ -0,0 +1,131 @@ + + + + + + +0.9.9 API documentation: color_space_YCoCg.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
color_space_YCoCg.hpp File Reference
+
+
+ +

GLM_GTX_color_space_YCoCg +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + +

+Functions

template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > rgb2YCoCg (vec< 3, T, Q > const &rgbColor)
 Convert a color from RGB color space to YCoCg color space. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > rgb2YCoCgR (vec< 3, T, Q > const &rgbColor)
 Convert a color from RGB color space to YCoCgR color space. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > YCoCg2rgb (vec< 3, T, Q > const &YCoCgColor)
 Convert a color from YCoCg color space to RGB color space. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > YCoCgR2rgb (vec< 3, T, Q > const &YCoCgColor)
 Convert a color from YCoCgR color space to RGB color space. More...
 
+

Detailed Description

+

GLM_GTX_color_space_YCoCg

+
See also
Core features (dependence)
+ +

Definition in file color_space_YCoCg.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00014_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00014_source.html new file mode 100644 index 0000000000000000000000000000000000000000..903a7d9b707e7d77f6b456b9fd3110ed63f8d94f --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00014_source.html @@ -0,0 +1,141 @@ + + + + + + +0.9.9 API documentation: color_space_YCoCg.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
color_space_YCoCg.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../glm.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # ifndef GLM_ENABLE_EXPERIMENTAL
+
20 # pragma message("GLM: GLM_GTX_color_space_YCoCg is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
21 # else
+
22 # pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
+
23 # endif
+
24 #endif
+
25 
+
26 namespace glm
+
27 {
+
30 
+
33  template<typename T, qualifier Q>
+
34  GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCg(
+
35  vec<3, T, Q> const& rgbColor);
+
36 
+
39  template<typename T, qualifier Q>
+
40  GLM_FUNC_DECL vec<3, T, Q> YCoCg2rgb(
+
41  vec<3, T, Q> const& YCoCgColor);
+
42 
+
46  template<typename T, qualifier Q>
+
47  GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCgR(
+
48  vec<3, T, Q> const& rgbColor);
+
49 
+
53  template<typename T, qualifier Q>
+
54  GLM_FUNC_DECL vec<3, T, Q> YCoCgR2rgb(
+
55  vec<3, T, Q> const& YCoCgColor);
+
56 
+
58 }//namespace glm
+
59 
+
60 #include "color_space_YCoCg.inl"
+
GLM_FUNC_DECL vec< 3, T, Q > YCoCgR2rgb(vec< 3, T, Q > const &YCoCgColor)
Convert a color from YCoCgR color space to RGB color space.
+
GLM_FUNC_DECL vec< 3, T, Q > YCoCg2rgb(vec< 3, T, Q > const &YCoCgColor)
Convert a color from YCoCg color space to RGB color space.
+
GLM_FUNC_DECL vec< 3, T, Q > rgbColor(vec< 3, T, Q > const &hsvValue)
Converts a color from HSV color space to its color in RGB color space.
+
GLM_FUNC_DECL vec< 3, T, Q > rgb2YCoCg(vec< 3, T, Q > const &rgbColor)
Convert a color from RGB color space to YCoCg color space.
+
GLM_FUNC_DECL vec< 3, T, Q > rgb2YCoCgR(vec< 3, T, Q > const &rgbColor)
Convert a color from RGB color space to YCoCgR color space.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00015.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00015.html new file mode 100644 index 0000000000000000000000000000000000000000..0f9e2256d5a8e1e636279d89cc972c2ce73e1098 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00015.html @@ -0,0 +1,267 @@ + + + + + + +0.9.9 API documentation: common.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
common.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType abs (genType x)
 Returns x if x >= 0; otherwise, it returns -x. More...
 
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 x if x >= 0; otherwise, it returns -x. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > ceil (vec< L, T, Q > const &x)
 Returns a value equal to the nearest integer that is greater than or equal to x. More...
 
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. More...
 
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. More...
 
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)
 Returns min(max(x, minVal), maxVal) for each component in x using the floating-point values minVal and maxVal. More...
 
GLM_FUNC_DECL int floatBitsToInt (float const &v)
 Returns a signed integer value representing the encoding of a floating-point value. More...
 
template<length_t L, qualifier Q>
GLM_FUNC_DECL vec< L, int, Q > floatBitsToInt (vec< L, float, Q > const &v)
 Returns a signed integer value representing the encoding of a floating-point value. More...
 
GLM_FUNC_DECL uint floatBitsToUint (float const &v)
 Returns a unsigned integer value representing the encoding of a floating-point value. More...
 
template<length_t L, qualifier Q>
GLM_FUNC_DECL vec< L, uint, Q > floatBitsToUint (vec< L, float, Q > const &v)
 Returns a unsigned integer value representing the encoding of a floating-point value. More...
 
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 that is less then or equal to x. More...
 
template<typename genType >
GLM_FUNC_DECL genType fma (genType const &a, genType const &b, genType const &c)
 Computes and returns a * b + c. More...
 
template<typename genType >
GLM_FUNC_DECL genType fract (genType x)
 Return x - floor(x). More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fract (vec< L, T, Q > const &x)
 Return x - floor(x). More...
 
template<typename genType >
GLM_FUNC_DECL genType frexp (genType x, int &exp)
 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) More...
 
GLM_FUNC_DECL float intBitsToFloat (int const &v)
 Returns a floating-point value corresponding to a signed integer encoding of a floating-point value. More...
 
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 signed integer encoding of a floating-point value. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, bool, Q > isinf (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. More...
 
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 NaN (not a number) representation in the underlying implementation's set of floating point representations. More...
 
template<typename genType >
GLM_FUNC_DECL genType ldexp (genType const &x, int const &exp)
 Builds a floating-point number from x and the corresponding integral exponent of two in exp, returning: significand * exp(2, exponent) More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType max (genType x, genType y)
 Returns y if x < y; otherwise, it returns x. More...
 
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. More...
 
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 y if x < y; otherwise, it returns x. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType min (genType x, genType y)
 Returns y if y < x; otherwise, it returns x. More...
 
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. More...
 
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 y < x; otherwise, it returns x. More...
 
template<typename genTypeT , typename genTypeU >
GLM_FUNC_DECL genTypeT mix (genTypeT x, genTypeT y, genTypeU a)
 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. More...
 
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)
 Modulus. More...
 
template<typename genType >
GLM_FUNC_DECL genType modf (genType x, genType &i)
 Returns the fractional part of x and sets i to the integer part (as a whole number floating point value). More...
 
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. More...
 
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 to x. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > sign (vec< L, T, Q > const &x)
 Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. More...
 
template<typename genType >
GLM_FUNC_DECL genType smoothstep (genType edge0, genType edge1, genType 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. More...
 
template<typename genType >
GLM_FUNC_DECL genType step (genType edge, genType x)
 Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType. More...
 
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. More...
 
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 < edge, otherwise it returns 1.0. More...
 
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 whose absolute value is not larger than the absolute value of x. More...
 
GLM_FUNC_DECL float uintBitsToFloat (uint const &v)
 Returns a floating-point value corresponding to a unsigned integer encoding of a floating-point value. More...
 
template<length_t L, qualifier Q>
GLM_FUNC_DECL vec< L, float, Q > uintBitsToFloat (vec< L, uint, Q > const &v)
 Returns a floating-point value corresponding to a unsigned integer encoding of a floating-point value. More...
 
+

Detailed Description

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00015_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00015_source.html new file mode 100644 index 0000000000000000000000000000000000000000..6bc9d1035797ebfc57a53bc8b5f7d3af9fd1f5c4 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00015_source.html @@ -0,0 +1,276 @@ + + + + + + +0.9.9 API documentation: common.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
common.hpp
+
+
+Go to the documentation of this file.
1 
+
15 #pragma once
+
16 
+
17 #include "detail/qualifier.hpp"
+
18 #include "detail/_fixes.hpp"
+
19 
+
20 namespace glm
+
21 {
+
24 
+
31  template<typename genType>
+
32  GLM_FUNC_DECL GLM_CONSTEXPR genType abs(genType x);
+
33 
+
42  template<length_t L, typename T, qualifier Q>
+
43  GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> abs(vec<L, T, Q> const& x);
+
44 
+
53  template<length_t L, typename T, qualifier Q>
+
54  GLM_FUNC_DECL vec<L, T, Q> sign(vec<L, T, Q> const& x);
+
55 
+
64  template<length_t L, typename T, qualifier Q>
+
65  GLM_FUNC_DECL vec<L, T, Q> floor(vec<L, T, Q> const& x);
+
66 
+
76  template<length_t L, typename T, qualifier Q>
+
77  GLM_FUNC_DECL vec<L, T, Q> trunc(vec<L, T, Q> const& x);
+
78 
+
91  template<length_t L, typename T, qualifier Q>
+
92  GLM_FUNC_DECL vec<L, T, Q> round(vec<L, T, Q> const& x);
+
93 
+
105  template<length_t L, typename T, qualifier Q>
+
106  GLM_FUNC_DECL vec<L, T, Q> roundEven(vec<L, T, Q> const& x);
+
107 
+
117  template<length_t L, typename T, qualifier Q>
+
118  GLM_FUNC_DECL vec<L, T, Q> ceil(vec<L, T, Q> const& x);
+
119 
+
126  template<typename genType>
+
127  GLM_FUNC_DECL genType fract(genType x);
+
128 
+
137  template<length_t L, typename T, qualifier Q>
+
138  GLM_FUNC_DECL vec<L, T, Q> fract(vec<L, T, Q> const& x);
+
139 
+
140  template<typename genType>
+
141  GLM_FUNC_DECL genType mod(genType x, genType y);
+
142 
+
143  template<length_t L, typename T, qualifier Q>
+
144  GLM_FUNC_DECL vec<L, T, Q> mod(vec<L, T, Q> const& x, T y);
+
145 
+
155  template<length_t L, typename T, qualifier Q>
+
156  GLM_FUNC_DECL vec<L, T, Q> mod(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
157 
+
167  template<typename genType>
+
168  GLM_FUNC_DECL genType modf(genType x, genType& i);
+
169 
+
176  template<typename genType>
+
177  GLM_FUNC_DECL GLM_CONSTEXPR genType min(genType x, genType y);
+
178 
+
187  template<length_t L, typename T, qualifier Q>
+
188  GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& x, T y);
+
189 
+
198  template<length_t L, typename T, qualifier Q>
+
199  GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
200 
+
207  template<typename genType>
+
208  GLM_FUNC_DECL GLM_CONSTEXPR genType max(genType x, genType y);
+
209 
+
218  template<length_t L, typename T, qualifier Q>
+
219  GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, T y);
+
220 
+
229  template<length_t L, typename T, qualifier Q>
+
230  GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
231 
+
239  template<typename genType>
+
240  GLM_FUNC_DECL GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal);
+
241 
+
251  template<length_t L, typename T, qualifier Q>
+
252  GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, T minVal, T maxVal);
+
253 
+
263  template<length_t L, typename T, qualifier Q>
+
264  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);
+
265 
+
308  template<typename genTypeT, typename genTypeU>
+
309  GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
+
310 
+
311  template<length_t L, typename T, typename U, qualifier Q>
+
312  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);
+
313 
+
314  template<length_t L, typename T, typename U, qualifier Q>
+
315  GLM_FUNC_DECL vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a);
+
316 
+
321  template<typename genType>
+
322  GLM_FUNC_DECL genType step(genType edge, genType x);
+
323 
+
332  template<length_t L, typename T, qualifier Q>
+
333  GLM_FUNC_DECL vec<L, T, Q> step(T edge, vec<L, T, Q> const& x);
+
334 
+
343  template<length_t L, typename T, qualifier Q>
+
344  GLM_FUNC_DECL vec<L, T, Q> step(vec<L, T, Q> const& edge, vec<L, T, Q> const& x);
+
345 
+
360  template<typename genType>
+
361  GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x);
+
362 
+
363  template<length_t L, typename T, qualifier Q>
+
364  GLM_FUNC_DECL vec<L, T, Q> smoothstep(T edge0, T edge1, vec<L, T, Q> const& x);
+
365 
+
366  template<length_t L, typename T, qualifier Q>
+
367  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);
+
368 
+
383  template<length_t L, typename T, qualifier Q>
+
384  GLM_FUNC_DECL vec<L, bool, Q> isnan(vec<L, T, Q> const& x);
+
385 
+
398  template<length_t L, typename T, qualifier Q>
+
399  GLM_FUNC_DECL vec<L, bool, Q> isinf(vec<L, T, Q> const& x);
+
400 
+
407  GLM_FUNC_DECL int floatBitsToInt(float const& v);
+
408 
+
418  template<length_t L, qualifier Q>
+
419  GLM_FUNC_DECL vec<L, int, Q> floatBitsToInt(vec<L, float, Q> const& v);
+
420 
+
427  GLM_FUNC_DECL uint floatBitsToUint(float const& v);
+
428 
+
438  template<length_t L, qualifier Q>
+
439  GLM_FUNC_DECL vec<L, uint, Q> floatBitsToUint(vec<L, float, Q> const& v);
+
440 
+
449  GLM_FUNC_DECL float intBitsToFloat(int const& v);
+
450 
+
462  template<length_t L, qualifier Q>
+
463  GLM_FUNC_DECL vec<L, float, Q> intBitsToFloat(vec<L, int, Q> const& v);
+
464 
+
473  GLM_FUNC_DECL float uintBitsToFloat(uint const& v);
+
474 
+
486  template<length_t L, qualifier Q>
+
487  GLM_FUNC_DECL vec<L, float, Q> uintBitsToFloat(vec<L, uint, Q> const& v);
+
488 
+
495  template<typename genType>
+
496  GLM_FUNC_DECL genType fma(genType const& a, genType const& b, genType const& c);
+
497 
+
512  template<typename genType>
+
513  GLM_FUNC_DECL genType frexp(genType x, int& exp);
+
514 
+
515  template<length_t L, typename T, qualifier Q>
+
516  GLM_FUNC_DECL vec<L, T, Q> frexp(vec<L, T, Q> const& v, vec<L, int, Q>& exp);
+
517 
+
529  template<typename genType>
+
530  GLM_FUNC_DECL genType ldexp(genType const& x, int const& exp);
+
531 
+
532  template<length_t L, typename T, qualifier Q>
+
533  GLM_FUNC_DECL vec<L, T, Q> ldexp(vec<L, T, Q> const& v, vec<L, int, Q> const& exp);
+
534 
+
536 }//namespace glm
+
537 
+
538 #include "detail/func_common.inl"
+
539 
+
GLM_FUNC_DECL vec< L, T, Q > floor(vec< L, T, Q > const &x)
Returns a value equal to the nearest integer that is less then or equal to x.
+
GLM_FUNC_DECL genType fma(genType const &a, genType const &b, genType const &c)
Computes and returns a * b + c.
+
GLM_FUNC_DECL vec< L, T, Q > trunc(vec< L, T, Q > const &x)
Returns a value equal to the nearest integer to x whose absolute value is not larger than the absolut...
+
GLM_FUNC_DECL vec< L, T, Q > mod(vec< L, T, Q > const &x, vec< L, T, Q > const &y)
Modulus.
+
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)
Returns min(max(x, minVal), maxVal) for each component in x using the floating-point values minVal an...
+
GLM_FUNC_DECL vec< L, T, Q > round(vec< L, T, Q > const &x)
Returns a value equal to the nearest integer to x.
+
GLM_FUNC_DECL vec< L, float, Q > uintBitsToFloat(vec< L, uint, Q > const &v)
Returns a floating-point value corresponding to a unsigned integer encoding of a floating-point value...
+
GLM_FUNC_DECL vec< L, T, Q > sign(vec< L, T, Q > const &x)
Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
+
GLM_FUNC_DECL vec< L, bool, Q > isinf(vec< L, T, Q > const &x)
Returns true if x holds a positive infinity or negative infinity representation in the underlying imp...
+
GLM_FUNC_DECL vec< L, T, Q > roundEven(vec< L, T, Q > const &x)
Returns a value equal to the nearest integer to x.
+
GLM_FUNC_DECL genType modf(genType x, genType &i)
Returns the fractional part of x and sets i to the integer part (as a whole number floating point val...
+
GLM_FUNC_DECL vec< L, T, Q > ceil(vec< L, T, Q > const &x)
Returns a value equal to the nearest integer that is greater than or equal to x.
+
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 y < x; otherwise, it returns x.
+
GLM_FUNC_DECL vec< L, float, Q > intBitsToFloat(vec< L, int, Q > const &v)
Returns a floating-point value corresponding to a signed integer encoding of a floating-point value...
+
GLM_FUNC_DECL vec< L, bool, Q > isnan(vec< L, T, Q > const &x)
Returns true if x holds a NaN (not a number) representation in the underlying implementation's set of...
+
GLM_FUNC_DECL vec< L, T, Q > exp(vec< L, T, Q > const &v)
Returns the natural exponentiation of x, i.e., e^x.
+
GLM_FUNC_DECL vec< L, uint, Q > floatBitsToUint(vec< L, float, Q > const &v)
Returns a unsigned integer value representing the encoding of a floating-point value.
+
GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x)
Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation between 0 a...
+
GLM_FUNC_DECL GLM_CONSTEXPR vec< L, T, Q > abs(vec< L, T, Q > const &x)
Returns x if x >= 0; otherwise, it returns -x.
+
GLM_FUNC_DECL GLM_CONSTEXPR vec< L, T, Q > max(vec< L, T, Q > const &x, vec< L, T, Q > const &y)
Returns y if x < y; otherwise, it returns x.
+
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 < edge, otherwise it returns 1.0.
+
GLM_FUNC_DECL vec< L, T, Q > fract(vec< L, T, Q > const &x)
Return x - floor(x).
+
GLM_FUNC_DECL genType ldexp(genType const &x, int const &exp)
Builds a floating-point number from x and the corresponding integral exponent of two in exp...
+
GLM_FUNC_DECL vec< L, int, Q > floatBitsToInt(vec< L, float, Q > const &v)
Returns a signed integer value representing the encoding of a floating-point value.
+
GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a)
If genTypeU is a floating scalar or vector: Returns x * (1.0 - a) + y * a, i.e., the linear blend of ...
+
GLM_FUNC_DECL genType frexp(genType x, int &exp)
Splits x into a floating-point significand in the range [0.5, 1.0) and an integral exponent of two...
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00016.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00016.html new file mode 100644 index 0000000000000000000000000000000000000000..82bb37508646dfcda23fe391bc3f2e311f2b4a8e --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00016.html @@ -0,0 +1,131 @@ + + + + + + +0.9.9 API documentation: common.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
gtx/common.hpp File Reference
+
+
+ +

GLM_GTX_common +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + +

+Functions

template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, bool, Q > closeBounded (vec< L, T, Q > const &Value, vec< L, T, Q > const &Min, vec< L, T, Q > const &Max)
 Returns whether vector components values are within an interval. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fmod (vec< L, T, Q > const &v)
 Similar to 'mod' but with a different rounding and integer support. More...
 
template<typename genType >
GLM_FUNC_DECL genType::bool_type isdenormal (genType const &x)
 Returns true if x is a denormalized number Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, bool, Q > openBounded (vec< L, T, Q > const &Value, vec< L, T, Q > const &Min, vec< L, T, Q > const &Max)
 Returns whether vector components values are within an interval. More...
 
+

Detailed Description

+

GLM_GTX_common

+
See also
Core features (dependence)
+ +

Definition in file gtx/common.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00016_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00016_source.html new file mode 100644 index 0000000000000000000000000000000000000000..0833436df8a1f2e160ededec3c67233f09eea1b4 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00016_source.html @@ -0,0 +1,139 @@ + + + + + + +0.9.9 API documentation: common.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
gtx/common.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependencies:
+
16 #include "../vec2.hpp"
+
17 #include "../vec3.hpp"
+
18 #include "../vec4.hpp"
+
19 #include "../gtc/vec1.hpp"
+
20 
+
21 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
22 # ifndef GLM_ENABLE_EXPERIMENTAL
+
23 # pragma message("GLM: GLM_GTX_common is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
24 # else
+
25 # pragma message("GLM: GLM_GTX_common extension included")
+
26 # endif
+
27 #endif
+
28 
+
29 namespace glm
+
30 {
+
33 
+
42  template<typename genType>
+
43  GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const& x);
+
44 
+
50  template<length_t L, typename T, qualifier Q>
+
51  GLM_FUNC_DECL vec<L, T, Q> fmod(vec<L, T, Q> const& v);
+
52 
+
60  template <length_t L, typename T, qualifier Q>
+
61  GLM_FUNC_DECL vec<L, bool, Q> openBounded(vec<L, T, Q> const& Value, vec<L, T, Q> const& Min, vec<L, T, Q> const& Max);
+
62 
+
70  template <length_t L, typename T, qualifier Q>
+
71  GLM_FUNC_DECL vec<L, bool, Q> closeBounded(vec<L, T, Q> const& Value, vec<L, T, Q> const& Min, vec<L, T, Q> const& Max);
+
72 
+
74 }//namespace glm
+
75 
+
76 #include "common.inl"
+
GLM_FUNC_DECL vec< L, T, Q > fmod(vec< L, T, Q > const &v)
Similar to 'mod' but with a different rounding and integer support.
+
GLM_FUNC_DECL vec< L, bool, Q > openBounded(vec< L, T, Q > const &Value, vec< L, T, Q > const &Min, vec< L, T, Q > const &Max)
Returns whether vector components values are within an interval.
+
GLM_FUNC_DECL genType::bool_type isdenormal(genType const &x)
Returns true if x is a denormalized number Numbers whose absolute value is too small to be represente...
+
Definition: common.hpp:20
+
GLM_FUNC_DECL vec< L, bool, Q > closeBounded(vec< L, T, Q > const &Value, vec< L, T, Q > const &Min, vec< L, T, Q > const &Max)
Returns whether vector components values are within an interval.
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00017.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00017.html new file mode 100644 index 0000000000000000000000000000000000000000..f5eda22a3411c5ed20cada98ed9f9104f981582e --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00017.html @@ -0,0 +1,443 @@ + + + + + + +0.9.9 API documentation: compatibility.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
compatibility.hpp File Reference
+
+
+ +

GLM_GTX_compatibility +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Typedefs

+typedef bool bool1
 boolean type with 1 component. (From GLM_GTX_compatibility extension)
 
+typedef bool bool1x1
 boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
 
+typedef vec< 2, bool, highp > bool2
 boolean type with 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 2, bool, highp > bool2x2
 boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 3, bool, highp > bool2x3
 boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 4, bool, highp > bool2x4
 boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef vec< 3, bool, highp > bool3
 boolean type with 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 2, bool, highp > bool3x2
 boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 3, bool, highp > bool3x3
 boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 4, bool, highp > bool3x4
 boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef vec< 4, bool, highp > bool4
 boolean type with 4 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 2, bool, highp > bool4x2
 boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 3, bool, highp > bool4x3
 boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 4, bool, highp > bool4x4
 boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef double double1
 double-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
 
+typedef double double1x1
 double-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
 
+typedef vec< 2, double, highp > double2
 double-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 2, double, highp > double2x2
 double-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 3, double, highp > double2x3
 double-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 4, double, highp > double2x4
 double-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef vec< 3, double, highp > double3
 double-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 2, double, highp > double3x2
 double-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 3, double, highp > double3x3
 double-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 4, double, highp > double3x4
 double-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef vec< 4, double, highp > double4
 double-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 2, double, highp > double4x2
 double-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 3, double, highp > double4x3
 double-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 4, double, highp > double4x4
 double-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef float float1
 single-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
 
+typedef float float1x1
 single-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
 
+typedef vec< 2, float, highp > float2
 single-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 2, float, highp > float2x2
 single-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 3, float, highp > float2x3
 single-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 4, float, highp > float2x4
 single-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef vec< 3, float, highp > float3
 single-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 2, float, highp > float3x2
 single-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 3, float, highp > float3x3
 single-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 4, float, highp > float3x4
 single-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef vec< 4, float, highp > float4
 single-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 2, float, highp > float4x2
 single-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 3, float, highp > float4x3
 single-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 4, float, highp > float4x4
 single-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef int int1
 integer vector with 1 component. (From GLM_GTX_compatibility extension)
 
+typedef int int1x1
 integer matrix with 1 component. (From GLM_GTX_compatibility extension)
 
+typedef vec< 2, int, highp > int2
 integer vector with 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 2, int, highp > int2x2
 integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 3, int, highp > int2x3
 integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 2, 4, int, highp > int2x4
 integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef vec< 3, int, highp > int3
 integer vector with 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 2, int, highp > int3x2
 integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 3, int, highp > int3x3
 integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 3, 4, int, highp > int3x4
 integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
 
+typedef vec< 4, int, highp > int4
 integer vector with 4 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 2, int, highp > int4x2
 integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 3, int, highp > int4x3
 integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
 
+typedef mat< 4, 4, int, highp > int4x4
 integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER T atan2 (T x, T y)
 Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 2, T, Q > atan2 (const vec< 2, T, Q > &x, const vec< 2, T, Q > &y)
 Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 3, T, Q > atan2 (const vec< 3, T, Q > &x, const vec< 3, T, Q > &y)
 Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 4, T, Q > atan2 (const vec< 4, T, Q > &x, const vec< 4, T, Q > &y)
 Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
 
+template<typename genType >
GLM_FUNC_DECL bool isfinite (genType const &x)
 Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 1, bool, Q > isfinite (const vec< 1, T, Q > &x)
 Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 2, bool, Q > isfinite (const vec< 2, T, Q > &x)
 Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, bool, Q > isfinite (const vec< 3, T, Q > &x)
 Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 4, bool, Q > isfinite (const vec< 4, T, Q > &x)
 Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
 
+template<typename T >
GLM_FUNC_QUALIFIER T lerp (T x, T y, T a)
 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]. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 2, T, Q > lerp (const vec< 2, T, Q > &x, const vec< 2, T, Q > &y, T a)
 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]. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 3, T, Q > lerp (const vec< 3, T, Q > &x, const vec< 3, T, Q > &y, T a)
 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]. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 4, T, Q > lerp (const vec< 4, T, Q > &x, const vec< 4, T, Q > &y, T a)
 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]. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 2, T, Q > lerp (const vec< 2, T, Q > &x, const vec< 2, T, Q > &y, const vec< 2, T, Q > &a)
 Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 3, T, Q > lerp (const vec< 3, T, Q > &x, const vec< 3, T, Q > &y, const vec< 3, T, Q > &a)
 Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 4, T, Q > lerp (const vec< 4, T, Q > &x, const vec< 4, T, Q > &y, const vec< 4, T, Q > &a)
 Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER T saturate (T x)
 Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 2, T, Q > saturate (const vec< 2, T, Q > &x)
 Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 3, T, Q > saturate (const vec< 3, T, Q > &x)
 Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
 
+template<typename T , qualifier Q>
GLM_FUNC_QUALIFIER vec< 4, T, Q > saturate (const vec< 4, T, Q > &x)
 Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
 
+

Detailed Description

+

GLM_GTX_compatibility

+
See also
Core features (dependence)
+ +

Definition in file compatibility.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00017_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00017_source.html new file mode 100644 index 0000000000000000000000000000000000000000..206d3954f9949fdd18833b6a929bbdbf9f28703f --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00017_source.html @@ -0,0 +1,282 @@ + + + + + + +0.9.9 API documentation: compatibility.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
compatibility.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../glm.hpp"
+
17 #include "../gtc/quaternion.hpp"
+
18 
+
19 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
20 # ifndef GLM_ENABLE_EXPERIMENTAL
+
21 # pragma message("GLM: GLM_GTX_compatibility is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
22 # else
+
23 # pragma message("GLM: GLM_GTX_compatibility extension included")
+
24 # endif
+
25 #endif
+
26 
+
27 #if GLM_COMPILER & GLM_COMPILER_VC
+
28 # include <cfloat>
+
29 #elif GLM_COMPILER & GLM_COMPILER_GCC
+
30 # include <cmath>
+
31 # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+
32 # undef isfinite
+
33 # endif
+
34 #endif//GLM_COMPILER
+
35 
+
36 namespace glm
+
37 {
+
40 
+
41  template<typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}
+
42  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<2, T, Q>& y, T a){return mix(x, y, a);}
+
43 
+
44  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<3, T, Q>& y, T a){return mix(x, y, a);}
+
45  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<4, T, Q>& y, T a){return mix(x, y, a);}
+
46  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<2, T, Q>& y, const vec<2, T, Q>& a){return mix(x, y, a);}
+
47  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<3, T, Q>& y, const vec<3, T, Q>& a){return mix(x, y, a);}
+
48  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<4, T, Q>& y, const vec<4, T, Q>& a){return mix(x, y, a);}
+
49 
+
50  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}
+
51  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<2, T, Q> saturate(const vec<2, T, Q>& x){return clamp(x, T(0), T(1));}
+
52  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<3, T, Q> saturate(const vec<3, T, Q>& x){return clamp(x, T(0), T(1));}
+
53  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<4, T, Q> saturate(const vec<4, T, Q>& x){return clamp(x, T(0), T(1));}
+
54 
+
55  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}
+
56  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<2, T, Q> atan2(const vec<2, T, Q>& x, const vec<2, T, Q>& y){return atan(x, y);}
+
57  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<3, T, Q> atan2(const vec<3, T, Q>& x, const vec<3, T, Q>& y){return atan(x, y);}
+
58  template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<4, T, Q> atan2(const vec<4, T, Q>& x, const vec<4, T, Q>& y){return atan(x, y);}
+
59 
+
60  template<typename genType> GLM_FUNC_DECL bool isfinite(genType const& x);
+
61  template<typename T, qualifier Q> GLM_FUNC_DECL vec<1, bool, Q> isfinite(const vec<1, T, Q>& x);
+
62  template<typename T, qualifier Q> GLM_FUNC_DECL vec<2, bool, Q> isfinite(const vec<2, T, Q>& x);
+
63  template<typename T, qualifier Q> GLM_FUNC_DECL vec<3, bool, Q> isfinite(const vec<3, T, Q>& x);
+
64  template<typename T, qualifier Q> GLM_FUNC_DECL vec<4, bool, Q> isfinite(const vec<4, T, Q>& x);
+
65 
+
66  typedef bool bool1;
+
67  typedef vec<2, bool, highp> bool2;
+
68  typedef vec<3, bool, highp> bool3;
+
69  typedef vec<4, bool, highp> bool4;
+
70 
+
71  typedef bool bool1x1;
+
72  typedef mat<2, 2, bool, highp> bool2x2;
+
73  typedef mat<2, 3, bool, highp> bool2x3;
+
74  typedef mat<2, 4, bool, highp> bool2x4;
+
75  typedef mat<3, 2, bool, highp> bool3x2;
+
76  typedef mat<3, 3, bool, highp> bool3x3;
+
77  typedef mat<3, 4, bool, highp> bool3x4;
+
78  typedef mat<4, 2, bool, highp> bool4x2;
+
79  typedef mat<4, 3, bool, highp> bool4x3;
+
80  typedef mat<4, 4, bool, highp> bool4x4;
+
81 
+
82  typedef int int1;
+
83  typedef vec<2, int, highp> int2;
+
84  typedef vec<3, int, highp> int3;
+
85  typedef vec<4, int, highp> int4;
+
86 
+
87  typedef int int1x1;
+
88  typedef mat<2, 2, int, highp> int2x2;
+
89  typedef mat<2, 3, int, highp> int2x3;
+
90  typedef mat<2, 4, int, highp> int2x4;
+
91  typedef mat<3, 2, int, highp> int3x2;
+
92  typedef mat<3, 3, int, highp> int3x3;
+
93  typedef mat<3, 4, int, highp> int3x4;
+
94  typedef mat<4, 2, int, highp> int4x2;
+
95  typedef mat<4, 3, int, highp> int4x3;
+
96  typedef mat<4, 4, int, highp> int4x4;
+
97 
+
98  typedef float float1;
+
99  typedef vec<2, float, highp> float2;
+
100  typedef vec<3, float, highp> float3;
+
101  typedef vec<4, float, highp> float4;
+
102 
+
103  typedef float float1x1;
+
104  typedef mat<2, 2, float, highp> float2x2;
+
105  typedef mat<2, 3, float, highp> float2x3;
+
106  typedef mat<2, 4, float, highp> float2x4;
+
107  typedef mat<3, 2, float, highp> float3x2;
+
108  typedef mat<3, 3, float, highp> float3x3;
+
109  typedef mat<3, 4, float, highp> float3x4;
+
110  typedef mat<4, 2, float, highp> float4x2;
+
111  typedef mat<4, 3, float, highp> float4x3;
+
112  typedef mat<4, 4, float, highp> float4x4;
+
113 
+
114  typedef double double1;
+
115  typedef vec<2, double, highp> double2;
+
116  typedef vec<3, double, highp> double3;
+
117  typedef vec<4, double, highp> double4;
+
118 
+
119  typedef double double1x1;
+
120  typedef mat<2, 2, double, highp> double2x2;
+
121  typedef mat<2, 3, double, highp> double2x3;
+
122  typedef mat<2, 4, double, highp> double2x4;
+
123  typedef mat<3, 2, double, highp> double3x2;
+
124  typedef mat<3, 3, double, highp> double3x3;
+
125  typedef mat<3, 4, double, highp> double3x4;
+
126  typedef mat<4, 2, double, highp> double4x2;
+
127  typedef mat<4, 3, double, highp> double4x3;
+
128  typedef mat<4, 4, double, highp> double4x4;
+
129 
+
131 }//namespace glm
+
132 
+
133 #include "compatibility.inl"
+
mat< 4, 4, double, highp > double4x4
double-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) ...
+
mat< 3, 4, int, highp > int3x4
integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+
GLM_FUNC_DECL vec< L, T, Q > atan(vec< L, T, Q > const &y, vec< L, T, Q > const &x)
Arc tangent.
+
bool bool1
boolean type with 1 component. (From GLM_GTX_compatibility extension)
+
mat< 4, 3, float, highp > float4x3
single-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) ...
+
mat< 4, 4, float, highp > float4x4
single-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) ...
+
mat< 2, 4, double, highp > double2x4
double-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) ...
+
mat< 2, 2, double, highp > double2x2
double-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) ...
+
mat< 3, 2, double, highp > double3x2
double-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) ...
+
GLM_FUNC_QUALIFIER vec< 4, T, Q > atan2(const vec< 4, T, Q > &x, const vec< 4, T, Q > &y)
Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what q...
+
double double1x1
double-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) ...
+
GLM_FUNC_QUALIFIER vec< 4, T, Q > lerp(const vec< 4, T, Q > &x, const vec< 4, T, Q > &y, const vec< 4, T, Q > &a)
Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using v...
+
mat< 3, 3, double, highp > double3x3
double-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) ...
+
vec< 4, float, highp > float4
single-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension) ...
+
int int1x1
integer matrix with 1 component. (From GLM_GTX_compatibility extension)
+
vec< 2, float, highp > float2
single-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension) ...
+
GLM_FUNC_DECL vec< 4, bool, Q > isfinite(const vec< 4, T, Q > &x)
Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)...
+
mat< 2, 3, bool, highp > bool2x3
boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+
mat< 2, 3, int, highp > int2x3
integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+
int int1
integer vector with 1 component. (From GLM_GTX_compatibility extension)
+
vec< 3, float, highp > float3
single-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension) ...
+
mat< 2, 4, float, highp > float2x4
single-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) ...
+
mat< 2, 2, bool, highp > bool2x2
boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+
mat< 4, 4, bool, highp > bool4x4
boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
float float1
single-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension) ...
+
float float1x1
single-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) ...
+
mat< 4, 2, double, highp > double4x2
double-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) ...
+
mat< 4, 3, int, highp > int4x3
integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+
mat< 4, 2, bool, highp > bool4x2
boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+
mat< 2, 2, float, highp > float2x2
single-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) ...
+
vec< 3, int, highp > int3
integer vector with 3 components. (From GLM_GTX_compatibility extension)
+
mat< 4, 2, float, highp > float4x2
single-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) ...
+
mat< 2, 3, double, highp > double2x3
double-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) ...
+
mat< 2, 3, float, highp > float2x3
single-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) ...
+
mat< 3, 2, int, highp > int3x2
integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+
vec< 4, bool, highp > bool4
boolean type with 4 components. (From GLM_GTX_compatibility extension)
+
mat< 4, 2, int, highp > int4x2
integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+
bool bool1x1
boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
+
GLM_FUNC_QUALIFIER vec< 4, T, Q > saturate(const vec< 4, T, Q > &x)
Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+
vec< 3, bool, highp > bool3
boolean type with 3 components. (From GLM_GTX_compatibility extension)
+
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 an...
+
mat< 2, 2, int, highp > int2x2
integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+
vec< 2, int, highp > int2
integer vector with 2 components. (From GLM_GTX_compatibility extension)
+
mat< 4, 4, int, highp > int4x4
integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
mat< 3, 2, bool, highp > bool3x2
boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+
mat< 4, 3, double, highp > double4x3
double-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) ...
+
mat< 4, 3, bool, highp > bool4x3
boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+
double double1
double-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension) ...
+
vec< 3, double, highp > double3
double-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension) ...
+
vec< 4, double, highp > double4
double-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension) ...
+
mat< 3, 3, int, highp > int3x3
integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+
mat< 3, 3, bool, highp > bool3x3
boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+
mat< 3, 2, float, highp > float3x2
single-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) ...
+
vec< 4, int, highp > int4
integer vector with 4 components. (From GLM_GTX_compatibility extension)
+
vec< 2, double, highp > double2
double-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension) ...
+
mat< 3, 3, float, highp > float3x3
single-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) ...
+
GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a)
If genTypeU is a floating scalar or vector: Returns x * (1.0 - a) + y * a, i.e., the linear blend of ...
+
vec< 2, bool, highp > bool2
boolean type with 2 components. (From GLM_GTX_compatibility extension)
+
mat< 3, 4, bool, highp > bool3x4
boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+
mat< 2, 4, int, highp > int2x4
integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+
mat< 2, 4, bool, highp > bool2x4
boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+
mat< 3, 4, double, highp > double3x4
double-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) ...
+
Definition: common.hpp:20
+
mat< 3, 4, float, highp > float3x4
single-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) ...
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00018.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00018.html new file mode 100644 index 0000000000000000000000000000000000000000..5d5fd80405c2821a9ffd30bac56b9bfa9d43fade --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00018.html @@ -0,0 +1,141 @@ + + + + + + +0.9.9 API documentation: component_wise.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
component_wise.hpp File Reference
+
+
+ +

GLM_GTX_component_wise +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL genType::value_type compAdd (genType const &v)
 Add all vector components together. More...
 
template<typename genType >
GLM_FUNC_DECL genType::value_type compMax (genType const &v)
 Find the maximum value between single vector components. More...
 
template<typename genType >
GLM_FUNC_DECL genType::value_type compMin (genType const &v)
 Find the minimum value between single vector components. More...
 
template<typename genType >
GLM_FUNC_DECL genType::value_type compMul (genType const &v)
 Multiply all vector components together. More...
 
template<typename floatType , length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, floatType, Q > compNormalize (vec< L, T, Q > const &v)
 Convert an integer vector to a normalized float vector. More...
 
template<length_t L, typename T , typename floatType , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > compScale (vec< L, floatType, Q > const &v)
 Convert a normalized float vector to an integer vector. More...
 
+

Detailed Description

+

GLM_GTX_component_wise

+
Date
2007-05-21 / 2011-06-07
+
Author
Christophe Riccio
+
See also
Core features (dependence)
+ +

Definition in file component_wise.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00018_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00018_source.html new file mode 100644 index 0000000000000000000000000000000000000000..81414087d564a2b219ccd627a0e44a2b3a150f6e --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00018_source.html @@ -0,0 +1,145 @@ + + + + + + +0.9.9 API documentation: component_wise.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
component_wise.hpp
+
+
+Go to the documentation of this file.
1 
+
15 #pragma once
+
16 
+
17 // Dependencies
+
18 #include "../detail/setup.hpp"
+
19 #include "../detail/qualifier.hpp"
+
20 
+
21 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
22 # ifndef GLM_ENABLE_EXPERIMENTAL
+
23 # pragma message("GLM: GLM_GTX_component_wise is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
24 # else
+
25 # pragma message("GLM: GLM_GTX_component_wise extension included")
+
26 # endif
+
27 #endif
+
28 
+
29 namespace glm
+
30 {
+
33 
+
37  template<typename floatType, length_t L, typename T, qualifier Q>
+
38  GLM_FUNC_DECL vec<L, floatType, Q> compNormalize(vec<L, T, Q> const& v);
+
39 
+
43  template<length_t L, typename T, typename floatType, qualifier Q>
+
44  GLM_FUNC_DECL vec<L, T, Q> compScale(vec<L, floatType, Q> const& v);
+
45 
+
48  template<typename genType>
+
49  GLM_FUNC_DECL typename genType::value_type compAdd(genType const& v);
+
50 
+
53  template<typename genType>
+
54  GLM_FUNC_DECL typename genType::value_type compMul(genType const& v);
+
55 
+
58  template<typename genType>
+
59  GLM_FUNC_DECL typename genType::value_type compMin(genType const& v);
+
60 
+
63  template<typename genType>
+
64  GLM_FUNC_DECL typename genType::value_type compMax(genType const& v);
+
65 
+
67 }//namespace glm
+
68 
+
69 #include "component_wise.inl"
+
GLM_FUNC_DECL genType::value_type compMax(genType const &v)
Find the maximum value between single vector components.
+
GLM_FUNC_DECL genType::value_type compMul(genType const &v)
Multiply all vector components together.
+
GLM_FUNC_DECL vec< L, T, Q > compScale(vec< L, floatType, Q > const &v)
Convert a normalized float vector to an integer vector.
+
GLM_FUNC_DECL vec< L, floatType, Q > compNormalize(vec< L, T, Q > const &v)
Convert an integer vector to a normalized float vector.
+
GLM_FUNC_DECL genType::value_type compMin(genType const &v)
Find the minimum value between single vector components.
+
GLM_FUNC_DECL genType::value_type compAdd(genType const &v)
Add all vector components together.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00019_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00019_source.html new file mode 100644 index 0000000000000000000000000000000000000000..d2fd66f722e3726d067af8fe407daa7d0bfeb668 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00019_source.html @@ -0,0 +1,150 @@ + + + + + + +0.9.9 API documentation: compute_common.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
compute_common.hpp
+
+
+
1 #pragma once
+
2 
+
3 #include "setup.hpp"
+
4 #include <limits>
+
5 
+
6 namespace glm{
+
7 namespace detail
+
8 {
+
9  template<typename genFIType, bool /*signed*/>
+
10  struct compute_abs
+
11  {};
+
12 
+
13  template<typename genFIType>
+
14  struct compute_abs<genFIType, true>
+
15  {
+
16  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
+
17  {
+
18  GLM_STATIC_ASSERT(
+
19  std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed,
+
20  "'abs' only accept floating-point and integer scalar or vector inputs");
+
21 
+
22  return x >= genFIType(0) ? x : -x;
+
23  // TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
+
24  }
+
25  };
+
26 
+
27 #if GLM_COMPILER & GLM_COMPILER_CUDA
+
28  template<>
+
29  struct compute_abs<float, true>
+
30  {
+
31  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static float call(float x)
+
32  {
+
33  return fabsf(x);
+
34  }
+
35  };
+
36 #endif
+
37 
+
38  template<typename genFIType>
+
39  struct compute_abs<genFIType, false>
+
40  {
+
41  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
+
42  {
+
43  GLM_STATIC_ASSERT(
+
44  (!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
+
45  "'abs' only accept floating-point and integer scalar or vector inputs");
+
46  return x;
+
47  }
+
48  };
+
49 }//namespace detail
+
50 }//namespace glm
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00020_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00020_source.html new file mode 100644 index 0000000000000000000000000000000000000000..049fde6eae2850dd8cc8638daa45dfdbc75c54fb --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00020_source.html @@ -0,0 +1,130 @@ + + + + + + +0.9.9 API documentation: compute_vector_relational.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
compute_vector_relational.hpp
+
+
+
1 #pragma once
+
2 
+
3 //#include "compute_common.hpp"
+
4 #include "setup.hpp"
+
5 #include <limits>
+
6 
+
7 namespace glm{
+
8 namespace detail
+
9 {
+
10  template <typename T, bool isFloat>
+
11  struct compute_equal
+
12  {
+
13  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b)
+
14  {
+
15  return a == b;
+
16  }
+
17  };
+
18 /*
+
19  template <typename T>
+
20  struct compute_equal<T, true>
+
21  {
+
22  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b)
+
23  {
+
24  return detail::compute_abs<T, std::numeric_limits<T>::is_signed>::call(b - a) <= static_cast<T>(0);
+
25  //return std::memcmp(&a, &b, sizeof(T)) == 0;
+
26  }
+
27  };
+
28 */
+
29 }//namespace detail
+
30 }//namespace glm
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00021.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00021.html new file mode 100644 index 0000000000000000000000000000000000000000..0203aaad51abc80e657a6dfdfaac4aadb040e757 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00021.html @@ -0,0 +1,223 @@ + + + + + + +0.9.9 API documentation: constants.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
constants.hpp File Reference
+
+
+ +

GLM_GTC_constants +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType e ()
 Return e constant. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType euler ()
 Return Euler's constant. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType four_over_pi ()
 Return 4 / pi. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType golden_ratio ()
 Return the golden ratio constant. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType half_pi ()
 Return pi / 2. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ln_two ()
 Return ln(ln(2)). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ten ()
 Return ln(10). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_two ()
 Return ln(2). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType one ()
 Return 1. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_pi ()
 Return 1 / pi. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_root_two ()
 Return 1 / sqrt(2). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_two_pi ()
 Return 1 / (pi * 2). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType quarter_pi ()
 Return pi / 4. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType root_five ()
 Return sqrt(5). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType root_half_pi ()
 Return sqrt(pi / 2). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType root_ln_four ()
 Return sqrt(ln(4)). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType root_pi ()
 Return square root of pi. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType root_three ()
 Return sqrt(3). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType root_two ()
 Return sqrt(2). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType root_two_pi ()
 Return sqrt(2 * pi). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType third ()
 Return 1 / 3. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType three_over_two_pi ()
 Return pi / 2 * 3. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_pi ()
 Return 2 / pi. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_root_pi ()
 Return 2 / sqrt(pi). More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType two_pi ()
 Return pi * 2. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType two_thirds ()
 Return 2 / 3. More...
 
template<typename genType >
GLM_FUNC_DECL GLM_CONSTEXPR genType zero ()
 Return 0. More...
 
+

Detailed Description

+

GLM_GTC_constants

+
See also
Core features (dependence)
+ +

Definition in file constants.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00021_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00021_source.html new file mode 100644 index 0000000000000000000000000000000000000000..67c7767d74c304ea63a31f9ea1dbabdf45f89b77 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00021_source.html @@ -0,0 +1,224 @@ + + + + + + +0.9.9 API documentation: constants.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
constants.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependencies
+
16 #include "../ext/scalar_constants.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # pragma message("GLM: GLM_GTC_constants extension included")
+
20 #endif
+
21 
+
22 namespace glm
+
23 {
+
26 
+
29  template<typename genType>
+
30  GLM_FUNC_DECL GLM_CONSTEXPR genType zero();
+
31 
+
34  template<typename genType>
+
35  GLM_FUNC_DECL GLM_CONSTEXPR genType one();
+
36 
+
39  template<typename genType>
+
40  GLM_FUNC_DECL GLM_CONSTEXPR genType two_pi();
+
41 
+
44  template<typename genType>
+
45  GLM_FUNC_DECL GLM_CONSTEXPR genType root_pi();
+
46 
+
49  template<typename genType>
+
50  GLM_FUNC_DECL GLM_CONSTEXPR genType half_pi();
+
51 
+
54  template<typename genType>
+
55  GLM_FUNC_DECL GLM_CONSTEXPR genType three_over_two_pi();
+
56 
+
59  template<typename genType>
+
60  GLM_FUNC_DECL GLM_CONSTEXPR genType quarter_pi();
+
61 
+
64  template<typename genType>
+
65  GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_pi();
+
66 
+
69  template<typename genType>
+
70  GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_two_pi();
+
71 
+
74  template<typename genType>
+
75  GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_pi();
+
76 
+
79  template<typename genType>
+
80  GLM_FUNC_DECL GLM_CONSTEXPR genType four_over_pi();
+
81 
+
84  template<typename genType>
+
85  GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_root_pi();
+
86 
+
89  template<typename genType>
+
90  GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_root_two();
+
91 
+
94  template<typename genType>
+
95  GLM_FUNC_DECL GLM_CONSTEXPR genType root_half_pi();
+
96 
+
99  template<typename genType>
+
100  GLM_FUNC_DECL GLM_CONSTEXPR genType root_two_pi();
+
101 
+
104  template<typename genType>
+
105  GLM_FUNC_DECL GLM_CONSTEXPR genType root_ln_four();
+
106 
+
109  template<typename genType>
+
110  GLM_FUNC_DECL GLM_CONSTEXPR genType e();
+
111 
+
114  template<typename genType>
+
115  GLM_FUNC_DECL GLM_CONSTEXPR genType euler();
+
116 
+
119  template<typename genType>
+
120  GLM_FUNC_DECL GLM_CONSTEXPR genType root_two();
+
121 
+
124  template<typename genType>
+
125  GLM_FUNC_DECL GLM_CONSTEXPR genType root_three();
+
126 
+
129  template<typename genType>
+
130  GLM_FUNC_DECL GLM_CONSTEXPR genType root_five();
+
131 
+
134  template<typename genType>
+
135  GLM_FUNC_DECL GLM_CONSTEXPR genType ln_two();
+
136 
+
139  template<typename genType>
+
140  GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ten();
+
141 
+
144  template<typename genType>
+
145  GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ln_two();
+
146 
+
149  template<typename genType>
+
150  GLM_FUNC_DECL GLM_CONSTEXPR genType third();
+
151 
+
154  template<typename genType>
+
155  GLM_FUNC_DECL GLM_CONSTEXPR genType two_thirds();
+
156 
+
159  template<typename genType>
+
160  GLM_FUNC_DECL GLM_CONSTEXPR genType golden_ratio();
+
161 
+
163 } //namespace glm
+
164 
+
165 #include "constants.inl"
+
GLM_FUNC_DECL GLM_CONSTEXPR genType third()
Return 1 / 3.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType root_two()
Return sqrt(2).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_root_two()
Return 1 / sqrt(2).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType euler()
Return Euler's constant.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType two_thirds()
Return 2 / 3.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType two_pi()
Return pi * 2.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType golden_ratio()
Return the golden ratio constant.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType quarter_pi()
Return pi / 4.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType one()
Return 1.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType root_five()
Return sqrt(5).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType three_over_two_pi()
Return pi / 2 * 3.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType zero()
Return 0.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ten()
Return ln(10).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType root_three()
Return sqrt(3).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType root_pi()
Return square root of pi.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType e()
Return e constant.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_pi()
Return 1 / pi.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_pi()
Return 2 / pi.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType four_over_pi()
Return 4 / pi.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType root_two_pi()
Return sqrt(2 * pi).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_two()
Return ln(2).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType root_ln_four()
Return sqrt(ln(4)).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_root_pi()
Return 2 / sqrt(pi).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ln_two()
Return ln(ln(2)).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType root_half_pi()
Return sqrt(pi / 2).
+
GLM_FUNC_DECL GLM_CONSTEXPR genType half_pi()
Return pi / 2.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_two_pi()
Return 1 / (pi * 2).
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00022.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00022.html new file mode 100644 index 0000000000000000000000000000000000000000..450161283be50f67638a10be708d41d94b8e7cc1 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00022.html @@ -0,0 +1,192 @@ + + + + + + +0.9.9 API documentation: dual_quaternion.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
dual_quaternion.hpp File Reference
+
+
+ +

GLM_GTX_dual_quaternion +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Typedefs

typedef highp_ddualquat ddualquat
 Dual-quaternion of default double-qualifier floating-point numbers. More...
 
typedef highp_fdualquat dualquat
 Dual-quaternion of floating-point numbers. More...
 
typedef highp_fdualquat fdualquat
 Dual-quaternion of single-qualifier floating-point numbers. More...
 
typedef tdualquat< double, highp > highp_ddualquat
 Dual-quaternion of high double-qualifier floating-point numbers. More...
 
typedef tdualquat< float, highp > highp_dualquat
 Dual-quaternion of high single-qualifier floating-point numbers. More...
 
typedef tdualquat< float, highp > highp_fdualquat
 Dual-quaternion of high single-qualifier floating-point numbers. More...
 
typedef tdualquat< double, lowp > lowp_ddualquat
 Dual-quaternion of low double-qualifier floating-point numbers. More...
 
typedef tdualquat< float, lowp > lowp_dualquat
 Dual-quaternion of low single-qualifier floating-point numbers. More...
 
typedef tdualquat< float, lowp > lowp_fdualquat
 Dual-quaternion of low single-qualifier floating-point numbers. More...
 
typedef tdualquat< double, mediump > mediump_ddualquat
 Dual-quaternion of medium double-qualifier floating-point numbers. More...
 
typedef tdualquat< float, mediump > mediump_dualquat
 Dual-quaternion of medium single-qualifier floating-point numbers. More...
 
typedef tdualquat< float, mediump > mediump_fdualquat
 Dual-quaternion of medium single-qualifier floating-point numbers. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename T , qualifier Q>
GLM_FUNC_DECL tdualquat< T, Q > dual_quat_identity ()
 Creates an identity dual quaternion. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL tdualquat< T, Q > dualquat_cast (mat< 2, 4, T, Q > const &x)
 Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL tdualquat< T, Q > dualquat_cast (mat< 3, 4, T, Q > const &x)
 Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL tdualquat< T, Q > inverse (tdualquat< T, Q > const &q)
 Returns the q inverse. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL tdualquat< T, Q > lerp (tdualquat< T, Q > const &x, tdualquat< T, Q > const &y, T const &a)
 Returns the linear interpolation of two dual quaternion. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL mat< 2, 4, T, Q > mat2x4_cast (tdualquat< T, Q > const &x)
 Converts a quaternion to a 2 * 4 matrix. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL mat< 3, 4, T, Q > mat3x4_cast (tdualquat< T, Q > const &x)
 Converts a quaternion to a 3 * 4 matrix. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL tdualquat< T, Q > normalize (tdualquat< T, Q > const &q)
 Returns the normalized quaternion. More...
 
+

Detailed Description

+

GLM_GTX_dual_quaternion

+
Author
Maksim Vorobiev (msome.nosp@m.one@.nosp@m.gmail.nosp@m..com)
+
See also
Core features (dependence)
+
+GLM_GTC_constants (dependence)
+
+GLM_GTC_quaternion (dependence)
+ +

Definition in file dual_quaternion.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00022_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00022_source.html new file mode 100644 index 0000000000000000000000000000000000000000..6be65eec58c4a59b70d7bdb3529ac820050eb2bb --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00022_source.html @@ -0,0 +1,317 @@ + + + + + + +0.9.9 API documentation: dual_quaternion.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
dual_quaternion.hpp
+
+
+Go to the documentation of this file.
1 
+
16 #pragma once
+
17 
+
18 // Dependency:
+
19 #include "../glm.hpp"
+
20 #include "../gtc/constants.hpp"
+
21 #include "../gtc/quaternion.hpp"
+
22 
+
23 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
24 # ifndef GLM_ENABLE_EXPERIMENTAL
+
25 # pragma message("GLM: GLM_GTX_dual_quaternion is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
26 # else
+
27 # pragma message("GLM: GLM_GTX_dual_quaternion extension included")
+
28 # endif
+
29 #endif
+
30 
+
31 namespace glm
+
32 {
+
35 
+
36  template<typename T, qualifier Q = defaultp>
+
37  struct tdualquat
+
38  {
+
39  // -- Implementation detail --
+
40 
+
41  typedef T value_type;
+
42  typedef qua<T, Q> part_type;
+
43 
+
44  // -- Data --
+
45 
+
46  qua<T, Q> real, dual;
+
47 
+
48  // -- Component accesses --
+
49 
+
50  typedef length_t length_type;
+
52  GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;}
+
53 
+
54  GLM_FUNC_DECL part_type & operator[](length_type i);
+
55  GLM_FUNC_DECL part_type const& operator[](length_type i) const;
+
56 
+
57  // -- Implicit basic constructors --
+
58 
+
59  GLM_FUNC_DECL GLM_CONSTEXPR tdualquat() GLM_DEFAULT;
+
60  GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat<T, Q> const& d) GLM_DEFAULT;
+
61  template<qualifier P>
+
62  GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat<T, P> const& d);
+
63 
+
64  // -- Explicit basic constructors --
+
65 
+
66  GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(qua<T, Q> const& real);
+
67  GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(qua<T, Q> const& orientation, vec<3, T, Q> const& translation);
+
68  GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(qua<T, Q> const& real, qua<T, Q> const& dual);
+
69 
+
70  // -- Conversion constructors --
+
71 
+
72  template<typename U, qualifier P>
+
73  GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tdualquat(tdualquat<U, P> const& q);
+
74 
+
75  GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR tdualquat(mat<2, 4, T, Q> const& holder_mat);
+
76  GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR tdualquat(mat<3, 4, T, Q> const& aug_mat);
+
77 
+
78  // -- Unary arithmetic operators --
+
79 
+
80  GLM_FUNC_DECL tdualquat<T, Q> & operator=(tdualquat<T, Q> const& m) GLM_DEFAULT;
+
81 
+
82  template<typename U>
+
83  GLM_FUNC_DECL tdualquat<T, Q> & operator=(tdualquat<U, Q> const& m);
+
84  template<typename U>
+
85  GLM_FUNC_DECL tdualquat<T, Q> & operator*=(U s);
+
86  template<typename U>
+
87  GLM_FUNC_DECL tdualquat<T, Q> & operator/=(U s);
+
88  };
+
89 
+
90  // -- Unary bit operators --
+
91 
+
92  template<typename T, qualifier Q>
+
93  GLM_FUNC_DECL tdualquat<T, Q> operator+(tdualquat<T, Q> const& q);
+
94 
+
95  template<typename T, qualifier Q>
+
96  GLM_FUNC_DECL tdualquat<T, Q> operator-(tdualquat<T, Q> const& q);
+
97 
+
98  // -- Binary operators --
+
99 
+
100  template<typename T, qualifier Q>
+
101  GLM_FUNC_DECL tdualquat<T, Q> operator+(tdualquat<T, Q> const& q, tdualquat<T, Q> const& p);
+
102 
+
103  template<typename T, qualifier Q>
+
104  GLM_FUNC_DECL tdualquat<T, Q> operator*(tdualquat<T, Q> const& q, tdualquat<T, Q> const& p);
+
105 
+
106  template<typename T, qualifier Q>
+
107  GLM_FUNC_DECL vec<3, T, Q> operator*(tdualquat<T, Q> const& q, vec<3, T, Q> const& v);
+
108 
+
109  template<typename T, qualifier Q>
+
110  GLM_FUNC_DECL vec<3, T, Q> operator*(vec<3, T, Q> const& v, tdualquat<T, Q> const& q);
+
111 
+
112  template<typename T, qualifier Q>
+
113  GLM_FUNC_DECL vec<4, T, Q> operator*(tdualquat<T, Q> const& q, vec<4, T, Q> const& v);
+
114 
+
115  template<typename T, qualifier Q>
+
116  GLM_FUNC_DECL vec<4, T, Q> operator*(vec<4, T, Q> const& v, tdualquat<T, Q> const& q);
+
117 
+
118  template<typename T, qualifier Q>
+
119  GLM_FUNC_DECL tdualquat<T, Q> operator*(tdualquat<T, Q> const& q, T const& s);
+
120 
+
121  template<typename T, qualifier Q>
+
122  GLM_FUNC_DECL tdualquat<T, Q> operator*(T const& s, tdualquat<T, Q> const& q);
+
123 
+
124  template<typename T, qualifier Q>
+
125  GLM_FUNC_DECL tdualquat<T, Q> operator/(tdualquat<T, Q> const& q, T const& s);
+
126 
+
127  // -- Boolean operators --
+
128 
+
129  template<typename T, qualifier Q>
+
130  GLM_FUNC_DECL bool operator==(tdualquat<T, Q> const& q1, tdualquat<T, Q> const& q2);
+
131 
+
132  template<typename T, qualifier Q>
+
133  GLM_FUNC_DECL bool operator!=(tdualquat<T, Q> const& q1, tdualquat<T, Q> const& q2);
+
134 
+
138  template <typename T, qualifier Q>
+
139  GLM_FUNC_DECL tdualquat<T, Q> dual_quat_identity();
+
140 
+
144  template<typename T, qualifier Q>
+
145  GLM_FUNC_DECL tdualquat<T, Q> normalize(tdualquat<T, Q> const& q);
+
146 
+
150  template<typename T, qualifier Q>
+
151  GLM_FUNC_DECL tdualquat<T, Q> lerp(tdualquat<T, Q> const& x, tdualquat<T, Q> const& y, T const& a);
+
152 
+
156  template<typename T, qualifier Q>
+
157  GLM_FUNC_DECL tdualquat<T, Q> inverse(tdualquat<T, Q> const& q);
+
158 
+
162  template<typename T, qualifier Q>
+
163  GLM_FUNC_DECL mat<2, 4, T, Q> mat2x4_cast(tdualquat<T, Q> const& x);
+
164 
+
168  template<typename T, qualifier Q>
+
169  GLM_FUNC_DECL mat<3, 4, T, Q> mat3x4_cast(tdualquat<T, Q> const& x);
+
170 
+
174  template<typename T, qualifier Q>
+
175  GLM_FUNC_DECL tdualquat<T, Q> dualquat_cast(mat<2, 4, T, Q> const& x);
+
176 
+
180  template<typename T, qualifier Q>
+
181  GLM_FUNC_DECL tdualquat<T, Q> dualquat_cast(mat<3, 4, T, Q> const& x);
+
182 
+
183 
+
187  typedef tdualquat<float, lowp> lowp_dualquat;
+
188 
+
192  typedef tdualquat<float, mediump> mediump_dualquat;
+
193 
+
197  typedef tdualquat<float, highp> highp_dualquat;
+
198 
+
199 
+
203  typedef tdualquat<float, lowp> lowp_fdualquat;
+
204 
+
208  typedef tdualquat<float, mediump> mediump_fdualquat;
+
209 
+
213  typedef tdualquat<float, highp> highp_fdualquat;
+
214 
+
215 
+
219  typedef tdualquat<double, lowp> lowp_ddualquat;
+
220 
+
224  typedef tdualquat<double, mediump> mediump_ddualquat;
+
225 
+
229  typedef tdualquat<double, highp> highp_ddualquat;
+
230 
+
231 
+
232 #if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+
233  typedef highp_fdualquat dualquat;
+
237 
+
241  typedef highp_fdualquat fdualquat;
+
242 #elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+
243  typedef highp_fdualquat dualquat;
+
244  typedef highp_fdualquat fdualquat;
+
245 #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+
246  typedef mediump_fdualquat dualquat;
+
247  typedef mediump_fdualquat fdualquat;
+
248 #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
+
249  typedef lowp_fdualquat dualquat;
+
250  typedef lowp_fdualquat fdualquat;
+
251 #else
+
252 # error "GLM error: multiple default precision requested for single-precision floating-point types"
+
253 #endif
+
254 
+
255 
+
256 #if(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
+
257  typedef highp_ddualquat ddualquat;
+
261 #elif(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
+
262  typedef highp_ddualquat ddualquat;
+
263 #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
+
264  typedef mediump_ddualquat ddualquat;
+
265 #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE))
+
266  typedef lowp_ddualquat ddualquat;
+
267 #else
+
268 # error "GLM error: Multiple default precision requested for double-precision floating-point types"
+
269 #endif
+
270 
+
272 } //namespace glm
+
273 
+
274 #include "dual_quaternion.inl"
+
highp_ddualquat ddualquat
Dual-quaternion of default double-qualifier floating-point numbers.
+
highp_fdualquat fdualquat
Dual-quaternion of single-qualifier floating-point numbers.
+
GLM_FUNC_DECL mat< 2, 4, T, Q > mat2x4_cast(tdualquat< T, Q > const &x)
Converts a quaternion to a 2 * 4 matrix.
+
tdualquat< double, highp > highp_ddualquat
Dual-quaternion of high double-qualifier floating-point numbers.
+
GLM_FUNC_DECL tdualquat< T, Q > normalize(tdualquat< T, Q > const &q)
Returns the normalized quaternion.
+
GLM_FUNC_DECL tdualquat< T, Q > dual_quat_identity()
Creates an identity dual quaternion.
+
GLM_FUNC_DECL tdualquat< T, Q > inverse(tdualquat< T, Q > const &q)
Returns the q inverse.
+
GLM_FUNC_DECL tdualquat< T, Q > lerp(tdualquat< T, Q > const &x, tdualquat< T, Q > const &y, T const &a)
Returns the linear interpolation of two dual quaternion.
+
tdualquat< float, lowp > lowp_dualquat
Dual-quaternion of low single-qualifier floating-point numbers.
+
tdualquat< float, lowp > lowp_fdualquat
Dual-quaternion of low single-qualifier floating-point numbers.
+
GLM_FUNC_DECL T length(qua< T, Q > const &q)
Returns the norm of a quaternions.
+
tdualquat< double, lowp > lowp_ddualquat
Dual-quaternion of low double-qualifier floating-point numbers.
+
GLM_FUNC_DECL mat< 3, 4, T, Q > mat3x4_cast(tdualquat< T, Q > const &x)
Converts a quaternion to a 3 * 4 matrix.
+
highp_fdualquat dualquat
Dual-quaternion of floating-point numbers.
+
tdualquat< float, highp > highp_fdualquat
Dual-quaternion of high single-qualifier floating-point numbers.
+
GLM_FUNC_DECL mat< 4, 4, T, Q > orientation(vec< 3, T, Q > const &Normal, vec< 3, T, Q > const &Up)
Build a rotation matrix from a normal and a up vector.
+
tdualquat< float, mediump > mediump_dualquat
Dual-quaternion of medium single-qualifier floating-point numbers.
+
tdualquat< float, mediump > mediump_fdualquat
Dual-quaternion of medium single-qualifier floating-point numbers.
+
tdualquat< double, mediump > mediump_ddualquat
Dual-quaternion of medium double-qualifier floating-point numbers.
+
GLM_FUNC_DECL tdualquat< T, Q > dualquat_cast(mat< 3, 4, T, Q > const &x)
Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
+
tdualquat< float, highp > highp_dualquat
Dual-quaternion of high single-qualifier floating-point numbers.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00023.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00023.html new file mode 100644 index 0000000000000000000000000000000000000000..61002b829fa3f7384ec1fdd1a4f577237d8a02c1 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00023.html @@ -0,0 +1,244 @@ + + + + + + +0.9.9 API documentation: easing.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
easing.hpp File Reference
+
+
+ +

GLM_GTX_easing +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL genType backEaseIn (genType const &a)
 
template<typename genType >
GLM_FUNC_DECL genType backEaseIn (genType const &a, genType const &o)
 
template<typename genType >
GLM_FUNC_DECL genType backEaseInOut (genType const &a)
 
template<typename genType >
GLM_FUNC_DECL genType backEaseInOut (genType const &a, genType const &o)
 
template<typename genType >
GLM_FUNC_DECL genType backEaseOut (genType const &a)
 
template<typename genType >
GLM_FUNC_DECL genType backEaseOut (genType const &a, genType const &o)
 
template<typename genType >
GLM_FUNC_DECL genType bounceEaseIn (genType const &a)
 
template<typename genType >
GLM_FUNC_DECL genType bounceEaseInOut (genType const &a)
 
template<typename genType >
GLM_FUNC_DECL genType bounceEaseOut (genType const &a)
 
template<typename genType >
GLM_FUNC_DECL genType circularEaseIn (genType const &a)
 Modelled after shifted quadrant IV of unit circle. More...
 
template<typename genType >
GLM_FUNC_DECL genType circularEaseInOut (genType const &a)
 Modelled after the piecewise circular function y = (1/2)(1 - sqrt(1 - 4x^2)) ; [0, 0.5) y = (1/2)(sqrt(-(2x - 3)*(2x - 1)) + 1) ; [0.5, 1]. More...
 
template<typename genType >
GLM_FUNC_DECL genType circularEaseOut (genType const &a)
 Modelled after shifted quadrant II of unit circle. More...
 
+template<typename genType >
GLM_FUNC_DECL genType cubicEaseIn (genType const &a)
 Modelled after the cubic y = x^3.
 
template<typename genType >
GLM_FUNC_DECL genType cubicEaseInOut (genType const &a)
 Modelled after the piecewise cubic y = (1/2)((2x)^3) ; [0, 0.5) y = (1/2)((2x-2)^3 + 2) ; [0.5, 1]. More...
 
template<typename genType >
GLM_FUNC_DECL genType cubicEaseOut (genType const &a)
 Modelled after the cubic y = (x - 1)^3 + 1. More...
 
template<typename genType >
GLM_FUNC_DECL genType elasticEaseIn (genType const &a)
 Modelled after the damped sine wave y = sin(13pi/2*x)*pow(2, 10 * (x - 1)) More...
 
template<typename genType >
GLM_FUNC_DECL genType elasticEaseInOut (genType const &a)
 Modelled after the piecewise exponentially-damped sine wave: y = (1/2)*sin(13pi/2*(2*x))*pow(2, 10 * ((2*x) - 1)) ; [0,0.5) y = (1/2)*(sin(-13pi/2*((2x-1)+1))*pow(2,-10(2*x-1)) + 2) ; [0.5, 1]. More...
 
template<typename genType >
GLM_FUNC_DECL genType elasticEaseOut (genType const &a)
 Modelled after the damped sine wave y = sin(-13pi/2*(x + 1))*pow(2, -10x) + 1. More...
 
template<typename genType >
GLM_FUNC_DECL genType exponentialEaseIn (genType const &a)
 Modelled after the exponential function y = 2^(10(x - 1)) More...
 
template<typename genType >
GLM_FUNC_DECL genType exponentialEaseInOut (genType const &a)
 Modelled after the piecewise exponential y = (1/2)2^(10(2x - 1)) ; [0,0.5) y = -(1/2)*2^(-10(2x - 1))) + 1 ; [0.5,1]. More...
 
template<typename genType >
GLM_FUNC_DECL genType exponentialEaseOut (genType const &a)
 Modelled after the exponential function y = -2^(-10x) + 1. More...
 
template<typename genType >
GLM_FUNC_DECL genType linearInterpolation (genType const &a)
 Modelled after the line y = x. More...
 
template<typename genType >
GLM_FUNC_DECL genType quadraticEaseIn (genType const &a)
 Modelled after the parabola y = x^2. More...
 
template<typename genType >
GLM_FUNC_DECL genType quadraticEaseInOut (genType const &a)
 Modelled after the piecewise quadratic y = (1/2)((2x)^2) ; [0, 0.5) y = -(1/2)((2x-1)*(2x-3) - 1) ; [0.5, 1]. More...
 
template<typename genType >
GLM_FUNC_DECL genType quadraticEaseOut (genType const &a)
 Modelled after the parabola y = -x^2 + 2x. More...
 
template<typename genType >
GLM_FUNC_DECL genType quarticEaseIn (genType const &a)
 Modelled after the quartic x^4. More...
 
template<typename genType >
GLM_FUNC_DECL genType quarticEaseInOut (genType const &a)
 Modelled after the piecewise quartic y = (1/2)((2x)^4) ; [0, 0.5) y = -(1/2)((2x-2)^4 - 2) ; [0.5, 1]. More...
 
template<typename genType >
GLM_FUNC_DECL genType quarticEaseOut (genType const &a)
 Modelled after the quartic y = 1 - (x - 1)^4. More...
 
template<typename genType >
GLM_FUNC_DECL genType quinticEaseIn (genType const &a)
 Modelled after the quintic y = x^5. More...
 
template<typename genType >
GLM_FUNC_DECL genType quinticEaseInOut (genType const &a)
 Modelled after the piecewise quintic y = (1/2)((2x)^5) ; [0, 0.5) y = (1/2)((2x-2)^5 + 2) ; [0.5, 1]. More...
 
template<typename genType >
GLM_FUNC_DECL genType quinticEaseOut (genType const &a)
 Modelled after the quintic y = (x - 1)^5 + 1. More...
 
template<typename genType >
GLM_FUNC_DECL genType sineEaseIn (genType const &a)
 Modelled after quarter-cycle of sine wave. More...
 
template<typename genType >
GLM_FUNC_DECL genType sineEaseInOut (genType const &a)
 Modelled after half sine wave. More...
 
template<typename genType >
GLM_FUNC_DECL genType sineEaseOut (genType const &a)
 Modelled after quarter-cycle of sine wave (different phase) More...
 
+

Detailed Description

+

GLM_GTX_easing

+
Author
Robert Chisholm
+
See also
Core features (dependence)
+ +

Definition in file easing.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00023_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00023_source.html new file mode 100644 index 0000000000000000000000000000000000000000..92e1529b94e62b1a252ab6ab52cd01f9c2184b03 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00023_source.html @@ -0,0 +1,254 @@ + + + + + + +0.9.9 API documentation: easing.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
easing.hpp
+
+
+Go to the documentation of this file.
1 
+
17 #pragma once
+
18 
+
19 // Dependency:
+
20 #include "../glm.hpp"
+
21 #include "../gtc/constants.hpp"
+
22 #include "../detail/qualifier.hpp"
+
23 
+
24 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
25 # ifndef GLM_ENABLE_EXPERIMENTAL
+
26 # pragma message("GLM: GLM_GTX_easing is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
27 # else
+
28 # pragma message("GLM: GLM_GTX_easing extension included")
+
29 # endif
+
30 #endif
+
31 
+
32 namespace glm{
+
35 
+
38  template <typename genType>
+
39  GLM_FUNC_DECL genType linearInterpolation(genType const & a);
+
40 
+
43  template <typename genType>
+
44  GLM_FUNC_DECL genType quadraticEaseIn(genType const & a);
+
45 
+
48  template <typename genType>
+
49  GLM_FUNC_DECL genType quadraticEaseOut(genType const & a);
+
50 
+
55  template <typename genType>
+
56  GLM_FUNC_DECL genType quadraticEaseInOut(genType const & a);
+
57 
+
59  template <typename genType>
+
60  GLM_FUNC_DECL genType cubicEaseIn(genType const & a);
+
61 
+
64  template <typename genType>
+
65  GLM_FUNC_DECL genType cubicEaseOut(genType const & a);
+
66 
+
71  template <typename genType>
+
72  GLM_FUNC_DECL genType cubicEaseInOut(genType const & a);
+
73 
+
76  template <typename genType>
+
77  GLM_FUNC_DECL genType quarticEaseIn(genType const & a);
+
78 
+
81  template <typename genType>
+
82  GLM_FUNC_DECL genType quarticEaseOut(genType const & a);
+
83 
+
88  template <typename genType>
+
89  GLM_FUNC_DECL genType quarticEaseInOut(genType const & a);
+
90 
+
93  template <typename genType>
+
94  GLM_FUNC_DECL genType quinticEaseIn(genType const & a);
+
95 
+
98  template <typename genType>
+
99  GLM_FUNC_DECL genType quinticEaseOut(genType const & a);
+
100 
+
105  template <typename genType>
+
106  GLM_FUNC_DECL genType quinticEaseInOut(genType const & a);
+
107 
+
110  template <typename genType>
+
111  GLM_FUNC_DECL genType sineEaseIn(genType const & a);
+
112 
+
115  template <typename genType>
+
116  GLM_FUNC_DECL genType sineEaseOut(genType const & a);
+
117 
+
120  template <typename genType>
+
121  GLM_FUNC_DECL genType sineEaseInOut(genType const & a);
+
122 
+
125  template <typename genType>
+
126  GLM_FUNC_DECL genType circularEaseIn(genType const & a);
+
127 
+
130  template <typename genType>
+
131  GLM_FUNC_DECL genType circularEaseOut(genType const & a);
+
132 
+
137  template <typename genType>
+
138  GLM_FUNC_DECL genType circularEaseInOut(genType const & a);
+
139 
+
142  template <typename genType>
+
143  GLM_FUNC_DECL genType exponentialEaseIn(genType const & a);
+
144 
+
147  template <typename genType>
+
148  GLM_FUNC_DECL genType exponentialEaseOut(genType const & a);
+
149 
+
154  template <typename genType>
+
155  GLM_FUNC_DECL genType exponentialEaseInOut(genType const & a);
+
156 
+
159  template <typename genType>
+
160  GLM_FUNC_DECL genType elasticEaseIn(genType const & a);
+
161 
+
164  template <typename genType>
+
165  GLM_FUNC_DECL genType elasticEaseOut(genType const & a);
+
166 
+
171  template <typename genType>
+
172  GLM_FUNC_DECL genType elasticEaseInOut(genType const & a);
+
173 
+
175  template <typename genType>
+
176  GLM_FUNC_DECL genType backEaseIn(genType const& a);
+
177 
+
179  template <typename genType>
+
180  GLM_FUNC_DECL genType backEaseOut(genType const& a);
+
181 
+
183  template <typename genType>
+
184  GLM_FUNC_DECL genType backEaseInOut(genType const& a);
+
185 
+
189  template <typename genType>
+
190  GLM_FUNC_DECL genType backEaseIn(genType const& a, genType const& o);
+
191 
+
195  template <typename genType>
+
196  GLM_FUNC_DECL genType backEaseOut(genType const& a, genType const& o);
+
197 
+
201  template <typename genType>
+
202  GLM_FUNC_DECL genType backEaseInOut(genType const& a, genType const& o);
+
203 
+
205  template <typename genType>
+
206  GLM_FUNC_DECL genType bounceEaseIn(genType const& a);
+
207 
+
209  template <typename genType>
+
210  GLM_FUNC_DECL genType bounceEaseOut(genType const& a);
+
211 
+
213  template <typename genType>
+
214  GLM_FUNC_DECL genType bounceEaseInOut(genType const& a);
+
215 
+
217 }//namespace glm
+
218 
+
219 #include "easing.inl"
+
GLM_FUNC_DECL genType bounceEaseIn(genType const &a)
+
GLM_FUNC_DECL genType circularEaseInOut(genType const &a)
Modelled after the piecewise circular function y = (1/2)(1 - sqrt(1 - 4x^2)) ; [0, 0.5) y = (1/2)(sqrt(-(2x - 3)*(2x - 1)) + 1) ; [0.5, 1].
+
GLM_FUNC_DECL genType cubicEaseIn(genType const &a)
Modelled after the cubic y = x^3.
+
GLM_FUNC_DECL genType elasticEaseIn(genType const &a)
Modelled after the damped sine wave y = sin(13pi/2*x)*pow(2, 10 * (x - 1))
+
GLM_FUNC_DECL genType quinticEaseIn(genType const &a)
Modelled after the quintic y = x^5.
+
GLM_FUNC_DECL genType sineEaseInOut(genType const &a)
Modelled after half sine wave.
+
GLM_FUNC_DECL genType circularEaseOut(genType const &a)
Modelled after shifted quadrant II of unit circle.
+
GLM_FUNC_DECL genType elasticEaseOut(genType const &a)
Modelled after the damped sine wave y = sin(-13pi/2*(x + 1))*pow(2, -10x) + 1.
+
GLM_FUNC_DECL genType elasticEaseInOut(genType const &a)
Modelled after the piecewise exponentially-damped sine wave: y = (1/2)*sin(13pi/2*(2*x))*pow(2, 10 * ((2*x) - 1)) ; [0,0.5) y = (1/2)*(sin(-13pi/2*((2x-1)+1))*pow(2,-10(2*x-1)) + 2) ; [0.5, 1].
+
GLM_FUNC_DECL genType sineEaseIn(genType const &a)
Modelled after quarter-cycle of sine wave.
+
GLM_FUNC_DECL genType linearInterpolation(genType const &a)
Modelled after the line y = x.
+
GLM_FUNC_DECL genType quarticEaseIn(genType const &a)
Modelled after the quartic x^4.
+
GLM_FUNC_DECL genType quarticEaseOut(genType const &a)
Modelled after the quartic y = 1 - (x - 1)^4.
+
GLM_FUNC_DECL genType sineEaseOut(genType const &a)
Modelled after quarter-cycle of sine wave (different phase)
+
GLM_FUNC_DECL genType quadraticEaseInOut(genType const &a)
Modelled after the piecewise quadratic y = (1/2)((2x)^2) ; [0, 0.5) y = -(1/2)((2x-1)*(2x-3) - 1) ; [...
+
GLM_FUNC_DECL genType circularEaseIn(genType const &a)
Modelled after shifted quadrant IV of unit circle.
+
GLM_FUNC_DECL genType quadraticEaseOut(genType const &a)
Modelled after the parabola y = -x^2 + 2x.
+
GLM_FUNC_DECL genType exponentialEaseOut(genType const &a)
Modelled after the exponential function y = -2^(-10x) + 1.
+
GLM_FUNC_DECL genType quinticEaseOut(genType const &a)
Modelled after the quintic y = (x - 1)^5 + 1.
+
GLM_FUNC_DECL genType cubicEaseOut(genType const &a)
Modelled after the cubic y = (x - 1)^3 + 1.
+
GLM_FUNC_DECL genType exponentialEaseInOut(genType const &a)
Modelled after the piecewise exponential y = (1/2)2^(10(2x - 1)) ; [0,0.5) y = -(1/2)*2^(-10(2x - 1))...
+
GLM_FUNC_DECL genType bounceEaseOut(genType const &a)
+
GLM_FUNC_DECL genType quinticEaseInOut(genType const &a)
Modelled after the piecewise quintic y = (1/2)((2x)^5) ; [0, 0.5) y = (1/2)((2x-2)^5 + 2) ; [0...
+
GLM_FUNC_DECL genType backEaseIn(genType const &a, genType const &o)
+
GLM_FUNC_DECL genType exponentialEaseIn(genType const &a)
Modelled after the exponential function y = 2^(10(x - 1))
+
GLM_FUNC_DECL genType quadraticEaseIn(genType const &a)
Modelled after the parabola y = x^2.
+
GLM_FUNC_DECL genType quarticEaseInOut(genType const &a)
Modelled after the piecewise quartic y = (1/2)((2x)^4) ; [0, 0.5) y = -(1/2)((2x-2)^4 - 2) ; [0...
+
GLM_FUNC_DECL genType cubicEaseInOut(genType const &a)
Modelled after the piecewise cubic y = (1/2)((2x)^3) ; [0, 0.5) y = (1/2)((2x-2)^3 + 2) ; [0...
+
GLM_FUNC_DECL genType bounceEaseInOut(genType const &a)
+
GLM_FUNC_DECL genType backEaseInOut(genType const &a, genType const &o)
+
GLM_FUNC_DECL genType backEaseOut(genType const &a, genType const &o)
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00024.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00024.html new file mode 100644 index 0000000000000000000000000000000000000000..8a392d24a24890ef75f0329214bf2c6e3a135996 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00024.html @@ -0,0 +1,133 @@ + + + + + + +0.9.9 API documentation: epsilon.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
epsilon.hpp File Reference
+
+
+ +

GLM_GTC_epsilon +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + +

+Functions

template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, bool, Q > epsilonEqual (vec< L, T, Q > const &x, vec< L, T, Q > const &y, T const &epsilon)
 Returns the component-wise comparison of |x - y| < epsilon. More...
 
template<typename genType >
GLM_FUNC_DECL bool epsilonEqual (genType const &x, genType const &y, genType const &epsilon)
 Returns the component-wise comparison of |x - y| < epsilon. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, bool, Q > epsilonNotEqual (vec< L, T, Q > const &x, vec< L, T, Q > const &y, T const &epsilon)
 Returns the component-wise comparison of |x - y| < epsilon. More...
 
template<typename genType >
GLM_FUNC_DECL bool epsilonNotEqual (genType const &x, genType const &y, genType const &epsilon)
 Returns the component-wise comparison of |x - y| >= epsilon. More...
 
+

Detailed Description

+

GLM_GTC_epsilon

+
See also
Core features (dependence)
+
+GLM_GTC_quaternion (dependence)
+ +

Definition in file epsilon.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00024_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00024_source.html new file mode 100644 index 0000000000000000000000000000000000000000..a1da38389e05ae52089a5d5226491650bd1fc6da --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00024_source.html @@ -0,0 +1,132 @@ + + + + + + +0.9.9 API documentation: epsilon.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
epsilon.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependencies
+
17 #include "../detail/setup.hpp"
+
18 #include "../detail/qualifier.hpp"
+
19 
+
20 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
21 # pragma message("GLM: GLM_GTC_epsilon extension included")
+
22 #endif
+
23 
+
24 namespace glm
+
25 {
+
28 
+
33  template<length_t L, typename T, qualifier Q>
+
34  GLM_FUNC_DECL vec<L, bool, Q> epsilonEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T const& epsilon);
+
35 
+
40  template<typename genType>
+
41  GLM_FUNC_DECL bool epsilonEqual(genType const& x, genType const& y, genType const& epsilon);
+
42 
+
47  template<length_t L, typename T, qualifier Q>
+
48  GLM_FUNC_DECL vec<L, bool, Q> epsilonNotEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T const& epsilon);
+
49 
+
54  template<typename genType>
+
55  GLM_FUNC_DECL bool epsilonNotEqual(genType const& x, genType const& y, genType const& epsilon);
+
56 
+
58 }//namespace glm
+
59 
+
60 #include "epsilon.inl"
+
GLM_FUNC_DECL bool epsilonEqual(genType const &x, genType const &y, genType const &epsilon)
Returns the component-wise comparison of |x - y| < epsilon.
+
GLM_FUNC_DECL bool epsilonNotEqual(genType const &x, genType const &y, genType const &epsilon)
Returns the component-wise comparison of |x - y| >= epsilon.
+
GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon()
Return the epsilon constant for floating point types.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00025.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00025.html new file mode 100644 index 0000000000000000000000000000000000000000..2904e622e7427e3db429f2b504c16a2953a1af51 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00025.html @@ -0,0 +1,279 @@ + + + + + + +0.9.9 API documentation: euler_angles.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
euler_angles.hpp File Reference
+
+
+ +

GLM_GTX_euler_angles +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > derivedEulerAngleX (T const &angleX, T const &angularVelocityX)
 Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about X-axis. More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > derivedEulerAngleY (T const &angleY, T const &angularVelocityY)
 Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Y-axis. More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > derivedEulerAngleZ (T const &angleZ, T const &angularVelocityZ)
 Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Z-axis. More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleX (T const &angleX)
 Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X. More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXY (T const &angleX, T const &angleY)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXYX (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * X). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXYZ (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXZ (T const &angleX, T const &angleZ)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXZX (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * X). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXZY (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * Y). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleY (T const &angleY)
 Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y. More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYX (T const &angleY, T const &angleX)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYXY (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Y). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYXZ (T const &yaw, T const &pitch, T const &roll)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYZ (T const &angleY, T const &angleZ)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYZX (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * X). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYZY (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * Y). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZ (T const &angleZ)
 Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z. More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZX (T const &angle, T const &angleX)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZXY (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Y). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZXZ (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Z). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZY (T const &angleZ, T const &angleY)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZYX (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * X). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZYZ (T const &t1, T const &t2, T const &t3)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * Z). More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleXYX (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (X * Y * X) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleXYZ (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (X * Y * Z) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleXZX (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (X * Z * X) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleXZY (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (X * Z * Y) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleYXY (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (Y * X * Y) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleYXZ (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (Y * X * Z) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleYZX (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (Y * Z * X) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleYZY (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (Y * Z * Y) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleZXY (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (Z * X * Y) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleZXZ (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (Z * X * Z) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleZYX (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (Z * Y * X) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleZYZ (mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
 Extracts the (Z * Y * Z) Euler angles from the rotation matrix M. More...
 
template<typename T >
GLM_FUNC_DECL mat< 2, 2, T, defaultp > orientate2 (T const &angle)
 Creates a 2D 2 * 2 rotation matrix from an euler angle. More...
 
template<typename T >
GLM_FUNC_DECL mat< 3, 3, T, defaultp > orientate3 (T const &angle)
 Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL mat< 3, 3, T, Q > orientate3 (vec< 3, T, Q > const &angles)
 Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL mat< 4, 4, T, Q > orientate4 (vec< 3, T, Q > const &angles)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). More...
 
template<typename T >
GLM_FUNC_DECL mat< 4, 4, T, defaultp > yawPitchRoll (T const &yaw, T const &pitch, T const &roll)
 Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). More...
 
+

Detailed Description

+

GLM_GTX_euler_angles

+
See also
Core features (dependence)
+ +

Definition in file euler_angles.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00025_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00025_source.html new file mode 100644 index 0000000000000000000000000000000000000000..5c6402e7e45298b561490c7817bb09d50a395157 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00025_source.html @@ -0,0 +1,380 @@ + + + + + + +0.9.9 API documentation: euler_angles.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
euler_angles.hpp
+
+
+Go to the documentation of this file.
1 
+
16 #pragma once
+
17 
+
18 // Dependency:
+
19 #include "../glm.hpp"
+
20 
+
21 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
22 # ifndef GLM_ENABLE_EXPERIMENTAL
+
23 # pragma message("GLM: GLM_GTX_euler_angles is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
24 # else
+
25 # pragma message("GLM: GLM_GTX_euler_angles extension included")
+
26 # endif
+
27 #endif
+
28 
+
29 namespace glm
+
30 {
+
33 
+
36  template<typename T>
+
37  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleX(
+
38  T const& angleX);
+
39 
+
42  template<typename T>
+
43  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleY(
+
44  T const& angleY);
+
45 
+
48  template<typename T>
+
49  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZ(
+
50  T const& angleZ);
+
51 
+
54  template <typename T>
+
55  GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleX(
+
56  T const & angleX, T const & angularVelocityX);
+
57 
+
60  template <typename T>
+
61  GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleY(
+
62  T const & angleY, T const & angularVelocityY);
+
63 
+
66  template <typename T>
+
67  GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleZ(
+
68  T const & angleZ, T const & angularVelocityZ);
+
69 
+
72  template<typename T>
+
73  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXY(
+
74  T const& angleX,
+
75  T const& angleY);
+
76 
+
79  template<typename T>
+
80  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYX(
+
81  T const& angleY,
+
82  T const& angleX);
+
83 
+
86  template<typename T>
+
87  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZ(
+
88  T const& angleX,
+
89  T const& angleZ);
+
90 
+
93  template<typename T>
+
94  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZX(
+
95  T const& angle,
+
96  T const& angleX);
+
97 
+
100  template<typename T>
+
101  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZ(
+
102  T const& angleY,
+
103  T const& angleZ);
+
104 
+
107  template<typename T>
+
108  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZY(
+
109  T const& angleZ,
+
110  T const& angleY);
+
111 
+
114  template<typename T>
+
115  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYZ(
+
116  T const& t1,
+
117  T const& t2,
+
118  T const& t3);
+
119 
+
122  template<typename T>
+
123  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXZ(
+
124  T const& yaw,
+
125  T const& pitch,
+
126  T const& roll);
+
127 
+
130  template <typename T>
+
131  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZX(
+
132  T const & t1,
+
133  T const & t2,
+
134  T const & t3);
+
135 
+
138  template <typename T>
+
139  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYX(
+
140  T const & t1,
+
141  T const & t2,
+
142  T const & t3);
+
143 
+
146  template <typename T>
+
147  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXY(
+
148  T const & t1,
+
149  T const & t2,
+
150  T const & t3);
+
151 
+
154  template <typename T>
+
155  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZY(
+
156  T const & t1,
+
157  T const & t2,
+
158  T const & t3);
+
159 
+
162  template <typename T>
+
163  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZYZ(
+
164  T const & t1,
+
165  T const & t2,
+
166  T const & t3);
+
167 
+
170  template <typename T>
+
171  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZXZ(
+
172  T const & t1,
+
173  T const & t2,
+
174  T const & t3);
+
175 
+
178  template <typename T>
+
179  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZY(
+
180  T const & t1,
+
181  T const & t2,
+
182  T const & t3);
+
183 
+
186  template <typename T>
+
187  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZX(
+
188  T const & t1,
+
189  T const & t2,
+
190  T const & t3);
+
191 
+
194  template <typename T>
+
195  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZYX(
+
196  T const & t1,
+
197  T const & t2,
+
198  T const & t3);
+
199 
+
202  template <typename T>
+
203  GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZXY(
+
204  T const & t1,
+
205  T const & t2,
+
206  T const & t3);
+
207 
+
210  template<typename T>
+
211  GLM_FUNC_DECL mat<4, 4, T, defaultp> yawPitchRoll(
+
212  T const& yaw,
+
213  T const& pitch,
+
214  T const& roll);
+
215 
+
218  template<typename T>
+
219  GLM_FUNC_DECL mat<2, 2, T, defaultp> orientate2(T const& angle);
+
220 
+
223  template<typename T>
+
224  GLM_FUNC_DECL mat<3, 3, T, defaultp> orientate3(T const& angle);
+
225 
+
228  template<typename T, qualifier Q>
+
229  GLM_FUNC_DECL mat<3, 3, T, Q> orientate3(vec<3, T, Q> const& angles);
+
230 
+
233  template<typename T, qualifier Q>
+
234  GLM_FUNC_DECL mat<4, 4, T, Q> orientate4(vec<3, T, Q> const& angles);
+
235 
+
238  template<typename T>
+
239  GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const& M,
+
240  T & t1,
+
241  T & t2,
+
242  T & t3);
+
243 
+
246  template <typename T>
+
247  GLM_FUNC_DECL void extractEulerAngleYXZ(mat<4, 4, T, defaultp> const & M,
+
248  T & t1,
+
249  T & t2,
+
250  T & t3);
+
251 
+
254  template <typename T>
+
255  GLM_FUNC_DECL void extractEulerAngleXZX(mat<4, 4, T, defaultp> const & M,
+
256  T & t1,
+
257  T & t2,
+
258  T & t3);
+
259 
+
262  template <typename T>
+
263  GLM_FUNC_DECL void extractEulerAngleXYX(mat<4, 4, T, defaultp> const & M,
+
264  T & t1,
+
265  T & t2,
+
266  T & t3);
+
267 
+
270  template <typename T>
+
271  GLM_FUNC_DECL void extractEulerAngleYXY(mat<4, 4, T, defaultp> const & M,
+
272  T & t1,
+
273  T & t2,
+
274  T & t3);
+
275 
+
278  template <typename T>
+
279  GLM_FUNC_DECL void extractEulerAngleYZY(mat<4, 4, T, defaultp> const & M,
+
280  T & t1,
+
281  T & t2,
+
282  T & t3);
+
283 
+
286  template <typename T>
+
287  GLM_FUNC_DECL void extractEulerAngleZYZ(mat<4, 4, T, defaultp> const & M,
+
288  T & t1,
+
289  T & t2,
+
290  T & t3);
+
291 
+
294  template <typename T>
+
295  GLM_FUNC_DECL void extractEulerAngleZXZ(mat<4, 4, T, defaultp> const & M,
+
296  T & t1,
+
297  T & t2,
+
298  T & t3);
+
299 
+
302  template <typename T>
+
303  GLM_FUNC_DECL void extractEulerAngleXZY(mat<4, 4, T, defaultp> const & M,
+
304  T & t1,
+
305  T & t2,
+
306  T & t3);
+
307 
+
310  template <typename T>
+
311  GLM_FUNC_DECL void extractEulerAngleYZX(mat<4, 4, T, defaultp> const & M,
+
312  T & t1,
+
313  T & t2,
+
314  T & t3);
+
315 
+
318  template <typename T>
+
319  GLM_FUNC_DECL void extractEulerAngleZYX(mat<4, 4, T, defaultp> const & M,
+
320  T & t1,
+
321  T & t2,
+
322  T & t3);
+
323 
+
326  template <typename T>
+
327  GLM_FUNC_DECL void extractEulerAngleZXY(mat<4, 4, T, defaultp> const & M,
+
328  T & t1,
+
329  T & t2,
+
330  T & t3);
+
331 
+
333 }//namespace glm
+
334 
+
335 #include "euler_angles.inl"
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXY(T const &angleX, T const &angleY)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYZY(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * Y).
+
GLM_FUNC_DECL void extractEulerAngleYXZ(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (Y * X * Z) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXYZ(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXZY(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * Y).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > derivedEulerAngleZ(T const &angleZ, T const &angularVelocityZ)
Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Z-axis.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYX(T const &angleY, T const &angleX)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleY(T const &angleY)
Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
+
GLM_FUNC_DECL T angle(qua< T, Q > const &x)
Returns the quaternion rotation angle.
+
GLM_FUNC_DECL void extractEulerAngleZYZ(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (Z * Y * Z) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > derivedEulerAngleX(T const &angleX, T const &angularVelocityX)
Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about X-axis.
+
GLM_FUNC_DECL void extractEulerAngleXYX(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (X * Y * X) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZXY(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Y).
+
GLM_FUNC_DECL T roll(qua< T, Q > const &x)
Returns roll value of euler angles expressed in radians.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleX(T const &angleX)
Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
+
GLM_FUNC_DECL mat< 2, 2, T, defaultp > orientate2(T const &angle)
Creates a 2D 2 * 2 rotation matrix from an euler angle.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXYX(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * X).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYXZ(T const &yaw, T const &pitch, T const &roll)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+
GLM_FUNC_DECL void extractEulerAngleXZX(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (X * Z * X) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL T yaw(qua< T, Q > const &x)
Returns yaw value of euler angles expressed in radians.
+
GLM_FUNC_DECL void extractEulerAngleYXY(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (Y * X * Y) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL void extractEulerAngleZXY(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (Z * X * Y) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL void extractEulerAngleXZY(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (X * Z * Y) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL void extractEulerAngleYZX(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (Y * Z * X) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXZX(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * X).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZYX(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * X).
+
GLM_FUNC_DECL mat< 4, 4, T, Q > orientate4(vec< 3, T, Q > const &angles)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+
GLM_FUNC_DECL void extractEulerAngleZYX(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (Z * Y * X) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZ(T const &angleZ)
Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYXY(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Y).
+
GLM_FUNC_DECL void extractEulerAngleYZY(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (Y * Z * Y) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > yawPitchRoll(T const &yaw, T const &pitch, T const &roll)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXZ(T const &angleX, T const &angleZ)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
+
GLM_FUNC_DECL void extractEulerAngleXYZ(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (X * Y * Z) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZXZ(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Z).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYZX(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * X).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZY(T const &angleZ, T const &angleY)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZYZ(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * Z).
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYZ(T const &angleY, T const &angleZ)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
+
GLM_FUNC_DECL mat< 3, 3, T, Q > orientate3(vec< 3, T, Q > const &angles)
Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z).
+
GLM_FUNC_DECL void extractEulerAngleZXZ(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Extracts the (Z * X * Z) Euler angles from the rotation matrix M.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > derivedEulerAngleY(T const &angleY, T const &angularVelocityY)
Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Y-axis.
+
GLM_FUNC_DECL T pitch(qua< T, Q > const &x)
Returns pitch value of euler angles expressed in radians.
+
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZX(T const &angle, T const &angleX)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00026.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00026.html new file mode 100644 index 0000000000000000000000000000000000000000..552b6ed247df1b5a700a1a854bec7d7518a76a2c --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00026.html @@ -0,0 +1,143 @@ + + + + + + +0.9.9 API documentation: exponential.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
exponential.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

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 exponentiation of x, i.e., e^x. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > exp2 (vec< L, T, Q > const &v)
 Returns 2 raised to the v power. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > inversesqrt (vec< L, T, Q > const &v)
 Returns the reciprocal of the positive square root of v. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > log (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. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > log2 (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. More...
 
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 'base' raised to the power 'exponent'. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > sqrt (vec< L, T, Q > const &v)
 Returns the positive square root of v. More...
 
+

Detailed Description

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00026_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00026_source.html new file mode 100644 index 0000000000000000000000000000000000000000..56d929d8d957182431f771bb8c7fe7cf03c5a7d0 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00026_source.html @@ -0,0 +1,147 @@ + + + + + + +0.9.9 API documentation: exponential.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
exponential.hpp
+
+
+Go to the documentation of this file.
1 
+
15 #pragma once
+
16 
+
17 #include "detail/type_vec1.hpp"
+
18 #include "detail/type_vec2.hpp"
+
19 #include "detail/type_vec3.hpp"
+
20 #include "detail/type_vec4.hpp"
+
21 #include <cmath>
+
22 
+
23 namespace glm
+
24 {
+
27 
+
35  template<length_t L, typename T, qualifier Q>
+
36  GLM_FUNC_DECL vec<L, T, Q> pow(vec<L, T, Q> const& base, vec<L, T, Q> const& exponent);
+
37 
+
46  template<length_t L, typename T, qualifier Q>
+
47  GLM_FUNC_DECL vec<L, T, Q> exp(vec<L, T, Q> const& v);
+
48 
+
59  template<length_t L, typename T, qualifier Q>
+
60  GLM_FUNC_DECL vec<L, T, Q> log(vec<L, T, Q> const& v);
+
61 
+
70  template<length_t L, typename T, qualifier Q>
+
71  GLM_FUNC_DECL vec<L, T, Q> exp2(vec<L, T, Q> const& v);
+
72 
+
82  template<length_t L, typename T, qualifier Q>
+
83  GLM_FUNC_DECL vec<L, T, Q> log2(vec<L, T, Q> const& v);
+
84 
+
93  template<length_t L, typename T, qualifier Q>
+
94  GLM_FUNC_DECL vec<L, T, Q> sqrt(vec<L, T, Q> const& v);
+
95 
+
104  template<length_t L, typename T, qualifier Q>
+
105  GLM_FUNC_DECL vec<L, T, Q> inversesqrt(vec<L, T, Q> const& v);
+
106 
+
108 }//namespace glm
+
109 
+
110 #include "detail/func_exponential.inl"
+
Core features
+
GLM_FUNC_DECL vec< L, T, Q > sqrt(vec< L, T, Q > const &v)
Returns the positive square root of v.
+
GLM_FUNC_DECL vec< L, T, Q > exp2(vec< L, T, Q > const &v)
Returns 2 raised to the v power.
+
GLM_FUNC_DECL vec< L, T, Q > inversesqrt(vec< L, T, Q > const &v)
Returns the reciprocal of the positive square root of v.
+
Core features
+
Core features
+
GLM_FUNC_DECL vec< L, T, Q > pow(vec< L, T, Q > const &base, vec< L, T, Q > const &exponent)
Returns 'base' raised to the power 'exponent'.
+
GLM_FUNC_DECL vec< L, T, Q > exp(vec< L, T, Q > const &v)
Returns the natural exponentiation of x, i.e., e^x.
+
GLM_FUNC_DECL vec< L, T, Q > log(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...
+
Core features
+
GLM_FUNC_DECL vec< L, T, Q > log2(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...
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00027.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00027.html new file mode 100644 index 0000000000000000000000000000000000000000..d70d9442df27d598547452fe7036b119fe898f06 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00027.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: ext.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
ext.hpp File Reference
+
+
+ +

Core features (Dependence) +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features (Dependence)

+ +

Definition in file ext.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00027_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00027_source.html new file mode 100644 index 0000000000000000000000000000000000000000..4142831aae1e3698a8b4e546dbd5c096762be488 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00027_source.html @@ -0,0 +1,449 @@ + + + + + + +0.9.9 API documentation: ext.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
ext.hpp
+
+
+Go to the documentation of this file.
1 
+
5 #include "detail/setup.hpp"
+
6 
+
7 #pragma once
+
8 
+
9 #include "glm.hpp"
+
10 
+
11 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED)
+
12 # define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED
+
13 # pragma message("GLM: All extensions included (not recommended)")
+
14 #endif//GLM_MESSAGES
+
15 
+ + + + + + + + + + + + + + + + + + +
34 
+ + + + + + + + + + + + + +
48 #include "./ext/matrix_float4x2_precision.hpp"
+ + + + +
53 
+ +
55 
+ + + + + + +
62 
+ + + +
66 
+
67 #include "./ext/vector_bool1.hpp"
+ +
69 #include "./ext/vector_bool2.hpp"
+ +
71 #include "./ext/vector_bool3.hpp"
+ +
73 #include "./ext/vector_bool4.hpp"
+ +
75 
+
76 #include "./ext/vector_double1.hpp"
+ +
78 #include "./ext/vector_double2.hpp"
+ +
80 #include "./ext/vector_double3.hpp"
+ +
82 #include "./ext/vector_double4.hpp"
+ +
84 
+
85 #include "./ext/vector_float1.hpp"
+ +
87 #include "./ext/vector_float2.hpp"
+ +
89 #include "./ext/vector_float3.hpp"
+ +
91 #include "./ext/vector_float4.hpp"
+ +
93 
+
94 #include "./ext/vector_int1.hpp"
+ +
96 #include "./ext/vector_int2.hpp"
+ +
98 #include "./ext/vector_int3.hpp"
+ +
100 #include "./ext/vector_int4.hpp"
+ +
102 
+ +
104 
+
105 #include "./ext/vector_uint1.hpp"
+ +
107 #include "./ext/vector_uint2.hpp"
+ +
109 #include "./ext/vector_uint3.hpp"
+ +
111 #include "./ext/vector_uint4.hpp"
+ +
113 
+
114 #include "./gtc/bitfield.hpp"
+
115 #include "./gtc/color_space.hpp"
+
116 #include "./gtc/constants.hpp"
+
117 #include "./gtc/epsilon.hpp"
+
118 #include "./gtc/integer.hpp"
+
119 #include "./gtc/matrix_access.hpp"
+
120 #include "./gtc/matrix_integer.hpp"
+
121 #include "./gtc/matrix_inverse.hpp"
+ +
123 #include "./gtc/noise.hpp"
+
124 #include "./gtc/packing.hpp"
+
125 #include "./gtc/quaternion.hpp"
+
126 #include "./gtc/random.hpp"
+
127 #include "./gtc/reciprocal.hpp"
+
128 #include "./gtc/round.hpp"
+
129 #include "./gtc/type_precision.hpp"
+
130 #include "./gtc/type_ptr.hpp"
+
131 #include "./gtc/ulp.hpp"
+
132 #include "./gtc/vec1.hpp"
+
133 #if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+
134 # include "./gtc/type_aligned.hpp"
+
135 #endif
+
136 
+
137 #ifdef GLM_ENABLE_EXPERIMENTAL
+ +
139 #include "./gtx/bit.hpp"
+
140 #include "./gtx/closest_point.hpp"
+
141 #include "./gtx/color_encoding.hpp"
+
142 #include "./gtx/color_space.hpp"
+ +
144 #include "./gtx/compatibility.hpp"
+
145 #include "./gtx/component_wise.hpp"
+
146 #include "./gtx/dual_quaternion.hpp"
+
147 #include "./gtx/euler_angles.hpp"
+
148 #include "./gtx/extend.hpp"
+ + + + +
153 #include "./gtx/functions.hpp"
+
154 #include "./gtx/gradient_paint.hpp"
+ +
156 #include "./gtx/integer.hpp"
+
157 #include "./gtx/intersect.hpp"
+
158 #include "./gtx/log_base.hpp"
+ + + + +
163 #include "./gtx/matrix_query.hpp"
+
164 #include "./gtx/mixed_product.hpp"
+
165 #include "./gtx/norm.hpp"
+
166 #include "./gtx/normal.hpp"
+
167 #include "./gtx/normalize_dot.hpp"
+ +
169 #include "./gtx/optimum_pow.hpp"
+
170 #include "./gtx/orthonormalize.hpp"
+
171 #include "./gtx/perpendicular.hpp"
+ +
173 #include "./gtx/projection.hpp"
+
174 #include "./gtx/quaternion.hpp"
+
175 #include "./gtx/raw_data.hpp"
+
176 #include "./gtx/rotate_vector.hpp"
+
177 #include "./gtx/spline.hpp"
+
178 #include "./gtx/std_based_type.hpp"
+
179 #if !(GLM_COMPILER & GLM_COMPILER_CUDA)
+
180 # include "./gtx/string_cast.hpp"
+
181 #endif
+
182 #include "./gtx/transform.hpp"
+
183 #include "./gtx/transform2.hpp"
+
184 #include "./gtx/vec_swizzle.hpp"
+
185 #include "./gtx/vector_angle.hpp"
+
186 #include "./gtx/vector_query.hpp"
+
187 #include "./gtx/wrap.hpp"
+
188 
+
189 #if GLM_HAS_TEMPLATE_ALIASES
+ +
191 #endif
+
192 
+
193 #if GLM_HAS_RANGE_FOR
+
194 # include "./gtx/range.hpp"
+
195 #endif
+
196 #endif//GLM_ENABLE_EXPERIMENTAL
+
GLM_GTC_epsilon
+
GLM_EXT_vector_relational
+
GLM_GTX_dual_quaternion
+
GLM_GTX_polar_coordinates
+
GLM_GTX_closest_point
+
Core features
+ + +
GLM_GTX_handed_coordinate_space
+
Core features
+
GLM_GTX_raw_data
+ +
Core features
+
GLM_GTX_string_cast
+
GLM_EXT_vector_uint1_precision
+
GLM_GTX_intersect
+
GLM_EXT_vector_int1_precision
+
GLM_GTX_normalize_dot
+
GLM_GTX_integer
+
GLM_GTX_rotate_vector
+ +
GLM_GTX_matrix_major_storage
+
Core features
+ +
Core features
+
GLM_GTX_matrix_interpolation
+
GLM_GTX_vector_angle
+
GLM_GTX_transform2
+ + +
GLM_GTX_wrap
+
GLM_GTX_vector_query
+
GLM_GTX_projection
+
GLM_GTC_constants
+ +
GLM_GTX_perpendicular
+
Core features
+
Core features
+
Core features
+ +
Core features
+
GLM_GTX_std_based_type
+
Core features
+
GLM_GTX_component_wise
+
GLM_GTC_ulp
+
GLM_GTC_round
+
Core features
+
GLM_GTX_orthonormalize
+ +
GLM_GTC_integer
+
GLM_EXT_vector_float1
+ +
GLM_GTX_matrix_query
+
GLM_EXT_vector_double1_precision
+ +
GLM_GTX_vec_swizzle
+
Core features
+
GLM_GTC_type_ptr
+
Core features
+
GLM_GTX_gradient_paint
+
GLM_GTC_bitfield
+
GLM_GTX_range
+ +
Core features
+
GLM_GTC_matrix_transform
+
GLM_GTX_matrix_cross_product
+
GLM_EXT_vector_bool1_precision
+
GLM_GTC_type_aligned
+
GLM_EXT_vector_uint1
+
GLM_GTX_quaternion
+
GLM_GTX_color_space_YCoCg
+
GLM_EXT_vector_int1
+
GLM_GTX_normal
+
GLM_GTC_color_space
+
Core features
+
GLM_GTC_noise
+
Core features
+
Core features
+ +
GLM_GTC_matrix_integer
+
GLM_GTC_matrix_access
+
GLM_GTX_extented_min_max
+
GLM_GTC_vec1
+
GLM_GTX_transform
+ +
GLM_EXT_quaternion_double_precision
+
GLM_GTX_log_base
+
GLM_GTX_compatibility
+
GLM_EXT_scalar_int_sized
+ +
GLM_GTX_optimum_pow
+
GLM_GTX_functions
+
GLM_EXT_quaternion_relational
+ +
GLM_GTX_fast_square_root
+
Core features
+
GLM_EXT_quaternion_float_precision
+
Core features
+ +
GLM_EXT_scalar_relational
+ +
Core features
+
GLM_GTC_random
+
GLM_GTX_euler_angles
+
GLM_GTX_spline
+
GLM_GTC_quaternion
+
GLM_GTX_color_space
+ +
GLM_GTX_norm
+
GLM_GTX_color_encoding
+
GLM_GTC_reciprocal
+ +
Core features
+
GLM_GTX_mixed_producte
+
Core features
+
GLM_EXT_vector_double1
+
Core features
+ +
GLM_GTC_type_precision
+
GLM_EXT_scalar_constants
+ +
GLM_GTX_fast_trigonometry
+
GLM_GTX_bit
+ +
GLM_EXT_quaternion_geometric
+
Core features
+
GLM_GTX_fast_exponential
+ +
GLM_EXT_quaternion_float
+ +
GLM_EXT_vector_bool1
+
Core features
+
Core features
+
Core features
+ +
Core features
+
GLM_GTX_extend
+ +
Core features
+
GLM_EXT_quaternion_double
+ +
Core features
+
GLM_GTX_number_precision
+
Core features
+ +
GLM_GTX_matrix_operation
+
Core features
+ +
GLM_GTC_matrix_inverse
+
Core features
+
Experimental extensions
+ +
GLM_GTC_packing
+
Core features
+
GLM_GTX_associated_min_max
+
GLM_EXT_vector_float1_precision
+
GLM_EXT_matrix_relational
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00028.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00028.html new file mode 100644 index 0000000000000000000000000000000000000000..99d4646d54ad11886a8dd648c8c9e80befb43f0b --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00028.html @@ -0,0 +1,119 @@ + + + + + + +0.9.9 API documentation: extend.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
extend.hpp File Reference
+
+
+ +

GLM_GTX_extend +More...

+ +

Go to the source code of this file.

+ + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL genType extend (genType const &Origin, genType const &Source, typename genType::value_type const Length)
 Extends of Length the Origin position using the (Source - Origin) direction. More...
 
+

Detailed Description

+

GLM_GTX_extend

+
See also
Core features (dependence)
+ +

Definition in file extend.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00028_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00028_source.html new file mode 100644 index 0000000000000000000000000000000000000000..71f6bf9a5528029edef45039ec34ce23372d82e6 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00028_source.html @@ -0,0 +1,127 @@ + + + + + + +0.9.9 API documentation: extend.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
extend.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../glm.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # ifndef GLM_ENABLE_EXPERIMENTAL
+
20 # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
21 # else
+
22 # pragma message("GLM: GLM_GTX_extend extension included")
+
23 # endif
+
24 #endif
+
25 
+
26 namespace glm
+
27 {
+
30 
+
33  template<typename genType>
+
34  GLM_FUNC_DECL genType extend(
+
35  genType const& Origin,
+
36  genType const& Source,
+
37  typename genType::value_type const Length);
+
38 
+
40 }//namespace glm
+
41 
+
42 #include "extend.inl"
+
GLM_FUNC_DECL genType extend(genType const &Origin, genType const &Source, typename genType::value_type const Length)
Extends of Length the Origin position using the (Source - Origin) direction.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00029.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00029.html new file mode 100644 index 0000000000000000000000000000000000000000..892f596aa321f020cedb5d42b432e85060ea4c18 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00029.html @@ -0,0 +1,183 @@ + + + + + + +0.9.9 API documentation: extended_min_max.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
extended_min_max.hpp File Reference
+
+
+ +

GLM_GTX_extented_min_max +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL genType fclamp (genType x, genType minVal, genType maxVal)
 Returns min(max(x, minVal), maxVal) for each component in x. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fclamp (vec< L, T, Q > const &x, T minVal, T maxVal)
 Returns min(max(x, minVal), maxVal) for each component in x. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fclamp (vec< L, T, Q > const &x, vec< L, T, Q > const &minVal, vec< L, T, Q > const &maxVal)
 Returns min(max(x, minVal), maxVal) for each component in x. More...
 
template<typename genType >
GLM_FUNC_DECL genType fmax (genType x, genType y)
 Returns y if x < y; otherwise, it returns x. More...
 
template<typename genType >
GLM_FUNC_DECL genType fmin (genType x, genType y)
 Returns y if y < x; otherwise, it returns x. More...
 
template<typename T >
GLM_FUNC_DECL T max (T const &x, T const &y, T const &z)
 Return the maximum component-wise values of 3 inputs. More...
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z)
 Return the maximum component-wise values of 3 inputs. More...
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, C< T > const &y, C< T > const &z)
 Return the maximum component-wise values of 3 inputs. More...
 
template<typename T >
GLM_FUNC_DECL T max (T const &x, T const &y, T const &z, T const &w)
 Return the maximum component-wise values of 4 inputs. More...
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z, typename C< T >::T const &w)
 Return the maximum component-wise values of 4 inputs. More...
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
 Return the maximum component-wise values of 4 inputs. More...
 
template<typename T >
GLM_FUNC_DECL T min (T const &x, T const &y, T const &z)
 Return the minimum component-wise values of 3 inputs. More...
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z)
 Return the minimum component-wise values of 3 inputs. More...
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, C< T > const &y, C< T > const &z)
 Return the minimum component-wise values of 3 inputs. More...
 
template<typename T >
GLM_FUNC_DECL T min (T const &x, T const &y, T const &z, T const &w)
 Return the minimum component-wise values of 4 inputs. More...
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z, typename C< T >::T const &w)
 Return the minimum component-wise values of 4 inputs. More...
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
 Return the minimum component-wise values of 4 inputs. More...
 
+

Detailed Description

+

GLM_GTX_extented_min_max

+
See also
Core features (dependence)
+ +

Definition in file extended_min_max.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00029_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00029_source.html new file mode 100644 index 0000000000000000000000000000000000000000..2cb43baf335cced1c4e64d845e80f444a6ffd12a --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00029_source.html @@ -0,0 +1,219 @@ + + + + + + +0.9.9 API documentation: extended_min_max.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
extended_min_max.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../glm.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # ifndef GLM_ENABLE_EXPERIMENTAL
+
20 # pragma message("GLM: GLM_GTX_extented_min_max is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
21 # else
+
22 # pragma message("GLM: GLM_GTX_extented_min_max extension included")
+
23 # endif
+
24 #endif
+
25 
+
26 namespace glm
+
27 {
+
30 
+
33  template<typename T>
+
34  GLM_FUNC_DECL T min(
+
35  T const& x,
+
36  T const& y,
+
37  T const& z);
+
38 
+
41  template<typename T, template<typename> class C>
+
42  GLM_FUNC_DECL C<T> min(
+
43  C<T> const& x,
+
44  typename C<T>::T const& y,
+
45  typename C<T>::T const& z);
+
46 
+
49  template<typename T, template<typename> class C>
+
50  GLM_FUNC_DECL C<T> min(
+
51  C<T> const& x,
+
52  C<T> const& y,
+
53  C<T> const& z);
+
54 
+
57  template<typename T>
+
58  GLM_FUNC_DECL T min(
+
59  T const& x,
+
60  T const& y,
+
61  T const& z,
+
62  T const& w);
+
63 
+
66  template<typename T, template<typename> class C>
+
67  GLM_FUNC_DECL C<T> min(
+
68  C<T> const& x,
+
69  typename C<T>::T const& y,
+
70  typename C<T>::T const& z,
+
71  typename C<T>::T const& w);
+
72 
+
75  template<typename T, template<typename> class C>
+
76  GLM_FUNC_DECL C<T> min(
+
77  C<T> const& x,
+
78  C<T> const& y,
+
79  C<T> const& z,
+
80  C<T> const& w);
+
81 
+
84  template<typename T>
+
85  GLM_FUNC_DECL T max(
+
86  T const& x,
+
87  T const& y,
+
88  T const& z);
+
89 
+
92  template<typename T, template<typename> class C>
+
93  GLM_FUNC_DECL C<T> max(
+
94  C<T> const& x,
+
95  typename C<T>::T const& y,
+
96  typename C<T>::T const& z);
+
97 
+
100  template<typename T, template<typename> class C>
+
101  GLM_FUNC_DECL C<T> max(
+
102  C<T> const& x,
+
103  C<T> const& y,
+
104  C<T> const& z);
+
105 
+
108  template<typename T>
+
109  GLM_FUNC_DECL T max(
+
110  T const& x,
+
111  T const& y,
+
112  T const& z,
+
113  T const& w);
+
114 
+
117  template<typename T, template<typename> class C>
+
118  GLM_FUNC_DECL C<T> max(
+
119  C<T> const& x,
+
120  typename C<T>::T const& y,
+
121  typename C<T>::T const& z,
+
122  typename C<T>::T const& w);
+
123 
+
126  template<typename T, template<typename> class C>
+
127  GLM_FUNC_DECL C<T> max(
+
128  C<T> const& x,
+
129  C<T> const& y,
+
130  C<T> const& z,
+
131  C<T> const& w);
+
132 
+
138  template<typename genType>
+
139  GLM_FUNC_DECL genType fmin(genType x, genType y);
+
140 
+
147  template<typename genType>
+
148  GLM_FUNC_DECL genType fmax(genType x, genType y);
+
149 
+
155  template<typename genType>
+
156  GLM_FUNC_DECL genType fclamp(genType x, genType minVal, genType maxVal);
+
157 
+
165  template<length_t L, typename T, qualifier Q>
+
166  GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, T minVal, T maxVal);
+
167 
+
175  template<length_t L, typename T, qualifier Q>
+
176  GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal);
+
177 
+
178 
+
180 }//namespace glm
+
181 
+
182 #include "extended_min_max.inl"
+
GLM_FUNC_DECL vec< L, T, Q > fclamp(vec< L, T, Q > const &x, vec< L, T, Q > const &minVal, vec< L, T, Q > const &maxVal)
Returns min(max(x, minVal), maxVal) for each component in x.
+
GLM_FUNC_DECL genType fmin(genType x, genType y)
Returns y if y < x; otherwise, it returns x.
+
GLM_FUNC_DECL genType fmax(genType x, genType y)
Returns y if x < y; otherwise, it returns x.
+
GLM_FUNC_DECL C< T > max(C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
Return the maximum component-wise values of 4 inputs.
+
GLM_FUNC_DECL C< T > min(C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
Return the minimum component-wise values of 4 inputs.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00030.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00030.html new file mode 100644 index 0000000000000000000000000000000000000000..5f1b5b83c993064b26b4b06d0ece9b55fc1a51e2 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00030.html @@ -0,0 +1,121 @@ + + + + + + +0.9.9 API documentation: exterior_product.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
exterior_product.hpp File Reference
+
+
+ +

GLM_GTX_exterior_product +More...

+ +

Go to the source code of this file.

+ + + + + + +

+Functions

template<typename T , qualifier Q>
GLM_FUNC_DECL T cross (vec< 2, T, Q > const &v, vec< 2, T, Q > const &u)
 Returns the cross product of x and y. More...
 
+

Detailed Description

+

GLM_GTX_exterior_product

+
See also
Core features (dependence)
+
+GLM_GTX_exterior_product (dependence)
+ +

Definition in file exterior_product.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00030_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00030_source.html new file mode 100644 index 0000000000000000000000000000000000000000..9bdf622e7b57a79b72ddc1a5396f6496fa87a04a --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00030_source.html @@ -0,0 +1,125 @@ + + + + + + +0.9.9 API documentation: exterior_product.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
exterior_product.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependencies
+
17 #include "../detail/setup.hpp"
+
18 #include "../detail/qualifier.hpp"
+
19 
+
20 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
21 # ifndef GLM_ENABLE_EXPERIMENTAL
+
22 # pragma message("GLM: GLM_GTX_exterior_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
23 # else
+
24 # pragma message("GLM: GLM_GTX_exterior_product extension included")
+
25 # endif
+
26 #endif
+
27 
+
28 namespace glm
+
29 {
+
32 
+
39  template<typename T, qualifier Q>
+
40  GLM_FUNC_DECL T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u);
+
41 
+
43 } //namespace glm
+
44 
+
45 #include "exterior_product.inl"
+
GLM_FUNC_DECL T cross(vec< 2, T, Q > const &v, vec< 2, T, Q > const &u)
Returns the cross product of x and y.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00031.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00031.html new file mode 100644 index 0000000000000000000000000000000000000000..40ce828f460d081bd85a6f58d4a5987de8a5cb3b --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00031.html @@ -0,0 +1,165 @@ + + + + + + +0.9.9 API documentation: fast_exponential.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
fast_exponential.hpp File Reference
+
+
+ +

GLM_GTX_fast_exponential +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename T >
GLM_FUNC_DECL T fastExp (T x)
 Faster than the common exp function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fastExp (vec< L, T, Q > const &x)
 Faster than the common exp function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T fastExp2 (T x)
 Faster than the common exp2 function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fastExp2 (vec< L, T, Q > const &x)
 Faster than the common exp2 function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T fastLog (T x)
 Faster than the common log function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fastLog (vec< L, T, Q > const &x)
 Faster than the common exp2 function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T fastLog2 (T x)
 Faster than the common log2 function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fastLog2 (vec< L, T, Q > const &x)
 Faster than the common log2 function but less accurate. More...
 
template<typename genType >
GLM_FUNC_DECL genType fastPow (genType x, genType y)
 Faster than the common pow function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fastPow (vec< L, T, Q > const &x, vec< L, T, Q > const &y)
 Faster than the common pow function but less accurate. More...
 
template<typename genTypeT , typename genTypeU >
GLM_FUNC_DECL genTypeT fastPow (genTypeT x, genTypeU y)
 Faster than the common pow function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fastPow (vec< L, T, Q > const &x)
 Faster than the common pow function but less accurate. More...
 
+

Detailed Description

+

GLM_GTX_fast_exponential

+
See also
Core features (dependence)
+
+gtx_half_float (dependence)
+ +

Definition in file fast_exponential.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00031_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00031_source.html new file mode 100644 index 0000000000000000000000000000000000000000..40945b5be14fd3fdc589085f901cd07e1153d7a4 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00031_source.html @@ -0,0 +1,161 @@ + + + + + + +0.9.9 API documentation: fast_exponential.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
fast_exponential.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependency:
+
17 #include "../glm.hpp"
+
18 
+
19 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
20 # ifndef GLM_ENABLE_EXPERIMENTAL
+
21 # pragma message("GLM: GLM_GTX_fast_exponential is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
22 # else
+
23 # pragma message("GLM: GLM_GTX_fast_exponential extension included")
+
24 # endif
+
25 #endif
+
26 
+
27 namespace glm
+
28 {
+
31 
+
34  template<typename genType>
+
35  GLM_FUNC_DECL genType fastPow(genType x, genType y);
+
36 
+
39  template<length_t L, typename T, qualifier Q>
+
40  GLM_FUNC_DECL vec<L, T, Q> fastPow(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
41 
+
44  template<typename genTypeT, typename genTypeU>
+
45  GLM_FUNC_DECL genTypeT fastPow(genTypeT x, genTypeU y);
+
46 
+
49  template<length_t L, typename T, qualifier Q>
+
50  GLM_FUNC_DECL vec<L, T, Q> fastPow(vec<L, T, Q> const& x);
+
51 
+
54  template<typename T>
+
55  GLM_FUNC_DECL T fastExp(T x);
+
56 
+
59  template<length_t L, typename T, qualifier Q>
+
60  GLM_FUNC_DECL vec<L, T, Q> fastExp(vec<L, T, Q> const& x);
+
61 
+
64  template<typename T>
+
65  GLM_FUNC_DECL T fastLog(T x);
+
66 
+
69  template<length_t L, typename T, qualifier Q>
+
70  GLM_FUNC_DECL vec<L, T, Q> fastLog(vec<L, T, Q> const& x);
+
71 
+
74  template<typename T>
+
75  GLM_FUNC_DECL T fastExp2(T x);
+
76 
+
79  template<length_t L, typename T, qualifier Q>
+
80  GLM_FUNC_DECL vec<L, T, Q> fastExp2(vec<L, T, Q> const& x);
+
81 
+
84  template<typename T>
+
85  GLM_FUNC_DECL T fastLog2(T x);
+
86 
+
89  template<length_t L, typename T, qualifier Q>
+
90  GLM_FUNC_DECL vec<L, T, Q> fastLog2(vec<L, T, Q> const& x);
+
91 
+
93 }//namespace glm
+
94 
+
95 #include "fast_exponential.inl"
+
GLM_FUNC_DECL vec< L, T, Q > fastLog(vec< L, T, Q > const &x)
Faster than the common exp2 function but less accurate.
+
GLM_FUNC_DECL vec< L, T, Q > fastPow(vec< L, T, Q > const &x)
Faster than the common pow function but less accurate.
+
GLM_FUNC_DECL vec< L, T, Q > fastLog2(vec< L, T, Q > const &x)
Faster than the common log2 function but less accurate.
+
GLM_FUNC_DECL vec< L, T, Q > fastExp2(vec< L, T, Q > const &x)
Faster than the common exp2 function but less accurate.
+
GLM_FUNC_DECL vec< L, T, Q > fastExp(vec< L, T, Q > const &x)
Faster than the common exp function but less accurate.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00032.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00032.html new file mode 100644 index 0000000000000000000000000000000000000000..7ba4fe4fa15cced54c3c5a6170444c67ca1760be --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00032.html @@ -0,0 +1,151 @@ + + + + + + +0.9.9 API documentation: fast_square_root.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
fast_square_root.hpp File Reference
+
+
+ +

GLM_GTX_fast_square_root +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL genType fastDistance (genType x, genType y)
 Faster than the common distance function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL T fastDistance (vec< L, T, Q > const &x, vec< L, T, Q > const &y)
 Faster than the common distance function but less accurate. More...
 
template<typename genType >
GLM_FUNC_DECL genType fastInverseSqrt (genType x)
 Faster than the common inversesqrt function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fastInverseSqrt (vec< L, T, Q > const &x)
 Faster than the common inversesqrt function but less accurate. More...
 
template<typename genType >
GLM_FUNC_DECL genType fastLength (genType x)
 Faster than the common length function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL T fastLength (vec< L, T, Q > const &x)
 Faster than the common length function but less accurate. More...
 
template<typename genType >
GLM_FUNC_DECL genType fastNormalize (genType const &x)
 Faster than the common normalize function but less accurate. More...
 
template<typename genType >
GLM_FUNC_DECL genType fastSqrt (genType x)
 Faster than the common sqrt function but less accurate. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > fastSqrt (vec< L, T, Q > const &x)
 Faster than the common sqrt function but less accurate. More...
 
+

Detailed Description

+

GLM_GTX_fast_square_root

+
See also
Core features (dependence)
+ +

Definition in file fast_square_root.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00032_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00032_source.html new file mode 100644 index 0000000000000000000000000000000000000000..36328925d009a8213fc24871c721623574c4a2c5 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00032_source.html @@ -0,0 +1,154 @@ + + + + + + +0.9.9 API documentation: fast_square_root.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
fast_square_root.hpp
+
+
+Go to the documentation of this file.
1 
+
15 #pragma once
+
16 
+
17 // Dependency:
+
18 #include "../common.hpp"
+
19 #include "../exponential.hpp"
+
20 #include "../geometric.hpp"
+
21 
+
22 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
23 # ifndef GLM_ENABLE_EXPERIMENTAL
+
24 # pragma message("GLM: GLM_GTX_fast_square_root is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
25 # else
+
26 # pragma message("GLM: GLM_GTX_fast_square_root extension included")
+
27 # endif
+
28 #endif
+
29 
+
30 namespace glm
+
31 {
+
34 
+
38  template<typename genType>
+
39  GLM_FUNC_DECL genType fastSqrt(genType x);
+
40 
+
44  template<length_t L, typename T, qualifier Q>
+
45  GLM_FUNC_DECL vec<L, T, Q> fastSqrt(vec<L, T, Q> const& x);
+
46 
+
50  template<typename genType>
+
51  GLM_FUNC_DECL genType fastInverseSqrt(genType x);
+
52 
+
56  template<length_t L, typename T, qualifier Q>
+
57  GLM_FUNC_DECL vec<L, T, Q> fastInverseSqrt(vec<L, T, Q> const& x);
+
58 
+
62  template<typename genType>
+
63  GLM_FUNC_DECL genType fastLength(genType x);
+
64 
+
68  template<length_t L, typename T, qualifier Q>
+
69  GLM_FUNC_DECL T fastLength(vec<L, T, Q> const& x);
+
70 
+
74  template<typename genType>
+
75  GLM_FUNC_DECL genType fastDistance(genType x, genType y);
+
76 
+
80  template<length_t L, typename T, qualifier Q>
+
81  GLM_FUNC_DECL T fastDistance(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
82 
+
86  template<typename genType>
+
87  GLM_FUNC_DECL genType fastNormalize(genType const& x);
+
88 
+
90 }// namespace glm
+
91 
+
92 #include "fast_square_root.inl"
+
GLM_FUNC_DECL T fastLength(vec< L, T, Q > const &x)
Faster than the common length function but less accurate.
+
GLM_FUNC_DECL T fastDistance(vec< L, T, Q > const &x, vec< L, T, Q > const &y)
Faster than the common distance function but less accurate.
+
GLM_FUNC_DECL vec< L, T, Q > fastSqrt(vec< L, T, Q > const &x)
Faster than the common sqrt function but less accurate.
+
GLM_FUNC_DECL genType fastNormalize(genType const &x)
Faster than the common normalize function but less accurate.
+
GLM_FUNC_DECL vec< L, T, Q > fastInverseSqrt(vec< L, T, Q > const &x)
Faster than the common inversesqrt function but less accurate.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00033.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00033.html new file mode 100644 index 0000000000000000000000000000000000000000..3b49687028d6f56e5c4ce67fc31f8160c8662044 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00033.html @@ -0,0 +1,147 @@ + + + + + + +0.9.9 API documentation: fast_trigonometry.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
fast_trigonometry.hpp File Reference
+
+
+ +

GLM_GTX_fast_trigonometry +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename T >
GLM_FUNC_DECL T fastAcos (T angle)
 Faster than the common acos function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T fastAsin (T angle)
 Faster than the common asin function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T fastAtan (T y, T x)
 Faster than the common atan function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T fastAtan (T angle)
 Faster than the common atan function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T fastCos (T angle)
 Faster than the common cos function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T fastSin (T angle)
 Faster than the common sin function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T fastTan (T angle)
 Faster than the common tan function but less accurate. More...
 
template<typename T >
GLM_FUNC_DECL T wrapAngle (T angle)
 Wrap an angle to [0 2pi[ From GLM_GTX_fast_trigonometry extension. More...
 
+

Detailed Description

+

GLM_GTX_fast_trigonometry

+
See also
Core features (dependence)
+ +

Definition in file fast_trigonometry.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00033_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00033_source.html new file mode 100644 index 0000000000000000000000000000000000000000..c02ae841f0963c1a2e6e89e88f4d9256bce90de5 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00033_source.html @@ -0,0 +1,152 @@ + + + + + + +0.9.9 API documentation: fast_trigonometry.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
fast_trigonometry.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../gtc/constants.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # ifndef GLM_ENABLE_EXPERIMENTAL
+
20 # pragma message("GLM: GLM_GTX_fast_trigonometry is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
21 # else
+
22 # pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
+
23 # endif
+
24 #endif
+
25 
+
26 namespace glm
+
27 {
+
30 
+
33  template<typename T>
+
34  GLM_FUNC_DECL T wrapAngle(T angle);
+
35 
+
38  template<typename T>
+
39  GLM_FUNC_DECL T fastSin(T angle);
+
40 
+
43  template<typename T>
+
44  GLM_FUNC_DECL T fastCos(T angle);
+
45 
+
49  template<typename T>
+
50  GLM_FUNC_DECL T fastTan(T angle);
+
51 
+
55  template<typename T>
+
56  GLM_FUNC_DECL T fastAsin(T angle);
+
57 
+
61  template<typename T>
+
62  GLM_FUNC_DECL T fastAcos(T angle);
+
63 
+
67  template<typename T>
+
68  GLM_FUNC_DECL T fastAtan(T y, T x);
+
69 
+
73  template<typename T>
+
74  GLM_FUNC_DECL T fastAtan(T angle);
+
75 
+
77 }//namespace glm
+
78 
+
79 #include "fast_trigonometry.inl"
+
GLM_FUNC_DECL T fastAsin(T angle)
Faster than the common asin function but less accurate.
+
GLM_FUNC_DECL T angle(qua< T, Q > const &x)
Returns the quaternion rotation angle.
+
GLM_FUNC_DECL T fastAcos(T angle)
Faster than the common acos function but less accurate.
+
GLM_FUNC_DECL T fastTan(T angle)
Faster than the common tan function but less accurate.
+
GLM_FUNC_DECL T fastCos(T angle)
Faster than the common cos function but less accurate.
+
GLM_FUNC_DECL T fastAtan(T angle)
Faster than the common atan function but less accurate.
+
GLM_FUNC_DECL T fastSin(T angle)
Faster than the common sin function but less accurate.
+
GLM_FUNC_DECL T wrapAngle(T angle)
Wrap an angle to [0 2pi[ From GLM_GTX_fast_trigonometry extension.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00034.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00034.html new file mode 100644 index 0000000000000000000000000000000000000000..00e437cdffaaaccaef4ac3c1514d94bb7e1ffadd --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00034.html @@ -0,0 +1,125 @@ + + + + + + +0.9.9 API documentation: functions.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
functions.hpp File Reference
+
+
+ +

GLM_GTX_functions +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + +

+Functions

template<typename T >
GLM_FUNC_DECL T gauss (T x, T ExpectedValue, T StandardDeviation)
 1D gauss function More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL T gauss (vec< 2, T, Q > const &Coord, vec< 2, T, Q > const &ExpectedValue, vec< 2, T, Q > const &StandardDeviation)
 2D gauss function More...
 
+

Detailed Description

+

GLM_GTX_functions

+
See also
Core features (dependence)
+
+GLM_GTC_quaternion (dependence)
+ +

Definition in file functions.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00034_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00034_source.html new file mode 100644 index 0000000000000000000000000000000000000000..2d206e04e1f9180ae9bc956351eb36b088262ba6 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00034_source.html @@ -0,0 +1,136 @@ + + + + + + +0.9.9 API documentation: functions.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
functions.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependencies
+
17 #include "../detail/setup.hpp"
+
18 #include "../detail/qualifier.hpp"
+
19 #include "../detail/type_vec2.hpp"
+
20 
+
21 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
22 # ifndef GLM_ENABLE_EXPERIMENTAL
+
23 # pragma message("GLM: GLM_GTX_functions is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
24 # else
+
25 # pragma message("GLM: GLM_GTX_functions extension included")
+
26 # endif
+
27 #endif
+
28 
+
29 namespace glm
+
30 {
+
33 
+
37  template<typename T>
+
38  GLM_FUNC_DECL T gauss(
+
39  T x,
+
40  T ExpectedValue,
+
41  T StandardDeviation);
+
42 
+
46  template<typename T, qualifier Q>
+
47  GLM_FUNC_DECL T gauss(
+
48  vec<2, T, Q> const& Coord,
+
49  vec<2, T, Q> const& ExpectedValue,
+
50  vec<2, T, Q> const& StandardDeviation);
+
51 
+
53 }//namespace glm
+
54 
+
55 #include "functions.inl"
+
56 
+
GLM_FUNC_DECL T gauss(vec< 2, T, Q > const &Coord, vec< 2, T, Q > const &ExpectedValue, vec< 2, T, Q > const &StandardDeviation)
2D gauss function
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00035_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00035_source.html new file mode 100644 index 0000000000000000000000000000000000000000..454a17d496d377d2fb52c8b077a79a79c018f6a8 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00035_source.html @@ -0,0 +1,1544 @@ + + + + + + +0.9.9 API documentation: fwd.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
fwd.hpp
+
+
+
1 #pragma once
+
2 
+
3 #include "detail/qualifier.hpp"
+
4 
+
5 namespace glm
+
6 {
+
7 #if GLM_HAS_EXTENDED_INTEGER_TYPE
+
8  typedef std::int8_t int8;
+
9  typedef std::int16_t int16;
+
10  typedef std::int32_t int32;
+
11  typedef std::int64_t int64;
+
12 
+
13  typedef std::uint8_t uint8;
+
14  typedef std::uint16_t uint16;
+
15  typedef std::uint32_t uint32;
+
16  typedef std::uint64_t uint64;
+
17 #else
+
18  typedef signed char int8;
+
19  typedef signed short int16;
+
20  typedef signed int int32;
+
21  typedef detail::int64 int64;
+
22 
+
23  typedef unsigned char uint8;
+
24  typedef unsigned short uint16;
+
25  typedef unsigned int uint32;
+
26  typedef detail::uint64 uint64;
+
27 #endif
+
28 
+
29  // Scalar int
+
30 
+
31  typedef int8 lowp_i8;
+
32  typedef int8 mediump_i8;
+
33  typedef int8 highp_i8;
+
34  typedef int8 i8;
+
35 
+
36  typedef int8 lowp_int8;
+
37  typedef int8 mediump_int8;
+
38  typedef int8 highp_int8;
+
39 
+
40  typedef int8 lowp_int8_t;
+
41  typedef int8 mediump_int8_t;
+
42  typedef int8 highp_int8_t;
+
43  typedef int8 int8_t;
+
44 
+
45  typedef int16 lowp_i16;
+
46  typedef int16 mediump_i16;
+
47  typedef int16 highp_i16;
+
48  typedef int16 i16;
+
49 
+
50  typedef int16 lowp_int16;
+
51  typedef int16 mediump_int16;
+
52  typedef int16 highp_int16;
+
53 
+
54  typedef int16 lowp_int16_t;
+
55  typedef int16 mediump_int16_t;
+
56  typedef int16 highp_int16_t;
+
57  typedef int16 int16_t;
+
58 
+
59  typedef int32 lowp_i32;
+
60  typedef int32 mediump_i32;
+
61  typedef int32 highp_i32;
+
62  typedef int32 i32;
+
63 
+
64  typedef int32 lowp_int32;
+
65  typedef int32 mediump_int32;
+
66  typedef int32 highp_int32;
+
67 
+
68  typedef int32 lowp_int32_t;
+
69  typedef int32 mediump_int32_t;
+
70  typedef int32 highp_int32_t;
+
71  typedef int32 int32_t;
+
72 
+
73  typedef int64 lowp_i64;
+
74  typedef int64 mediump_i64;
+
75  typedef int64 highp_i64;
+
76  typedef int64 i64;
+
77 
+
78  typedef int64 lowp_int64;
+
79  typedef int64 mediump_int64;
+
80  typedef int64 highp_int64;
+
81 
+
82  typedef int64 lowp_int64_t;
+
83  typedef int64 mediump_int64_t;
+
84  typedef int64 highp_int64_t;
+
85  typedef int64 int64_t;
+
86 
+
87  // Scalar uint
+
88 
+
89  typedef uint8 lowp_u8;
+
90  typedef uint8 mediump_u8;
+
91  typedef uint8 highp_u8;
+
92  typedef uint8 u8;
+
93 
+
94  typedef uint8 lowp_uint8;
+
95  typedef uint8 mediump_uint8;
+
96  typedef uint8 highp_uint8;
+
97 
+
98  typedef uint8 lowp_uint8_t;
+
99  typedef uint8 mediump_uint8_t;
+
100  typedef uint8 highp_uint8_t;
+
101  typedef uint8 uint8_t;
+
102 
+
103  typedef uint16 lowp_u16;
+
104  typedef uint16 mediump_u16;
+
105  typedef uint16 highp_u16;
+
106  typedef uint16 u16;
+
107 
+
108  typedef uint16 lowp_uint16;
+
109  typedef uint16 mediump_uint16;
+
110  typedef uint16 highp_uint16;
+
111 
+
112  typedef uint16 lowp_uint16_t;
+
113  typedef uint16 mediump_uint16_t;
+
114  typedef uint16 highp_uint16_t;
+
115  typedef uint16 uint16_t;
+
116 
+
117  typedef uint32 lowp_u32;
+
118  typedef uint32 mediump_u32;
+
119  typedef uint32 highp_u32;
+
120  typedef uint32 u32;
+
121 
+
122  typedef uint32 lowp_uint32;
+
123  typedef uint32 mediump_uint32;
+
124  typedef uint32 highp_uint32;
+
125 
+
126  typedef uint32 lowp_uint32_t;
+
127  typedef uint32 mediump_uint32_t;
+
128  typedef uint32 highp_uint32_t;
+
129  typedef uint32 uint32_t;
+
130 
+
131  typedef uint64 lowp_u64;
+
132  typedef uint64 mediump_u64;
+
133  typedef uint64 highp_u64;
+
134  typedef uint64 u64;
+
135 
+
136  typedef uint64 lowp_uint64;
+
137  typedef uint64 mediump_uint64;
+
138  typedef uint64 highp_uint64;
+
139 
+
140  typedef uint64 lowp_uint64_t;
+
141  typedef uint64 mediump_uint64_t;
+
142  typedef uint64 highp_uint64_t;
+
143  typedef uint64 uint64_t;
+
144 
+
145  // Scalar float
+
146 
+
147  typedef float lowp_f32;
+
148  typedef float mediump_f32;
+
149  typedef float highp_f32;
+
150  typedef float f32;
+
151 
+
152  typedef float lowp_float32;
+
153  typedef float mediump_float32;
+
154  typedef float highp_float32;
+
155  typedef float float32;
+
156 
+
157  typedef float lowp_float32_t;
+
158  typedef float mediump_float32_t;
+
159  typedef float highp_float32_t;
+
160  typedef float float32_t;
+
161 
+
162 
+
163  typedef double lowp_f64;
+
164  typedef double mediump_f64;
+
165  typedef double highp_f64;
+
166  typedef double f64;
+
167 
+
168  typedef double lowp_float64;
+
169  typedef double mediump_float64;
+
170  typedef double highp_float64;
+
171  typedef double float64;
+
172 
+
173  typedef double lowp_float64_t;
+
174  typedef double mediump_float64_t;
+
175  typedef double highp_float64_t;
+
176  typedef double float64_t;
+
177 
+
178  // Vector bool
+
179 
+
180  typedef vec<1, bool, lowp> lowp_bvec1;
+
181  typedef vec<2, bool, lowp> lowp_bvec2;
+
182  typedef vec<3, bool, lowp> lowp_bvec3;
+
183  typedef vec<4, bool, lowp> lowp_bvec4;
+
184 
+
185  typedef vec<1, bool, mediump> mediump_bvec1;
+
186  typedef vec<2, bool, mediump> mediump_bvec2;
+
187  typedef vec<3, bool, mediump> mediump_bvec3;
+
188  typedef vec<4, bool, mediump> mediump_bvec4;
+
189 
+
190  typedef vec<1, bool, highp> highp_bvec1;
+
191  typedef vec<2, bool, highp> highp_bvec2;
+
192  typedef vec<3, bool, highp> highp_bvec3;
+
193  typedef vec<4, bool, highp> highp_bvec4;
+
194 
+
195  typedef vec<1, bool, defaultp> bvec1;
+
196  typedef vec<2, bool, defaultp> bvec2;
+
197  typedef vec<3, bool, defaultp> bvec3;
+
198  typedef vec<4, bool, defaultp> bvec4;
+
199 
+
200  // Vector int
+
201 
+
202  typedef vec<1, i32, lowp> lowp_ivec1;
+
203  typedef vec<2, i32, lowp> lowp_ivec2;
+
204  typedef vec<3, i32, lowp> lowp_ivec3;
+
205  typedef vec<4, i32, lowp> lowp_ivec4;
+
206 
+
207  typedef vec<1, i32, mediump> mediump_ivec1;
+
208  typedef vec<2, i32, mediump> mediump_ivec2;
+
209  typedef vec<3, i32, mediump> mediump_ivec3;
+
210  typedef vec<4, i32, mediump> mediump_ivec4;
+
211 
+
212  typedef vec<1, i32, highp> highp_ivec1;
+
213  typedef vec<2, i32, highp> highp_ivec2;
+
214  typedef vec<3, i32, highp> highp_ivec3;
+
215  typedef vec<4, i32, highp> highp_ivec4;
+
216 
+
217  typedef vec<1, i32, defaultp> ivec1;
+
218  typedef vec<2, i32, defaultp> ivec2;
+
219  typedef vec<3, i32, defaultp> ivec3;
+
220  typedef vec<4, i32, defaultp> ivec4;
+
221 
+
222  typedef vec<1, i8, lowp> lowp_i8vec1;
+
223  typedef vec<2, i8, lowp> lowp_i8vec2;
+
224  typedef vec<3, i8, lowp> lowp_i8vec3;
+
225  typedef vec<4, i8, lowp> lowp_i8vec4;
+
226 
+
227  typedef vec<1, i8, mediump> mediump_i8vec1;
+
228  typedef vec<2, i8, mediump> mediump_i8vec2;
+
229  typedef vec<3, i8, mediump> mediump_i8vec3;
+
230  typedef vec<4, i8, mediump> mediump_i8vec4;
+
231 
+
232  typedef vec<1, i8, highp> highp_i8vec1;
+
233  typedef vec<2, i8, highp> highp_i8vec2;
+
234  typedef vec<3, i8, highp> highp_i8vec3;
+
235  typedef vec<4, i8, highp> highp_i8vec4;
+
236 
+
237  typedef vec<1, i8, defaultp> i8vec1;
+
238  typedef vec<2, i8, defaultp> i8vec2;
+
239  typedef vec<3, i8, defaultp> i8vec3;
+
240  typedef vec<4, i8, defaultp> i8vec4;
+
241 
+
242  typedef vec<1, i16, lowp> lowp_i16vec1;
+
243  typedef vec<2, i16, lowp> lowp_i16vec2;
+
244  typedef vec<3, i16, lowp> lowp_i16vec3;
+
245  typedef vec<4, i16, lowp> lowp_i16vec4;
+
246 
+
247  typedef vec<1, i16, mediump> mediump_i16vec1;
+
248  typedef vec<2, i16, mediump> mediump_i16vec2;
+
249  typedef vec<3, i16, mediump> mediump_i16vec3;
+
250  typedef vec<4, i16, mediump> mediump_i16vec4;
+
251 
+
252  typedef vec<1, i16, highp> highp_i16vec1;
+
253  typedef vec<2, i16, highp> highp_i16vec2;
+
254  typedef vec<3, i16, highp> highp_i16vec3;
+
255  typedef vec<4, i16, highp> highp_i16vec4;
+
256 
+
257  typedef vec<1, i16, defaultp> i16vec1;
+
258  typedef vec<2, i16, defaultp> i16vec2;
+
259  typedef vec<3, i16, defaultp> i16vec3;
+
260  typedef vec<4, i16, defaultp> i16vec4;
+
261 
+
262  typedef vec<1, i32, lowp> lowp_i32vec1;
+
263  typedef vec<2, i32, lowp> lowp_i32vec2;
+
264  typedef vec<3, i32, lowp> lowp_i32vec3;
+
265  typedef vec<4, i32, lowp> lowp_i32vec4;
+
266 
+
267  typedef vec<1, i32, mediump> mediump_i32vec1;
+
268  typedef vec<2, i32, mediump> mediump_i32vec2;
+
269  typedef vec<3, i32, mediump> mediump_i32vec3;
+
270  typedef vec<4, i32, mediump> mediump_i32vec4;
+
271 
+
272  typedef vec<1, i32, highp> highp_i32vec1;
+
273  typedef vec<2, i32, highp> highp_i32vec2;
+
274  typedef vec<3, i32, highp> highp_i32vec3;
+
275  typedef vec<4, i32, highp> highp_i32vec4;
+
276 
+
277  typedef vec<1, i32, defaultp> i32vec1;
+
278  typedef vec<2, i32, defaultp> i32vec2;
+
279  typedef vec<3, i32, defaultp> i32vec3;
+
280  typedef vec<4, i32, defaultp> i32vec4;
+
281 
+
282  typedef vec<1, i64, lowp> lowp_i64vec1;
+
283  typedef vec<2, i64, lowp> lowp_i64vec2;
+
284  typedef vec<3, i64, lowp> lowp_i64vec3;
+
285  typedef vec<4, i64, lowp> lowp_i64vec4;
+
286 
+
287  typedef vec<1, i64, mediump> mediump_i64vec1;
+
288  typedef vec<2, i64, mediump> mediump_i64vec2;
+
289  typedef vec<3, i64, mediump> mediump_i64vec3;
+
290  typedef vec<4, i64, mediump> mediump_i64vec4;
+
291 
+
292  typedef vec<1, i64, highp> highp_i64vec1;
+
293  typedef vec<2, i64, highp> highp_i64vec2;
+
294  typedef vec<3, i64, highp> highp_i64vec3;
+
295  typedef vec<4, i64, highp> highp_i64vec4;
+
296 
+
297  typedef vec<1, i64, defaultp> i64vec1;
+
298  typedef vec<2, i64, defaultp> i64vec2;
+
299  typedef vec<3, i64, defaultp> i64vec3;
+
300  typedef vec<4, i64, defaultp> i64vec4;
+
301 
+
302  // Vector uint
+
303 
+
304  typedef vec<1, u32, lowp> lowp_uvec1;
+
305  typedef vec<2, u32, lowp> lowp_uvec2;
+
306  typedef vec<3, u32, lowp> lowp_uvec3;
+
307  typedef vec<4, u32, lowp> lowp_uvec4;
+
308 
+
309  typedef vec<1, u32, mediump> mediump_uvec1;
+
310  typedef vec<2, u32, mediump> mediump_uvec2;
+
311  typedef vec<3, u32, mediump> mediump_uvec3;
+
312  typedef vec<4, u32, mediump> mediump_uvec4;
+
313 
+
314  typedef vec<1, u32, highp> highp_uvec1;
+
315  typedef vec<2, u32, highp> highp_uvec2;
+
316  typedef vec<3, u32, highp> highp_uvec3;
+
317  typedef vec<4, u32, highp> highp_uvec4;
+
318 
+
319  typedef vec<1, u32, defaultp> uvec1;
+
320  typedef vec<2, u32, defaultp> uvec2;
+
321  typedef vec<3, u32, defaultp> uvec3;
+
322  typedef vec<4, u32, defaultp> uvec4;
+
323 
+
324  typedef vec<1, u8, lowp> lowp_u8vec1;
+
325  typedef vec<2, u8, lowp> lowp_u8vec2;
+
326  typedef vec<3, u8, lowp> lowp_u8vec3;
+
327  typedef vec<4, u8, lowp> lowp_u8vec4;
+
328 
+
329  typedef vec<1, u8, mediump> mediump_u8vec1;
+
330  typedef vec<2, u8, mediump> mediump_u8vec2;
+
331  typedef vec<3, u8, mediump> mediump_u8vec3;
+
332  typedef vec<4, u8, mediump> mediump_u8vec4;
+
333 
+
334  typedef vec<1, u8, highp> highp_u8vec1;
+
335  typedef vec<2, u8, highp> highp_u8vec2;
+
336  typedef vec<3, u8, highp> highp_u8vec3;
+
337  typedef vec<4, u8, highp> highp_u8vec4;
+
338 
+
339  typedef vec<1, u8, defaultp> u8vec1;
+
340  typedef vec<2, u8, defaultp> u8vec2;
+
341  typedef vec<3, u8, defaultp> u8vec3;
+
342  typedef vec<4, u8, defaultp> u8vec4;
+
343 
+
344  typedef vec<1, u16, lowp> lowp_u16vec1;
+
345  typedef vec<2, u16, lowp> lowp_u16vec2;
+
346  typedef vec<3, u16, lowp> lowp_u16vec3;
+
347  typedef vec<4, u16, lowp> lowp_u16vec4;
+
348 
+
349  typedef vec<1, u16, mediump> mediump_u16vec1;
+
350  typedef vec<2, u16, mediump> mediump_u16vec2;
+
351  typedef vec<3, u16, mediump> mediump_u16vec3;
+
352  typedef vec<4, u16, mediump> mediump_u16vec4;
+
353 
+
354  typedef vec<1, u16, highp> highp_u16vec1;
+
355  typedef vec<2, u16, highp> highp_u16vec2;
+
356  typedef vec<3, u16, highp> highp_u16vec3;
+
357  typedef vec<4, u16, highp> highp_u16vec4;
+
358 
+
359  typedef vec<1, u16, defaultp> u16vec1;
+
360  typedef vec<2, u16, defaultp> u16vec2;
+
361  typedef vec<3, u16, defaultp> u16vec3;
+
362  typedef vec<4, u16, defaultp> u16vec4;
+
363 
+
364  typedef vec<1, u32, lowp> lowp_u32vec1;
+
365  typedef vec<2, u32, lowp> lowp_u32vec2;
+
366  typedef vec<3, u32, lowp> lowp_u32vec3;
+
367  typedef vec<4, u32, lowp> lowp_u32vec4;
+
368 
+
369  typedef vec<1, u32, mediump> mediump_u32vec1;
+
370  typedef vec<2, u32, mediump> mediump_u32vec2;
+
371  typedef vec<3, u32, mediump> mediump_u32vec3;
+
372  typedef vec<4, u32, mediump> mediump_u32vec4;
+
373 
+
374  typedef vec<1, u32, highp> highp_u32vec1;
+
375  typedef vec<2, u32, highp> highp_u32vec2;
+
376  typedef vec<3, u32, highp> highp_u32vec3;
+
377  typedef vec<4, u32, highp> highp_u32vec4;
+
378 
+
379  typedef vec<1, u32, defaultp> u32vec1;
+
380  typedef vec<2, u32, defaultp> u32vec2;
+
381  typedef vec<3, u32, defaultp> u32vec3;
+
382  typedef vec<4, u32, defaultp> u32vec4;
+
383 
+
384  typedef vec<1, u64, lowp> lowp_u64vec1;
+
385  typedef vec<2, u64, lowp> lowp_u64vec2;
+
386  typedef vec<3, u64, lowp> lowp_u64vec3;
+
387  typedef vec<4, u64, lowp> lowp_u64vec4;
+
388 
+
389  typedef vec<1, u64, mediump> mediump_u64vec1;
+
390  typedef vec<2, u64, mediump> mediump_u64vec2;
+
391  typedef vec<3, u64, mediump> mediump_u64vec3;
+
392  typedef vec<4, u64, mediump> mediump_u64vec4;
+
393 
+
394  typedef vec<1, u64, highp> highp_u64vec1;
+
395  typedef vec<2, u64, highp> highp_u64vec2;
+
396  typedef vec<3, u64, highp> highp_u64vec3;
+
397  typedef vec<4, u64, highp> highp_u64vec4;
+
398 
+
399  typedef vec<1, u64, defaultp> u64vec1;
+
400  typedef vec<2, u64, defaultp> u64vec2;
+
401  typedef vec<3, u64, defaultp> u64vec3;
+
402  typedef vec<4, u64, defaultp> u64vec4;
+
403 
+
404  // Vector float
+
405 
+
406  typedef vec<1, float, lowp> lowp_vec1;
+
407  typedef vec<2, float, lowp> lowp_vec2;
+
408  typedef vec<3, float, lowp> lowp_vec3;
+
409  typedef vec<4, float, lowp> lowp_vec4;
+
410 
+
411  typedef vec<1, float, mediump> mediump_vec1;
+
412  typedef vec<2, float, mediump> mediump_vec2;
+
413  typedef vec<3, float, mediump> mediump_vec3;
+
414  typedef vec<4, float, mediump> mediump_vec4;
+
415 
+
416  typedef vec<1, float, highp> highp_vec1;
+
417  typedef vec<2, float, highp> highp_vec2;
+
418  typedef vec<3, float, highp> highp_vec3;
+
419  typedef vec<4, float, highp> highp_vec4;
+
420 
+
421  typedef vec<1, float, defaultp> vec1;
+
422  typedef vec<2, float, defaultp> vec2;
+
423  typedef vec<3, float, defaultp> vec3;
+
424  typedef vec<4, float, defaultp> vec4;
+
425 
+
426  typedef vec<1, float, lowp> lowp_fvec1;
+
427  typedef vec<2, float, lowp> lowp_fvec2;
+
428  typedef vec<3, float, lowp> lowp_fvec3;
+
429  typedef vec<4, float, lowp> lowp_fvec4;
+
430 
+
431  typedef vec<1, float, mediump> mediump_fvec1;
+
432  typedef vec<2, float, mediump> mediump_fvec2;
+
433  typedef vec<3, float, mediump> mediump_fvec3;
+
434  typedef vec<4, float, mediump> mediump_fvec4;
+
435 
+
436  typedef vec<1, float, highp> highp_fvec1;
+
437  typedef vec<2, float, highp> highp_fvec2;
+
438  typedef vec<3, float, highp> highp_fvec3;
+
439  typedef vec<4, float, highp> highp_fvec4;
+
440 
+
441  typedef vec<1, f32, defaultp> fvec1;
+
442  typedef vec<2, f32, defaultp> fvec2;
+
443  typedef vec<3, f32, defaultp> fvec3;
+
444  typedef vec<4, f32, defaultp> fvec4;
+
445 
+
446  typedef vec<1, f32, lowp> lowp_f32vec1;
+
447  typedef vec<2, f32, lowp> lowp_f32vec2;
+
448  typedef vec<3, f32, lowp> lowp_f32vec3;
+
449  typedef vec<4, f32, lowp> lowp_f32vec4;
+
450 
+
451  typedef vec<1, f32, mediump> mediump_f32vec1;
+
452  typedef vec<2, f32, mediump> mediump_f32vec2;
+
453  typedef vec<3, f32, mediump> mediump_f32vec3;
+
454  typedef vec<4, f32, mediump> mediump_f32vec4;
+
455 
+
456  typedef vec<1, f32, highp> highp_f32vec1;
+
457  typedef vec<2, f32, highp> highp_f32vec2;
+
458  typedef vec<3, f32, highp> highp_f32vec3;
+
459  typedef vec<4, f32, highp> highp_f32vec4;
+
460 
+
461  typedef vec<1, f32, defaultp> f32vec1;
+
462  typedef vec<2, f32, defaultp> f32vec2;
+
463  typedef vec<3, f32, defaultp> f32vec3;
+
464  typedef vec<4, f32, defaultp> f32vec4;
+
465 
+
466  typedef vec<1, f64, lowp> lowp_dvec1;
+
467  typedef vec<2, f64, lowp> lowp_dvec2;
+
468  typedef vec<3, f64, lowp> lowp_dvec3;
+
469  typedef vec<4, f64, lowp> lowp_dvec4;
+
470 
+
471  typedef vec<1, f64, mediump> mediump_dvec1;
+
472  typedef vec<2, f64, mediump> mediump_dvec2;
+
473  typedef vec<3, f64, mediump> mediump_dvec3;
+
474  typedef vec<4, f64, mediump> mediump_dvec4;
+
475 
+
476  typedef vec<1, f64, highp> highp_dvec1;
+
477  typedef vec<2, f64, highp> highp_dvec2;
+
478  typedef vec<3, f64, highp> highp_dvec3;
+
479  typedef vec<4, f64, highp> highp_dvec4;
+
480 
+
481  typedef vec<1, f64, defaultp> dvec1;
+
482  typedef vec<2, f64, defaultp> dvec2;
+
483  typedef vec<3, f64, defaultp> dvec3;
+
484  typedef vec<4, f64, defaultp> dvec4;
+
485 
+
486  typedef vec<1, f64, lowp> lowp_f64vec1;
+
487  typedef vec<2, f64, lowp> lowp_f64vec2;
+
488  typedef vec<3, f64, lowp> lowp_f64vec3;
+
489  typedef vec<4, f64, lowp> lowp_f64vec4;
+
490 
+
491  typedef vec<1, f64, mediump> mediump_f64vec1;
+
492  typedef vec<2, f64, mediump> mediump_f64vec2;
+
493  typedef vec<3, f64, mediump> mediump_f64vec3;
+
494  typedef vec<4, f64, mediump> mediump_f64vec4;
+
495 
+
496  typedef vec<1, f64, highp> highp_f64vec1;
+
497  typedef vec<2, f64, highp> highp_f64vec2;
+
498  typedef vec<3, f64, highp> highp_f64vec3;
+
499  typedef vec<4, f64, highp> highp_f64vec4;
+
500 
+
501  typedef vec<1, f64, defaultp> f64vec1;
+
502  typedef vec<2, f64, defaultp> f64vec2;
+
503  typedef vec<3, f64, defaultp> f64vec3;
+
504  typedef vec<4, f64, defaultp> f64vec4;
+
505 
+
506  // Matrix NxN
+
507 
+
508  typedef mat<2, 2, f32, lowp> lowp_mat2;
+
509  typedef mat<3, 3, f32, lowp> lowp_mat3;
+
510  typedef mat<4, 4, f32, lowp> lowp_mat4;
+
511 
+
512  typedef mat<2, 2, f32, mediump> mediump_mat2;
+
513  typedef mat<3, 3, f32, mediump> mediump_mat3;
+
514  typedef mat<4, 4, f32, mediump> mediump_mat4;
+
515 
+
516  typedef mat<2, 2, f32, highp> highp_mat2;
+
517  typedef mat<3, 3, f32, highp> highp_mat3;
+
518  typedef mat<4, 4, f32, highp> highp_mat4;
+
519 
+
520  typedef mat<2, 2, f32, defaultp> mat2;
+
521  typedef mat<3, 3, f32, defaultp> mat3;
+
522  typedef mat<4, 4, f32, defaultp> mat4;
+
523 
+
524  typedef mat<2, 2, f32, lowp> lowp_fmat2;
+
525  typedef mat<3, 3, f32, lowp> lowp_fmat3;
+
526  typedef mat<4, 4, f32, lowp> lowp_fmat4;
+
527 
+
528  typedef mat<2, 2, f32, mediump> mediump_fmat2;
+
529  typedef mat<3, 3, f32, mediump> mediump_fmat3;
+
530  typedef mat<4, 4, f32, mediump> mediump_fmat4;
+
531 
+
532  typedef mat<2, 2, f32, highp> highp_fmat2;
+
533  typedef mat<3, 3, f32, highp> highp_fmat3;
+
534  typedef mat<4, 4, f32, highp> highp_fmat4;
+
535 
+
536  typedef mat<2, 2, f32, defaultp> fmat2;
+
537  typedef mat<3, 3, f32, defaultp> fmat3;
+
538  typedef mat<4, 4, f32, defaultp> fmat4;
+
539 
+
540  typedef mat<2, 2, f32, lowp> lowp_f32mat2;
+
541  typedef mat<3, 3, f32, lowp> lowp_f32mat3;
+
542  typedef mat<4, 4, f32, lowp> lowp_f32mat4;
+
543 
+
544  typedef mat<2, 2, f32, mediump> mediump_f32mat2;
+
545  typedef mat<3, 3, f32, mediump> mediump_f32mat3;
+
546  typedef mat<4, 4, f32, mediump> mediump_f32mat4;
+
547 
+
548  typedef mat<2, 2, f32, highp> highp_f32mat2;
+
549  typedef mat<3, 3, f32, highp> highp_f32mat3;
+
550  typedef mat<4, 4, f32, highp> highp_f32mat4;
+
551 
+
552  typedef mat<2, 2, f32, defaultp> f32mat2;
+
553  typedef mat<3, 3, f32, defaultp> f32mat3;
+
554  typedef mat<4, 4, f32, defaultp> f32mat4;
+
555 
+
556  typedef mat<2, 2, f64, lowp> lowp_dmat2;
+
557  typedef mat<3, 3, f64, lowp> lowp_dmat3;
+
558  typedef mat<4, 4, f64, lowp> lowp_dmat4;
+
559 
+
560  typedef mat<2, 2, f64, mediump> mediump_dmat2;
+
561  typedef mat<3, 3, f64, mediump> mediump_dmat3;
+
562  typedef mat<4, 4, f64, mediump> mediump_dmat4;
+
563 
+
564  typedef mat<2, 2, f64, highp> highp_dmat2;
+
565  typedef mat<3, 3, f64, highp> highp_dmat3;
+
566  typedef mat<4, 4, f64, highp> highp_dmat4;
+
567 
+
568  typedef mat<2, 2, f64, defaultp> dmat2;
+
569  typedef mat<3, 3, f64, defaultp> dmat3;
+
570  typedef mat<4, 4, f64, defaultp> dmat4;
+
571 
+
572  typedef mat<2, 2, f64, lowp> lowp_f64mat2;
+
573  typedef mat<3, 3, f64, lowp> lowp_f64mat3;
+
574  typedef mat<4, 4, f64, lowp> lowp_f64mat4;
+
575 
+
576  typedef mat<2, 2, f64, mediump> mediump_f64mat2;
+
577  typedef mat<3, 3, f64, mediump> mediump_f64mat3;
+
578  typedef mat<4, 4, f64, mediump> mediump_f64mat4;
+
579 
+
580  typedef mat<2, 2, f64, highp> highp_f64mat2;
+
581  typedef mat<3, 3, f64, highp> highp_f64mat3;
+
582  typedef mat<4, 4, f64, highp> highp_f64mat4;
+
583 
+
584  typedef mat<2, 2, f64, defaultp> f64mat2;
+
585  typedef mat<3, 3, f64, defaultp> f64mat3;
+
586  typedef mat<4, 4, f64, defaultp> f64mat4;
+
587 
+
588  // Matrix MxN
+
589 
+
590  typedef mat<2, 2, f32, lowp> lowp_mat2x2;
+
591  typedef mat<2, 3, f32, lowp> lowp_mat2x3;
+
592  typedef mat<2, 4, f32, lowp> lowp_mat2x4;
+
593  typedef mat<3, 2, f32, lowp> lowp_mat3x2;
+
594  typedef mat<3, 3, f32, lowp> lowp_mat3x3;
+
595  typedef mat<3, 4, f32, lowp> lowp_mat3x4;
+
596  typedef mat<4, 2, f32, lowp> lowp_mat4x2;
+
597  typedef mat<4, 3, f32, lowp> lowp_mat4x3;
+
598  typedef mat<4, 4, f32, lowp> lowp_mat4x4;
+
599 
+
600  typedef mat<2, 2, f32, mediump> mediump_mat2x2;
+
601  typedef mat<2, 3, f32, mediump> mediump_mat2x3;
+
602  typedef mat<2, 4, f32, mediump> mediump_mat2x4;
+
603  typedef mat<3, 2, f32, mediump> mediump_mat3x2;
+
604  typedef mat<3, 3, f32, mediump> mediump_mat3x3;
+
605  typedef mat<3, 4, f32, mediump> mediump_mat3x4;
+
606  typedef mat<4, 2, f32, mediump> mediump_mat4x2;
+
607  typedef mat<4, 3, f32, mediump> mediump_mat4x3;
+
608  typedef mat<4, 4, f32, mediump> mediump_mat4x4;
+
609 
+
610  typedef mat<2, 2, f32, highp> highp_mat2x2;
+
611  typedef mat<2, 3, f32, highp> highp_mat2x3;
+
612  typedef mat<2, 4, f32, highp> highp_mat2x4;
+
613  typedef mat<3, 2, f32, highp> highp_mat3x2;
+
614  typedef mat<3, 3, f32, highp> highp_mat3x3;
+
615  typedef mat<3, 4, f32, highp> highp_mat3x4;
+
616  typedef mat<4, 2, f32, highp> highp_mat4x2;
+
617  typedef mat<4, 3, f32, highp> highp_mat4x3;
+
618  typedef mat<4, 4, f32, highp> highp_mat4x4;
+
619 
+
620  typedef mat<2, 2, f32, defaultp> mat2x2;
+
621  typedef mat<3, 2, f32, defaultp> mat3x2;
+
622  typedef mat<4, 2, f32, defaultp> mat4x2;
+
623  typedef mat<2, 3, f32, defaultp> mat2x3;
+
624  typedef mat<3, 3, f32, defaultp> mat3x3;
+
625  typedef mat<4, 3, f32, defaultp> mat4x3;
+
626  typedef mat<2, 4, f32, defaultp> mat2x4;
+
627  typedef mat<3, 4, f32, defaultp> mat3x4;
+
628  typedef mat<4, 4, f32, defaultp> mat4x4;
+
629 
+
630  typedef mat<2, 2, f32, lowp> lowp_fmat2x2;
+
631  typedef mat<2, 3, f32, lowp> lowp_fmat2x3;
+
632  typedef mat<2, 4, f32, lowp> lowp_fmat2x4;
+
633  typedef mat<3, 2, f32, lowp> lowp_fmat3x2;
+
634  typedef mat<3, 3, f32, lowp> lowp_fmat3x3;
+
635  typedef mat<3, 4, f32, lowp> lowp_fmat3x4;
+
636  typedef mat<4, 2, f32, lowp> lowp_fmat4x2;
+
637  typedef mat<4, 3, f32, lowp> lowp_fmat4x3;
+
638  typedef mat<4, 4, f32, lowp> lowp_fmat4x4;
+
639 
+
640  typedef mat<2, 2, f32, mediump> mediump_fmat2x2;
+
641  typedef mat<2, 3, f32, mediump> mediump_fmat2x3;
+
642  typedef mat<2, 4, f32, mediump> mediump_fmat2x4;
+
643  typedef mat<3, 2, f32, mediump> mediump_fmat3x2;
+
644  typedef mat<3, 3, f32, mediump> mediump_fmat3x3;
+
645  typedef mat<3, 4, f32, mediump> mediump_fmat3x4;
+
646  typedef mat<4, 2, f32, mediump> mediump_fmat4x2;
+
647  typedef mat<4, 3, f32, mediump> mediump_fmat4x3;
+
648  typedef mat<4, 4, f32, mediump> mediump_fmat4x4;
+
649 
+
650  typedef mat<2, 2, f32, highp> highp_fmat2x2;
+
651  typedef mat<2, 3, f32, highp> highp_fmat2x3;
+
652  typedef mat<2, 4, f32, highp> highp_fmat2x4;
+
653  typedef mat<3, 2, f32, highp> highp_fmat3x2;
+
654  typedef mat<3, 3, f32, highp> highp_fmat3x3;
+
655  typedef mat<3, 4, f32, highp> highp_fmat3x4;
+
656  typedef mat<4, 2, f32, highp> highp_fmat4x2;
+
657  typedef mat<4, 3, f32, highp> highp_fmat4x3;
+
658  typedef mat<4, 4, f32, highp> highp_fmat4x4;
+
659 
+
660  typedef mat<2, 2, f32, defaultp> fmat2x2;
+
661  typedef mat<3, 2, f32, defaultp> fmat3x2;
+
662  typedef mat<4, 2, f32, defaultp> fmat4x2;
+
663  typedef mat<2, 3, f32, defaultp> fmat2x3;
+
664  typedef mat<3, 3, f32, defaultp> fmat3x3;
+
665  typedef mat<4, 3, f32, defaultp> fmat4x3;
+
666  typedef mat<2, 4, f32, defaultp> fmat2x4;
+
667  typedef mat<3, 4, f32, defaultp> fmat3x4;
+
668  typedef mat<4, 4, f32, defaultp> fmat4x4;
+
669 
+
670  typedef mat<2, 2, f32, lowp> lowp_f32mat2x2;
+
671  typedef mat<2, 3, f32, lowp> lowp_f32mat2x3;
+
672  typedef mat<2, 4, f32, lowp> lowp_f32mat2x4;
+
673  typedef mat<3, 2, f32, lowp> lowp_f32mat3x2;
+
674  typedef mat<3, 3, f32, lowp> lowp_f32mat3x3;
+
675  typedef mat<3, 4, f32, lowp> lowp_f32mat3x4;
+
676  typedef mat<4, 2, f32, lowp> lowp_f32mat4x2;
+
677  typedef mat<4, 3, f32, lowp> lowp_f32mat4x3;
+
678  typedef mat<4, 4, f32, lowp> lowp_f32mat4x4;
+
679 
+
680  typedef mat<2, 2, f32, mediump> mediump_f32mat2x2;
+
681  typedef mat<2, 3, f32, mediump> mediump_f32mat2x3;
+
682  typedef mat<2, 4, f32, mediump> mediump_f32mat2x4;
+
683  typedef mat<3, 2, f32, mediump> mediump_f32mat3x2;
+
684  typedef mat<3, 3, f32, mediump> mediump_f32mat3x3;
+
685  typedef mat<3, 4, f32, mediump> mediump_f32mat3x4;
+
686  typedef mat<4, 2, f32, mediump> mediump_f32mat4x2;
+
687  typedef mat<4, 3, f32, mediump> mediump_f32mat4x3;
+
688  typedef mat<4, 4, f32, mediump> mediump_f32mat4x4;
+
689 
+
690  typedef mat<2, 2, f32, highp> highp_f32mat2x2;
+
691  typedef mat<2, 3, f32, highp> highp_f32mat2x3;
+
692  typedef mat<2, 4, f32, highp> highp_f32mat2x4;
+
693  typedef mat<3, 2, f32, highp> highp_f32mat3x2;
+
694  typedef mat<3, 3, f32, highp> highp_f32mat3x3;
+
695  typedef mat<3, 4, f32, highp> highp_f32mat3x4;
+
696  typedef mat<4, 2, f32, highp> highp_f32mat4x2;
+
697  typedef mat<4, 3, f32, highp> highp_f32mat4x3;
+
698  typedef mat<4, 4, f32, highp> highp_f32mat4x4;
+
699 
+
700  typedef mat<2, 2, f32, defaultp> f32mat2x2;
+
701  typedef mat<3, 2, f32, defaultp> f32mat3x2;
+
702  typedef mat<4, 2, f32, defaultp> f32mat4x2;
+
703  typedef mat<2, 3, f32, defaultp> f32mat2x3;
+
704  typedef mat<3, 3, f32, defaultp> f32mat3x3;
+
705  typedef mat<4, 3, f32, defaultp> f32mat4x3;
+
706  typedef mat<2, 4, f32, defaultp> f32mat2x4;
+
707  typedef mat<3, 4, f32, defaultp> f32mat3x4;
+
708  typedef mat<4, 4, f32, defaultp> f32mat4x4;
+
709 
+
710  typedef mat<2, 2, double, lowp> lowp_dmat2x2;
+
711  typedef mat<2, 3, double, lowp> lowp_dmat2x3;
+
712  typedef mat<2, 4, double, lowp> lowp_dmat2x4;
+
713  typedef mat<3, 2, double, lowp> lowp_dmat3x2;
+
714  typedef mat<3, 3, double, lowp> lowp_dmat3x3;
+
715  typedef mat<3, 4, double, lowp> lowp_dmat3x4;
+
716  typedef mat<4, 2, double, lowp> lowp_dmat4x2;
+
717  typedef mat<4, 3, double, lowp> lowp_dmat4x3;
+
718  typedef mat<4, 4, double, lowp> lowp_dmat4x4;
+
719 
+
720  typedef mat<2, 2, double, mediump> mediump_dmat2x2;
+
721  typedef mat<2, 3, double, mediump> mediump_dmat2x3;
+
722  typedef mat<2, 4, double, mediump> mediump_dmat2x4;
+
723  typedef mat<3, 2, double, mediump> mediump_dmat3x2;
+
724  typedef mat<3, 3, double, mediump> mediump_dmat3x3;
+
725  typedef mat<3, 4, double, mediump> mediump_dmat3x4;
+
726  typedef mat<4, 2, double, mediump> mediump_dmat4x2;
+
727  typedef mat<4, 3, double, mediump> mediump_dmat4x3;
+
728  typedef mat<4, 4, double, mediump> mediump_dmat4x4;
+
729 
+
730  typedef mat<2, 2, double, highp> highp_dmat2x2;
+
731  typedef mat<2, 3, double, highp> highp_dmat2x3;
+
732  typedef mat<2, 4, double, highp> highp_dmat2x4;
+
733  typedef mat<3, 2, double, highp> highp_dmat3x2;
+
734  typedef mat<3, 3, double, highp> highp_dmat3x3;
+
735  typedef mat<3, 4, double, highp> highp_dmat3x4;
+
736  typedef mat<4, 2, double, highp> highp_dmat4x2;
+
737  typedef mat<4, 3, double, highp> highp_dmat4x3;
+
738  typedef mat<4, 4, double, highp> highp_dmat4x4;
+
739 
+
740  typedef mat<2, 2, double, defaultp> dmat2x2;
+
741  typedef mat<3, 2, double, defaultp> dmat3x2;
+
742  typedef mat<4, 2, double, defaultp> dmat4x2;
+
743  typedef mat<2, 3, double, defaultp> dmat2x3;
+
744  typedef mat<3, 3, double, defaultp> dmat3x3;
+
745  typedef mat<4, 3, double, defaultp> dmat4x3;
+
746  typedef mat<2, 4, double, defaultp> dmat2x4;
+
747  typedef mat<3, 4, double, defaultp> dmat3x4;
+
748  typedef mat<4, 4, double, defaultp> dmat4x4;
+
749 
+
750  typedef mat<2, 2, f64, lowp> lowp_f64mat2x2;
+
751  typedef mat<2, 3, f64, lowp> lowp_f64mat2x3;
+
752  typedef mat<2, 4, f64, lowp> lowp_f64mat2x4;
+
753  typedef mat<3, 2, f64, lowp> lowp_f64mat3x2;
+
754  typedef mat<3, 3, f64, lowp> lowp_f64mat3x3;
+
755  typedef mat<3, 4, f64, lowp> lowp_f64mat3x4;
+
756  typedef mat<4, 2, f64, lowp> lowp_f64mat4x2;
+
757  typedef mat<4, 3, f64, lowp> lowp_f64mat4x3;
+
758  typedef mat<4, 4, f64, lowp> lowp_f64mat4x4;
+
759 
+
760  typedef mat<2, 2, f64, mediump> mediump_f64mat2x2;
+
761  typedef mat<2, 3, f64, mediump> mediump_f64mat2x3;
+
762  typedef mat<2, 4, f64, mediump> mediump_f64mat2x4;
+
763  typedef mat<3, 2, f64, mediump> mediump_f64mat3x2;
+
764  typedef mat<3, 3, f64, mediump> mediump_f64mat3x3;
+
765  typedef mat<3, 4, f64, mediump> mediump_f64mat3x4;
+
766  typedef mat<4, 2, f64, mediump> mediump_f64mat4x2;
+
767  typedef mat<4, 3, f64, mediump> mediump_f64mat4x3;
+
768  typedef mat<4, 4, f64, mediump> mediump_f64mat4x4;
+
769 
+
770  typedef mat<2, 2, f64, highp> highp_f64mat2x2;
+
771  typedef mat<2, 3, f64, highp> highp_f64mat2x3;
+
772  typedef mat<2, 4, f64, highp> highp_f64mat2x4;
+
773  typedef mat<3, 2, f64, highp> highp_f64mat3x2;
+
774  typedef mat<3, 3, f64, highp> highp_f64mat3x3;
+
775  typedef mat<3, 4, f64, highp> highp_f64mat3x4;
+
776  typedef mat<4, 2, f64, highp> highp_f64mat4x2;
+
777  typedef mat<4, 3, f64, highp> highp_f64mat4x3;
+
778  typedef mat<4, 4, f64, highp> highp_f64mat4x4;
+
779 
+
780  typedef mat<2, 2, f64, defaultp> f64mat2x2;
+
781  typedef mat<3, 2, f64, defaultp> f64mat3x2;
+
782  typedef mat<4, 2, f64, defaultp> f64mat4x2;
+
783  typedef mat<2, 3, f64, defaultp> f64mat2x3;
+
784  typedef mat<3, 3, f64, defaultp> f64mat3x3;
+
785  typedef mat<4, 3, f64, defaultp> f64mat4x3;
+
786  typedef mat<2, 4, f64, defaultp> f64mat2x4;
+
787  typedef mat<3, 4, f64, defaultp> f64mat3x4;
+
788  typedef mat<4, 4, f64, defaultp> f64mat4x4;
+
789 
+
790  // Quaternion
+
791 
+
792  typedef qua<float, lowp> lowp_quat;
+
793  typedef qua<float, mediump> mediump_quat;
+
794  typedef qua<float, highp> highp_quat;
+
795  typedef qua<float, defaultp> quat;
+
796 
+
797  typedef qua<float, lowp> lowp_fquat;
+
798  typedef qua<float, mediump> mediump_fquat;
+
799  typedef qua<float, highp> highp_fquat;
+
800  typedef qua<float, defaultp> fquat;
+
801 
+
802  typedef qua<f32, lowp> lowp_f32quat;
+
803  typedef qua<f32, mediump> mediump_f32quat;
+
804  typedef qua<f32, highp> highp_f32quat;
+
805  typedef qua<f32, defaultp> f32quat;
+
806 
+
807  typedef qua<double, lowp> lowp_dquat;
+
808  typedef qua<double, mediump> mediump_dquat;
+
809  typedef qua<double, highp> highp_dquat;
+
810  typedef qua<double, defaultp> dquat;
+
811 
+
812  typedef qua<f64, lowp> lowp_f64quat;
+
813  typedef qua<f64, mediump> mediump_f64quat;
+
814  typedef qua<f64, highp> highp_f64quat;
+
815  typedef qua<f64, defaultp> f64quat;
+
816 }//namespace glm
+
817 
+
818 
+
vec< 1, u16, highp > highp_u16vec1
High qualifier 16 bit unsigned integer scalar type.
Definition: fwd.hpp:354
+
mat< 4, 2, float, mediump > mediump_mat4x2
4 columns of 2 components matrix of single-precision floating-point numbers using medium precision ar...
+
mat< 4, 2, f32, highp > highp_f32mat4x2
High single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:696
+
mat< 4, 3, float, highp > highp_mat4x3
4 columns of 3 components matrix of single-precision floating-point numbers using high precision arit...
+
mat< 4, 4, float, defaultp > mat4x4
4 columns of 4 components matrix of single-precision floating-point numbers.
+
vec< 4, unsigned int, mediump > mediump_uvec4
4 components vector of medium qualifier unsigned integer numbers.
+
uint64 highp_u64
High qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:133
+
vec< 1, f64, mediump > mediump_f64vec1
Medium double-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:491
+
vec< 3, f32, defaultp > f32vec3
Single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:463
+
mat< 2, 2, f32, mediump > mediump_fmat2
Medium single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:528
+
double highp_float64_t
High 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:175
+
mat< 4, 4, f64, defaultp > f64mat4
Double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:586
+
vec< 1, int, mediump > mediump_ivec1
1 component vector of signed integer values.
+
vec< 4, double, mediump > mediump_dvec4
4 components vector of medium double-qualifier floating-point numbers.
+
vec< 3, float, highp > highp_vec3
3 components vector of high single-qualifier floating-point numbers.
+
mat< 4, 2, double, lowp > lowp_dmat4x2
4 columns of 2 components matrix of double-precision floating-point numbers using low precision arith...
+
mat< 2, 2, float, defaultp > mat2x2
2 columns of 2 components matrix of single-precision floating-point numbers.
+
mat< 2, 2, f64, defaultp > f64mat2
Double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:584
+
mat< 4, 3, f32, mediump > mediump_fmat4x3
Medium single-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:647
+
mat< 3, 3, f32, mediump > mediump_f32mat3
Medium single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:545
+
uint32 mediump_uint32_t
Medium qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:127
+
uint64 lowp_uint64
Low qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:136
+
mat< 3, 3, float, mediump > mediump_mat3x3
3 columns of 3 components matrix of single-precision floating-point numbers using medium precision ar...
+
mat< 2, 2, f32, mediump > mediump_fmat2x2
Medium single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:640
+
vec< 1, f32, defaultp > f32vec1
Single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:461
+
mat< 4, 4, f32, highp > highp_f32mat4
High single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:550
+
qua< float, highp > highp_quat
Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs...
+
double highp_float64
High 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:170
+
mat< 3, 2, double, mediump > mediump_dmat3x2
3 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
+
uint8 lowp_u8
Low qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:89
+
mat< 3, 2, double, lowp > lowp_dmat3x2
3 columns of 2 components matrix of double-precision floating-point numbers using low precision arith...
+
uint32 u32
Default qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:120
+
mat< 3, 3, f64, defaultp > f64mat3
Double-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:585
+
vec< 2, int, highp > highp_ivec2
2 components vector of high qualifier signed integer numbers.
+
mat< 4, 3, double, highp > highp_dmat4x3
4 columns of 3 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 2, 3, float, mediump > mediump_mat2x3
2 columns of 3 components matrix of single-precision floating-point numbers using medium precision ar...
+
double lowp_float64
Low 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:168
+
vec< 1, i32, defaultp > i32vec1
32 bit signed integer scalar type.
Definition: fwd.hpp:277
+
uint16 highp_uint16
High qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:110
+
mat< 2, 4, f64, mediump > mediump_f64mat2x4
Medium double-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:762
+
vec< 4, i64, highp > highp_i64vec4
High qualifier 64 bit signed integer vector of 4 components type.
Definition: fwd.hpp:295
+
mat< 4, 4, double, mediump > mediump_dmat4x4
4 columns of 4 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 3, 4, f64, defaultp > f64mat3x4
Double-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:787
+
vec< 4, double, highp > highp_dvec4
4 components vector of high double-qualifier floating-point numbers.
+
mat< 2, 2, f32, defaultp > fmat2
Single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:536
+
mat< 3, 4, double, lowp > lowp_dmat3x4
3 columns of 4 components matrix of double-precision floating-point numbers using low precision arith...
+
vec< 3, i16, defaultp > i16vec3
16 bit signed integer vector of 3 components type.
Definition: fwd.hpp:259
+
uint32 lowp_uint32_t
Low qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:126
+
vec< 2, float, lowp > lowp_fvec2
Low single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:427
+
uint32 mediump_uint32
Medium qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:123
+
mat< 4, 4, f32, mediump > mediump_fmat4
Medium single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:530
+
uint64 highp_uint64
High qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:138
+
mat< 2, 2, f32, lowp > lowp_fmat2
Low single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:524
+
uint32 lowp_uint32
Low qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:122
+
vec< 3, float, lowp > lowp_fvec3
Low single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:428
+
vec< 2, float, mediump > mediump_fvec2
Medium Single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:432
+
mat< 2, 3, float, highp > highp_mat2x3
2 columns of 3 components matrix of single-precision floating-point numbers using high precision arit...
+
mat< 3, 4, f32, lowp > lowp_fmat3x4
Low single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:635
+
vec< 2, float, defaultp > vec2
2 components vector of single-precision floating-point numbers.
+
mat< 2, 2, f64, lowp > lowp_f64mat2x2
Low double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:750
+
vec< 4, i64, defaultp > i64vec4
64 bit signed integer vector of 4 components type.
Definition: fwd.hpp:300
+
vec< 3, u16, defaultp > u16vec3
Default qualifier 16 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:361
+
vec< 1, u64, lowp > lowp_u64vec1
Low qualifier 64 bit unsigned integer scalar type.
Definition: fwd.hpp:384
+
mat< 2, 2, double, mediump > mediump_dmat2
2 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
+
vec< 1, u16, mediump > mediump_u16vec1
Medium qualifier 16 bit unsigned integer scalar type.
Definition: fwd.hpp:349
+
vec< 2, float, highp > highp_vec2
2 components vector of high single-qualifier floating-point numbers.
+
vec< 2, i8, defaultp > i8vec2
8 bit signed integer vector of 2 components type.
Definition: fwd.hpp:238
+
mat< 2, 3, f64, mediump > mediump_f64mat2x3
Medium double-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:761
+
vec< 4, u32, lowp > lowp_u32vec4
Low qualifier 32 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:367
+
vec< 4, f32, highp > highp_f32vec4
High single-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:459
+
vec< 3, unsigned int, defaultp > uvec3
3 components vector of unsigned integer numbers.
+
vec< 1, f32, lowp > lowp_f32vec1
Low single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:446
+
mat< 2, 3, f32, highp > highp_f32mat2x3
High single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:691
+
int64 highp_int64
High qualifier 64 bit signed integer type.
Definition: fwd.hpp:80
+
vec< 2, i32, mediump > mediump_i32vec2
Medium qualifier 32 bit signed integer vector of 2 components type.
Definition: fwd.hpp:268
+
vec< 1, double, lowp > lowp_dvec1
1 component vector of double-precision floating-point numbers using low precision arithmetic in term ...
+
mat< 4, 4, f64, lowp > lowp_f64mat4
Low double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:574
+
mat< 4, 4, f32, defaultp > fmat4
Single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:538
+
mat< 3, 4, f32, mediump > mediump_fmat3x4
Medium single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:645
+
mat< 3, 3, double, lowp > lowp_dmat3
3 columns of 3 components matrix of double-precision floating-point numbers using low precision arith...
+
int16 lowp_int16_t
Low qualifier 16 bit signed integer type.
Definition: fwd.hpp:54
+
vec< 4, i32, highp > highp_i32vec4
High qualifier 32 bit signed integer vector of 4 components type.
Definition: fwd.hpp:275
+
mat< 4, 2, f32, defaultp > f32mat4x2
Single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:702
+
mat< 3, 2, f32, highp > highp_fmat3x2
High single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:653
+
mat< 2, 4, float, defaultp > mat2x4
2 columns of 4 components matrix of single-precision floating-point numbers.
+
mat< 2, 3, f32, mediump > mediump_fmat2x3
Medium single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:641
+
uint32 mediump_u32
Medium qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:118
+
mat< 3, 2, f32, lowp > lowp_fmat3x2
Low single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:633
+
mat< 2, 3, float, lowp > lowp_mat2x3
2 columns of 3 components matrix of single-precision floating-point numbers using low precision arith...
+
mat< 2, 2, float, lowp > lowp_mat2
2 columns of 2 components matrix of single-precision floating-point numbers using low precision arith...
+
mat< 4, 2, f64, mediump > mediump_f64mat4x2
Medium double-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:766
+
vec< 4, bool, lowp > lowp_bvec4
4 components vector of low qualifier bool numbers.
+
vec< 2, u16, highp > highp_u16vec2
High qualifier 16 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:355
+
vec< 1, f64, highp > highp_f64vec1
High double-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:496
+
vec< 3, int, defaultp > ivec3
3 components vector of signed integer numbers.
Definition: vector_int3.hpp:15
+
vec< 2, i16, mediump > mediump_i16vec2
Medium qualifier 16 bit signed integer vector of 2 components type.
Definition: fwd.hpp:248
+
mat< 2, 4, f32, highp > highp_fmat2x4
High single-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:652
+
vec< 3, u64, defaultp > u64vec3
Default qualifier 64 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:401
+
uint8 lowp_uint8
Low qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:94
+
mat< 3, 2, f32, lowp > lowp_f32mat3x2
Low single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:673
+
vec< 4, bool, mediump > mediump_bvec4
4 components vector of medium qualifier bool numbers.
+
mat< 3, 2, float, defaultp > mat3x2
3 columns of 2 components matrix of single-precision floating-point numbers.
+
uint64 lowp_u64
Low qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:131
+
vec< 1, unsigned int, mediump > mediump_uvec1
1 component vector of unsigned integer values.
+
vec< 3, i64, highp > highp_i64vec3
High qualifier 64 bit signed integer vector of 3 components type.
Definition: fwd.hpp:294
+
int8 mediump_int8
Medium qualifier 8 bit signed integer type.
Definition: fwd.hpp:37
+
int64 lowp_int64
Low qualifier 64 bit signed integer type.
Definition: fwd.hpp:78
+
vec< 1, float, lowp > lowp_vec1
1 component vector of single-precision floating-point numbers using low precision arithmetic in term ...
+
mat< 4, 2, f32, mediump > mediump_f32mat4x2
Medium single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:686
+
mat< 3, 3, float, highp > highp_mat3x3
3 columns of 3 components matrix of single-precision floating-point numbers using high precision arit...
+
vec< 3, f64, lowp > lowp_f64vec3
Low double-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:488
+
mat< 3, 4, float, defaultp > mat3x4
3 columns of 4 components matrix of single-precision floating-point numbers.
+
mat< 3, 3, float, lowp > lowp_mat3x3
3 columns of 3 components matrix of single-precision floating-point numbers using low precision arith...
+
vec< 2, u64, defaultp > u64vec2
Default qualifier 64 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:400
+
vec< 3, i64, lowp > lowp_i64vec3
Low qualifier 64 bit signed integer vector of 3 components type.
Definition: fwd.hpp:284
+
vec< 2, i8, mediump > mediump_i8vec2
Medium qualifier 8 bit signed integer vector of 2 components type.
Definition: fwd.hpp:228
+
vec< 4, float, lowp > lowp_vec4
4 components vector of low single-qualifier floating-point numbers.
+
mat< 4, 3, float, defaultp > mat4x3
4 columns of 3 components matrix of single-precision floating-point numbers.
+
mat< 3, 4, f32, defaultp > f32mat3x4
Single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:707
+
mat< 4, 2, double, mediump > mediump_dmat4x2
4 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
+
vec< 2, float, lowp > lowp_vec2
2 components vector of low single-qualifier floating-point numbers.
+
vec< 3, i16, highp > highp_i16vec3
High qualifier 16 bit signed integer vector of 3 components type.
Definition: fwd.hpp:254
+
mat< 2, 3, double, mediump > mediump_dmat2x3
2 columns of 3 components matrix of double-precision floating-point numbers using medium precision ar...
+
vec< 3, i16, mediump > mediump_i16vec3
Medium qualifier 16 bit signed integer vector of 3 components type.
Definition: fwd.hpp:249
+
uint64 u64
Default qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:134
+
vec< 2, int, mediump > mediump_ivec2
2 components vector of medium qualifier signed integer numbers.
+
mat< 3, 2, f32, mediump > mediump_fmat3x2
Medium single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:643
+
vec< 1, f64, defaultp > f64vec1
Double-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:501
+
vec< 1, i64, mediump > mediump_i64vec1
Medium qualifier 64 bit signed integer scalar type.
Definition: fwd.hpp:287
+
vec< 1, i16, defaultp > i16vec1
16 bit signed integer scalar type.
Definition: fwd.hpp:257
+
mat< 2, 2, double, lowp > lowp_dmat2
2 columns of 2 components matrix of double-precision floating-point numbers using low precision arith...
+
mat< 2, 4, double, highp > highp_dmat2x4
2 columns of 4 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 3, 3, f64, lowp > lowp_f64mat3x3
Low double-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:754
+
vec< 2, f64, lowp > lowp_f64vec2
Low double-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:487
+
mat< 2, 3, f32, highp > highp_fmat2x3
High single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:651
+
mat< 4, 3, f32, lowp > lowp_f32mat4x3
Low single-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:677
+
mat< 3, 3, f64, lowp > lowp_f64mat3
Low double-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:573
+
vec< 3, u64, mediump > mediump_u64vec3
Medium qualifier 64 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:391
+
double mediump_float64
Medium 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:169
+
double float64
Double-qualifier floating-point scalar.
Definition: fwd.hpp:171
+
vec< 2, bool, highp > highp_bvec2
2 components vector of high qualifier bool numbers.
+
vec< 2, i16, highp > highp_i16vec2
High qualifier 16 bit signed integer vector of 2 components type.
Definition: fwd.hpp:253
+
mat< 4, 2, f32, defaultp > fmat4x2
Single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:662
+
mat< 2, 3, f64, lowp > lowp_f64mat2x3
Low double-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:751
+
mat< 3, 4, f32, defaultp > fmat3x4
Single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:667
+
mat< 3, 3, double, lowp > lowp_dmat3x3
3 columns of 3 components matrix of double-precision floating-point numbers using low precision arith...
+
vec< 3, u32, lowp > lowp_u32vec3
Low qualifier 32 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:366
+
mat< 2, 4, f32, defaultp > f32mat2x4
Single-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:706
+
vec< 4, float, lowp > lowp_fvec4
Low single-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:429
+
vec< 4, f32, mediump > mediump_f32vec4
Medium single-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:454
+
vec< 4, i16, defaultp > i16vec4
16 bit signed integer vector of 4 components type.
Definition: fwd.hpp:260
+
uint8 lowp_uint8_t
Low qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:98
+
uint32 highp_uint32_t
High qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:128
+
mat< 3, 3, f32, defaultp > fmat3x3
Single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:664
+
mat< 3, 4, f64, mediump > mediump_f64mat3x4
Medium double-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:765
+
mat< 2, 3, f32, lowp > lowp_fmat2x3
Low single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:631
+
vec< 1, u32, lowp > lowp_u32vec1
Low qualifier 32 bit unsigned integer scalar type.
Definition: fwd.hpp:364
+
mat< 3, 2, float, lowp > lowp_mat3x2
3 columns of 2 components matrix of single-precision floating-point numbers using low precision arith...
+
mat< 2, 3, f32, defaultp > f32mat2x3
Single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:703
+
vec< 1, i32, mediump > mediump_i32vec1
Medium qualifier 32 bit signed integer scalar type.
Definition: fwd.hpp:267
+
vec< 4, u16, highp > highp_u16vec4
High qualifier 16 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:357
+
vec< 1, i32, lowp > lowp_i32vec1
Low qualifier 32 bit signed integer scalar type.
Definition: fwd.hpp:262
+
vec< 1, i64, lowp > lowp_i64vec1
Low qualifier 64 bit signed integer scalar type.
Definition: fwd.hpp:282
+
vec< 1, u32, highp > highp_u32vec1
High qualifier 32 bit unsigned integer scalar type.
Definition: fwd.hpp:374
+
vec< 1, bool, highp > highp_bvec1
1 component vector of bool values.
+
int16 mediump_int16
Medium qualifier 16 bit signed integer type.
Definition: fwd.hpp:51
+
uint16 mediump_u16
Medium qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:104
+
qua< f64, defaultp > f64quat
Double-qualifier floating-point quaternion.
Definition: fwd.hpp:815
+
vec< 4, float, mediump > mediump_vec4
4 components vector of medium single-qualifier floating-point numbers.
+
vec< 3, f64, mediump > mediump_f64vec3
Medium double-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:493
+
qua< double, defaultp > dquat
Quaternion of double-precision floating-point numbers.
+
vec< 1, u64, defaultp > u64vec1
Default qualifier 64 bit unsigned integer scalar type.
Definition: fwd.hpp:399
+
int64 int64_t
64 bit signed integer type.
Definition: fwd.hpp:85
+
vec< 1, u8, defaultp > u8vec1
Default qualifier 8 bit unsigned integer scalar type.
Definition: fwd.hpp:339
+
vec< 1, i8, highp > highp_i8vec1
High qualifier 8 bit signed integer scalar type.
Definition: fwd.hpp:232
+
vec< 4, u8, defaultp > u8vec4
Default qualifier 8 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:342
+
int8 int8_t
8 bit signed integer type.
Definition: fwd.hpp:43
+
int32 i32
32 bit signed integer type.
Definition: fwd.hpp:62
+
vec< 1, u32, mediump > mediump_u32vec1
Medium qualifier 32 bit unsigned integer scalar type.
Definition: fwd.hpp:369
+
mat< 2, 2, f64, defaultp > f64mat2x2
Double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:780
+
mat< 2, 2, f32, lowp > lowp_f32mat2x2
Low single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:670
+
vec< 4, f32, lowp > lowp_f32vec4
Low single-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:449
+
vec< 3, float, highp > highp_fvec3
High Single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:438
+
mat< 4, 2, f64, lowp > lowp_f64mat4x2
Low double-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:756
+
mat< 3, 3, f32, mediump > mediump_fmat3x3
Medium single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:644
+
vec< 1, i64, highp > highp_i64vec1
High qualifier 64 bit signed integer scalar type.
Definition: fwd.hpp:292
+
vec< 4, i8, defaultp > i8vec4
8 bit signed integer vector of 4 components type.
Definition: fwd.hpp:240
+
vec< 1, int, highp > highp_ivec1
1 component vector of signed integer values.
+
vec< 3, bool, mediump > mediump_bvec3
3 components vector of medium qualifier bool numbers.
+
int32 highp_int32
High qualifier 32 bit signed integer type.
Definition: fwd.hpp:66
+
mat< 2, 3, f32, mediump > mediump_f32mat2x3
Medium single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:681
+
mat< 3, 4, double, mediump > mediump_dmat3x4
3 columns of 4 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 3, 2, f64, lowp > lowp_f64mat3x2
Low double-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:753
+
mat< 4, 2, float, defaultp > mat4x2
4 columns of 2 components matrix of single-precision floating-point numbers.
+
vec< 1, float, mediump > mediump_vec1
1 component vector of single-precision floating-point numbers using medium precision arithmetic in te...
+
uint32 highp_u32
High qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:119
+
int32 highp_i32
High qualifier 32 bit signed integer type.
Definition: fwd.hpp:61
+
vec< 4, int, defaultp > ivec4
4 components vector of signed integer numbers.
Definition: vector_int4.hpp:15
+
mat< 4, 4, float, mediump > mediump_mat4x4
4 columns of 4 components matrix of single-precision floating-point numbers using medium precision ar...
+
vec< 4, u64, defaultp > u64vec4
Default qualifier 64 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:402
+
vec< 2, int, lowp > lowp_ivec2
2 components vector of low qualifier signed integer numbers.
+
vec< 4, f32, defaultp > f32vec4
Single-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:464
+
mat< 2, 3, f64, defaultp > f64mat2x3
Double-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:783
+
mat< 4, 4, f64, mediump > mediump_f64mat4x4
Medium double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:768
+
mat< 2, 2, double, mediump > mediump_dmat2x2
2 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
+
vec< 4, u16, lowp > lowp_u16vec4
Low qualifier 16 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:347
+
vec< 4, unsigned int, highp > highp_uvec4
4 components vector of high qualifier unsigned integer numbers.
+
uint32 highp_uint32
High qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:124
+
mat< 4, 4, f32, lowp > lowp_f32mat4
Low single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:542
+
mat< 3, 2, f64, defaultp > f64mat3x2
Double-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:781
+
float mediump_float32
Medium 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:153
+
vec< 1, u32, defaultp > u32vec1
Default qualifier 32 bit unsigned integer scalar type.
Definition: fwd.hpp:379
+
mat< 4, 2, float, lowp > lowp_mat4x2
4 columns of 2 components matrix of single-precision floating-point numbers using low precision arith...
+
vec< 4, f64, mediump > mediump_f64vec4
Medium double-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:494
+
mat< 3, 3, f64, defaultp > f64mat3x3
Double-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:784
+
float highp_float32
High 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:154
+
uint8 highp_uint8
High qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:96
+
int8 highp_i8
High qualifier 8 bit signed integer type.
Definition: fwd.hpp:33
+
mat< 2, 4, f64, lowp > lowp_f64mat2x4
Low double-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:752
+
mat< 3, 4, f64, lowp > lowp_f64mat3x4
Low double-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:755
+
vec< 3, float, lowp > lowp_vec3
3 components vector of low single-qualifier floating-point numbers.
+
mat< 3, 4, float, highp > highp_mat3x4
3 columns of 4 components matrix of single-precision floating-point numbers using high precision arit...
+
mat< 4, 4, float, lowp > lowp_mat4
4 columns of 4 components matrix of single-precision floating-point numbers using low precision arith...
+
int8 mediump_i8
Medium qualifier 8 bit signed integer type.
Definition: fwd.hpp:32
+
int64 highp_int64_t
High qualifier 64 bit signed integer type.
Definition: fwd.hpp:84
+
mat< 4, 4, f32, defaultp > f32mat4x4
Single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:708
+
float float32_t
Default 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:160
+
mat< 2, 2, f32, defaultp > f32mat2x2
Single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:700
+
vec< 2, i64, lowp > lowp_i64vec2
Low qualifier 64 bit signed integer vector of 2 components type.
Definition: fwd.hpp:283
+
mat< 2, 4, f32, lowp > lowp_f32mat2x4
Low single-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:672
+
vec< 4, bool, highp > highp_bvec4
4 components vector of high qualifier bool numbers.
+
uint32 uint32_t
Default qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:129
+
mat< 3, 3, f32, highp > highp_f32mat3
High single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:549
+
mat< 3, 3, f64, mediump > mediump_f64mat3x3
Medium double-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:764
+
vec< 2, bool, defaultp > bvec2
2 components vector of boolean.
+
vec< 4, float, defaultp > vec4
4 components vector of single-precision floating-point numbers.
+
uint8 u8
Default qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:92
+
vec< 3, i32, highp > highp_i32vec3
High qualifier 32 bit signed integer vector of 3 components type.
Definition: fwd.hpp:274
+
float float32
Single-qualifier floating-point scalar.
Definition: fwd.hpp:155
+
vec< 4, f32, defaultp > fvec4
Single-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:444
+
vec< 1, i32, highp > highp_i32vec1
High qualifier 32 bit signed integer scalar type.
Definition: fwd.hpp:272
+
mat< 3, 3, double, highp > highp_dmat3
3 columns of 3 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 3, 3, f32, lowp > lowp_f32mat3
Low single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:541
+
vec< 1, u16, defaultp > u16vec1
Default qualifier 16 bit unsigned integer scalar type.
Definition: fwd.hpp:359
+
mat< 2, 4, float, lowp > lowp_mat2x4
2 columns of 4 components matrix of single-precision floating-point numbers using low precision arith...
+
vec< 1, double, defaultp > dvec1
1 components vector of double-precision floating-point numbers.
+
vec< 1, i8, defaultp > i8vec1
8 bit signed integer scalar type.
Definition: fwd.hpp:237
+
vec< 3, i32, mediump > mediump_i32vec3
Medium qualifier 32 bit signed integer vector of 3 components type.
Definition: fwd.hpp:269
+
vec< 2, i32, defaultp > i32vec2
32 bit signed integer vector of 2 components type.
Definition: fwd.hpp:278
+
vec< 2, bool, mediump > mediump_bvec2
2 components vector of medium qualifier bool numbers.
+
vec< 2, i16, lowp > lowp_i16vec2
Low qualifier 16 bit signed integer vector of 2 components type.
Definition: fwd.hpp:243
+
vec< 2, float, mediump > mediump_vec2
2 components vector of medium single-qualifier floating-point numbers.
+
vec< 2, u64, mediump > mediump_u64vec2
Medium qualifier 64 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:390
+
vec< 4, u8, lowp > lowp_u8vec4
Low qualifier 8 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:327
+
mat< 3, 3, f32, highp > highp_f32mat3x3
High single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:694
+
vec< 1, u8, highp > highp_u8vec1
High qualifier 8 bit unsigned integer scalar type.
Definition: fwd.hpp:334
+
uint8 highp_uint8_t
High qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:100
+
vec< 4, u32, mediump > mediump_u32vec4
Medium qualifier 32 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:372
+
mat< 2, 2, f32, highp > highp_f32mat2x2
High single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:690
+
vec< 4, f64, highp > highp_f64vec4
High double-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:499
+
mat< 3, 3, double, highp > highp_dmat3x3
3 columns of 3 components matrix of double-precision floating-point numbers using medium precision ar...
+
vec< 3, u8, lowp > lowp_u8vec3
Low qualifier 8 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:326
+
float highp_f32
High 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:149
+
uint64 mediump_uint64
Medium qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:137
+
int32 highp_int32_t
32 bit signed integer type.
Definition: fwd.hpp:70
+
mat< 2, 3, f32, lowp > lowp_f32mat2x3
Low single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:671
+
vec< 3, f64, defaultp > f64vec3
Double-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:503
+
vec< 3, u16, mediump > mediump_u16vec3
Medium qualifier 16 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:351
+
mat< 2, 4, f64, defaultp > f64mat2x4
Double-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:786
+
qua< double, mediump > mediump_dquat
Quaternion of medium double-qualifier floating-point numbers using high precision arithmetic in term ...
+
mat< 3, 3, f32, defaultp > f32mat3
Single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:553
+
mat< 2, 2, f64, mediump > mediump_f64mat2x2
Medium double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:760
+
vec< 1, double, highp > highp_dvec1
1 component vector of double-precision floating-point numbers using high precision arithmetic in term...
+
mat< 3, 3, float, defaultp > mat3x3
3 columns of 3 components matrix of single-precision floating-point numbers.
+
uint64 mediump_u64
Medium qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:132
+
mat< 4, 4, float, mediump > mediump_mat4
4 columns of 4 components matrix of single-precision floating-point numbers using medium precision ar...
+
vec< 4, i16, highp > highp_i16vec4
High qualifier 16 bit signed integer vector of 4 components type.
Definition: fwd.hpp:255
+
mat< 4, 4, f32, lowp > lowp_fmat4
Low single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:526
+
vec< 2, u32, mediump > mediump_u32vec2
Medium qualifier 32 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:370
+
vec< 3, u64, highp > highp_u64vec3
High qualifier 64 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:396
+
vec< 2, unsigned int, defaultp > uvec2
2 components vector of unsigned integer numbers.
+
uint16 lowp_u16
Low qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:103
+
vec< 3, i16, lowp > lowp_i16vec3
Low qualifier 16 bit signed integer vector of 3 components type.
Definition: fwd.hpp:244
+
vec< 3, u16, lowp > lowp_u16vec3
Low qualifier 16 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:346
+
vec< 1, unsigned int, defaultp > uvec1
1 component vector of unsigned integer numbers.
+
vec< 3, f32, lowp > lowp_f32vec3
Low single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:448
+
mat< 4, 4, f32, highp > highp_fmat4
High single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:534
+
mat< 3, 3, f32, lowp > lowp_fmat3
Low single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:525
+
int16 highp_i16
High qualifier 16 bit signed integer type.
Definition: fwd.hpp:47
+
qua< f32, mediump > mediump_f32quat
Medium single-qualifier floating-point quaternion.
Definition: fwd.hpp:803
+
int8 highp_int8
High qualifier 8 bit signed integer type.
Definition: fwd.hpp:38
+
mat< 4, 4, f64, defaultp > f64mat4x4
Double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:788
+
mat< 4, 3, f32, defaultp > fmat4x3
Single-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:665
+
mat< 2, 4, f32, lowp > lowp_fmat2x4
Low single-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:632
+
mat< 3, 3, f64, highp > highp_f64mat3
High double-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:581
+
vec< 3, i8, mediump > mediump_i8vec3
Medium qualifier 8 bit signed integer vector of 3 components type.
Definition: fwd.hpp:229
+
vec< 1, f32, highp > highp_f32vec1
High single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:456
+
vec< 3, i8, lowp > lowp_i8vec3
Low qualifier 8 bit signed integer vector of 3 components type.
Definition: fwd.hpp:224
+
mat< 3, 3, double, mediump > mediump_dmat3x3
3 columns of 3 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 4, 3, f64, lowp > lowp_f64mat4x3
Low double-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:757
+
vec< 4, u64, highp > highp_u64vec4
High qualifier 64 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:397
+
mat< 3, 3, float, mediump > mediump_mat3
3 columns of 3 components matrix of single-precision floating-point numbers using medium precision ar...
+
vec< 3, f32, defaultp > fvec3
Single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:443
+
vec< 2, i16, defaultp > i16vec2
16 bit signed integer vector of 2 components type.
Definition: fwd.hpp:258
+
vec< 1, bool, mediump > mediump_bvec1
1 component vector of bool values.
+
mat< 4, 4, double, lowp > lowp_dmat4
4 columns of 4 components matrix of double-precision floating-point numbers using low precision arith...
+
mat< 3, 4, double, highp > highp_dmat3x4
3 columns of 4 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 4, 3, f32, defaultp > f32mat4x3
Single-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:705
+
mat< 2, 2, f32, defaultp > f32mat2
Single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:552
+
mat< 2, 4, f32, mediump > mediump_fmat2x4
Medium single-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:642
+
vec< 2, u16, mediump > mediump_u16vec2
Medium qualifier 16 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:350
+
mat< 4, 4, f32, lowp > lowp_f32mat4x4
Low single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:678
+
vec< 2, unsigned int, lowp > lowp_uvec2
2 components vector of low qualifier unsigned integer numbers.
+
mat< 3, 3, float, lowp > lowp_mat3
3 columns of 3 components matrix of single-precision floating-point numbers using low precision arith...
+
vec< 2, u8, lowp > lowp_u8vec2
Low qualifier 8 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:325
+
vec< 2, double, lowp > lowp_dvec2
2 components vector of low double-qualifier floating-point numbers.
+
mat< 3, 3, f64, mediump > mediump_f64mat3
Medium double-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:577
+
int16 lowp_i16
Low qualifier 16 bit signed integer type.
Definition: fwd.hpp:45
+
vec< 1, float, defaultp > vec1
1 components vector of single-precision floating-point numbers.
+
vec< 3, unsigned int, mediump > mediump_uvec3
3 components vector of medium qualifier unsigned integer numbers.
+
mat< 3, 4, f32, highp > highp_fmat3x4
High single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:655
+
double float64_t
Default 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:176
+
mat< 4, 4, f64, highp > highp_f64mat4x4
High double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:778
+
mat< 2, 2, float, highp > highp_mat2
2 columns of 2 components matrix of single-precision floating-point numbers using high precision arit...
+
mat< 4, 3, f32, mediump > mediump_f32mat4x3
Medium single-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:687
+
int16 lowp_int16
Low qualifier 16 bit signed integer type.
Definition: fwd.hpp:50
+
vec< 3, int, lowp > lowp_ivec3
3 components vector of low qualifier signed integer numbers.
+
mat< 3, 3, f32, mediump > mediump_fmat3
Medium single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:529
+
mat< 4, 4, double, mediump > mediump_dmat4
4 columns of 4 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 4, 4, f32, highp > highp_f32mat4x4
High single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:698
+
int64 lowp_int64_t
Low qualifier 64 bit signed integer type.
Definition: fwd.hpp:82
+
vec< 4, int, lowp > lowp_ivec4
4 components vector of low qualifier signed integer numbers.
+
uint16 uint16_t
Default qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:115
+
vec< 4, unsigned int, lowp > lowp_uvec4
4 components vector of low qualifier unsigned integer numbers.
+
vec< 2, f64, highp > highp_f64vec2
High double-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:497
+
vec< 2, u64, lowp > lowp_u64vec2
Low qualifier 64 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:385
+
mat< 3, 3, f32, defaultp > fmat3
Single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:537
+
mat< 3, 2, f32, mediump > mediump_f32mat3x2
Medium single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:683
+
mat< 3, 3, double, defaultp > dmat3x3
3 columns of 3 components matrix of double-precision floating-point numbers.
+
mat< 3, 3, double, defaultp > dmat3
3 columns of 3 components matrix of double-precision floating-point numbers.
+
mat< 4, 2, f32, lowp > lowp_f32mat4x2
Low single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:676
+
int32 lowp_int32
Low qualifier 32 bit signed integer type.
Definition: fwd.hpp:64
+
vec< 4, i64, mediump > mediump_i64vec4
Medium qualifier 64 bit signed integer vector of 4 components type.
Definition: fwd.hpp:290
+
vec< 4, bool, defaultp > bvec4
4 components vector of boolean.
+
uint8 uint8_t
Default qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:101
+
vec< 1, i8, mediump > mediump_i8vec1
Medium qualifier 8 bit signed integer scalar type.
Definition: fwd.hpp:227
+
int32 mediump_int32_t
Medium qualifier 32 bit signed integer type.
Definition: fwd.hpp:69
+
mat< 4, 3, double, mediump > mediump_dmat4x3
4 columns of 3 components matrix of double-precision floating-point numbers using medium precision ar...
+
float highp_float32_t
High 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:159
+
mat< 3, 3, f32, defaultp > f32mat3x3
Single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:704
+
mat< 4, 4, double, highp > highp_dmat4x4
4 columns of 4 components matrix of double-precision floating-point numbers using medium precision ar...
+
uint8 highp_u8
High qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:91
+
mat< 2, 3, double, highp > highp_dmat2x3
2 columns of 3 components matrix of double-precision floating-point numbers using medium precision ar...
+
uint8 mediump_uint8
Medium qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:95
+
mat< 4, 2, f32, highp > highp_fmat4x2
High single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:656
+
vec< 2, f32, highp > highp_f32vec2
High single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:457
+
mat< 2, 4, double, mediump > mediump_dmat2x4
2 columns of 4 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 2, 2, double, defaultp > dmat2
2 columns of 2 components matrix of double-precision floating-point numbers.
+
vec< 4, float, highp > highp_vec4
4 components vector of high single-qualifier floating-point numbers.
+
int64 mediump_int64_t
Medium qualifier 64 bit signed integer type.
Definition: fwd.hpp:83
+
vec< 3, u64, lowp > lowp_u64vec3
Low qualifier 64 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:386
+
mat< 4, 4, double, defaultp > dmat4x4
4 columns of 4 components matrix of double-precision floating-point numbers.
+
vec< 1, bool, lowp > lowp_bvec1
1 component vector of bool values.
+
mat< 2, 2, f64, highp > highp_f64mat2x2
High double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:770
+
vec< 3, u32, highp > highp_u32vec3
High qualifier 32 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:376
+
vec< 3, bool, highp > highp_bvec3
3 components vector of high qualifier bool numbers.
+
int8 highp_int8_t
High qualifier 8 bit signed integer type.
Definition: fwd.hpp:42
+
qua< f32, lowp > lowp_f32quat
Low single-qualifier floating-point quaternion.
Definition: fwd.hpp:802
+
vec< 4, i32, lowp > lowp_i32vec4
Low qualifier 32 bit signed integer vector of 4 components type.
Definition: fwd.hpp:265
+
vec< 1, i16, highp > highp_i16vec1
High qualifier 16 bit signed integer scalar type.
Definition: fwd.hpp:252
+
mat< 4, 4, f32, lowp > lowp_fmat4x4
Low single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:638
+
mat< 4, 3, double, lowp > lowp_dmat4x3
4 columns of 3 components matrix of double-precision floating-point numbers using low precision arith...
+
mat< 3, 2, f32, defaultp > f32mat3x2
Single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:701
+
mat< 3, 3, f32, lowp > lowp_f32mat3x3
Low single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:674
+
vec< 2, i8, lowp > lowp_i8vec2
Low qualifier 8 bit signed integer vector of 2 components type.
Definition: fwd.hpp:223
+
vec< 4, i32, defaultp > i32vec4
32 bit signed integer vector of 4 components type.
Definition: fwd.hpp:280
+
mat< 2, 2, f32, highp > highp_f32mat2
High single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:548
+
float lowp_f32
Low 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:147
+
vec< 1, unsigned int, highp > highp_uvec1
1 component vector of unsigned integer values.
+
vec< 4, u16, mediump > mediump_u16vec4
Medium qualifier 16 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:352
+
vec< 3, unsigned int, highp > highp_uvec3
3 components vector of high qualifier unsigned integer numbers.
+
vec< 3, u32, defaultp > u32vec3
Default qualifier 32 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:381
+
vec< 2, u8, defaultp > u8vec2
Default qualifier 8 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:340
+
vec< 3, double, mediump > mediump_dvec3
3 components vector of medium double-qualifier floating-point numbers.
+
int16 mediump_i16
Medium qualifier 16 bit signed integer type.
Definition: fwd.hpp:46
+
vec< 2, u64, highp > highp_u64vec2
High qualifier 64 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:395
+
vec< 1, int, lowp > lowp_ivec1
1 component vector of signed integer values.
+
vec< 3, i8, defaultp > i8vec3
8 bit signed integer vector of 3 components type.
Definition: fwd.hpp:239
+
mat< 2, 2, f32, mediump > mediump_f32mat2x2
High single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:680
+
mat< 4, 4, float, defaultp > mat4
4 columns of 4 components matrix of single-precision floating-point numbers.
+
uint16 mediump_uint16_t
Medium qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:113
+
mat< 4, 3, f64, mediump > mediump_f64mat4x3
Medium double-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:767
+
vec< 3, u8, defaultp > u8vec3
Default qualifier 8 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:341
+
double highp_f64
High 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:165
+
vec< 3, float, mediump > mediump_fvec3
Medium Single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:433
+
int64 mediump_int64
Medium qualifier 64 bit signed integer type.
Definition: fwd.hpp:79
+
vec< 4, u64, mediump > mediump_u64vec4
Medium qualifier 64 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:392
+
mat< 2, 2, double, highp > highp_dmat2x2
2 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
+
uint64 uint64_t
Default qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:143
+
vec< 2, u32, highp > highp_u32vec2
High qualifier 32 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:375
+
vec< 1, double, mediump > mediump_dvec1
1 component vector of double-precision floating-point numbers using medium precision arithmetic in te...
+
vec< 1, float, highp > highp_fvec1
High single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:436
+
vec< 4, i64, lowp > lowp_i64vec4
Low qualifier 64 bit signed integer vector of 4 components type.
Definition: fwd.hpp:285
+
vec< 4, int, highp > highp_ivec4
4 components vector of high qualifier signed integer numbers.
+
vec< 3, i32, defaultp > i32vec3
32 bit signed integer vector of 3 components type.
Definition: fwd.hpp:279
+
mat< 2, 4, f32, highp > highp_f32mat2x4
High single-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:692
+
vec< 1, i8, lowp > lowp_i8vec1
Low qualifier 8 bit signed integer scalar type.
Definition: fwd.hpp:222
+
mat< 2, 2, f64, highp > highp_f64mat2
High double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:580
+
vec< 3, double, lowp > lowp_dvec3
3 components vector of low double-qualifier floating-point numbers.
+
uint16 lowp_uint16_t
Low qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:112
+
vec< 2, double, defaultp > dvec2
2 components vector of double-precision floating-point numbers.
+
mat< 3, 2, f64, highp > highp_f64mat3x2
High double-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:773
+
vec< 3, u32, mediump > mediump_u32vec3
Medium qualifier 32 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:371
+
uint16 lowp_uint16
Low qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:108
+
mat< 3, 3, float, highp > highp_mat3
3 columns of 3 components matrix of single-precision floating-point numbers using high precision arit...
+
vec< 3, u8, highp > highp_u8vec3
High qualifier 8 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:336
+
vec< 4, f64, defaultp > f64vec4
Double-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:504
+
vec< 2, i8, highp > highp_i8vec2
High qualifier 8 bit signed integer vector of 2 components type.
Definition: fwd.hpp:233
+
mat< 2, 2, double, highp > highp_dmat2
2 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
+
vec< 3, i32, lowp > lowp_i32vec3
Low qualifier 32 bit signed integer vector of 3 components type.
Definition: fwd.hpp:264
+
int32 lowp_i32
Low qualifier 32 bit signed integer type.
Definition: fwd.hpp:59
+
mat< 4, 4, f32, mediump > mediump_fmat4x4
Medium single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:648
+
vec< 3, float, defaultp > vec3
3 components vector of single-precision floating-point numbers.
+
mat< 4, 4, double, lowp > lowp_dmat4x4
4 columns of 4 components matrix of double-precision floating-point numbers using low precision arith...
+
int64 mediump_i64
Medium qualifier 64 bit signed integer type.
Definition: fwd.hpp:74
+
mat< 4, 4, double, highp > highp_dmat4
4 columns of 4 components matrix of double-precision floating-point numbers using medium precision ar...
+
vec< 4, i16, lowp > lowp_i16vec4
Low qualifier 16 bit signed integer vector of 4 components type.
Definition: fwd.hpp:245
+
vec< 1, bool, defaultp > bvec1
1 components vector of boolean.
+
mat< 4, 3, f64, highp > highp_f64mat4x3
High double-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:777
+
vec< 2, u8, highp > highp_u8vec2
High qualifier 8 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:335
+
vec< 3, int, mediump > mediump_ivec3
3 components vector of medium qualifier signed integer numbers.
+
vec< 3, i8, highp > highp_i8vec3
High qualifier 8 bit signed integer vector of 3 components type.
Definition: fwd.hpp:234
+
vec< 3, f64, highp > highp_f64vec3
High double-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:498
+
vec< 2, f32, defaultp > fvec2
Single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:442
+
vec< 4, f64, lowp > lowp_f64vec4
Low double-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:489
+
qua< double, highp > highp_dquat
Quaternion of high double-qualifier floating-point numbers using high precision arithmetic in term of...
+
vec< 3, f32, mediump > mediump_f32vec3
Medium single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:453
+
double lowp_f64
Low 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:163
+
mat< 4, 2, f32, lowp > lowp_fmat4x2
Low single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:636
+
vec< 3, int, highp > highp_ivec3
3 components vector of high qualifier signed integer numbers.
+
mat< 2, 4, f64, highp > highp_f64mat2x4
High double-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:772
+
mat< 4, 4, f64, highp > highp_f64mat4
High double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:582
+
vec< 4, i32, mediump > mediump_i32vec4
Medium qualifier 32 bit signed integer vector of 4 components type.
Definition: fwd.hpp:270
+
mat< 2, 2, f32, lowp > lowp_f32mat2
Low single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:540
+
int16 int16_t
16 bit signed integer type.
Definition: fwd.hpp:57
+
mat< 3, 4, double, defaultp > dmat3x4
3 columns of 4 components matrix of double-precision floating-point numbers.
+
mat< 2, 3, double, lowp > lowp_dmat2x3
2 columns of 3 components matrix of double-precision floating-point numbers using low precision arith...
+
int64 highp_i64
High qualifier 64 bit signed integer type.
Definition: fwd.hpp:75
+
mat< 2, 4, float, mediump > mediump_mat2x4
2 columns of 4 components matrix of single-precision floating-point numbers using medium precision ar...
+
mat< 3, 4, f64, highp > highp_f64mat3x4
High double-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:775
+
mat< 3, 3, f32, highp > highp_fmat3
High single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:533
+
mat< 3, 3, f32, mediump > mediump_f32mat3x3
Medium single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:684
+
qua< f64, mediump > mediump_f64quat
Medium double-qualifier floating-point quaternion.
Definition: fwd.hpp:813
+
int32 int32_t
32 bit signed integer type.
Definition: fwd.hpp:71
+
vec< 2, f64, defaultp > f64vec2
Double-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:502
+
vec< 4, unsigned int, defaultp > uvec4
4 components vector of unsigned integer numbers.
+
uint64 lowp_uint64_t
Low qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:140
+
detail::uint64 uint64
64 bit unsigned integer type.
+
int16 highp_int16
High qualifier 16 bit signed integer type.
Definition: fwd.hpp:52
+
mat< 2, 2, double, defaultp > dmat2x2
2 columns of 2 components matrix of double-precision floating-point numbers.
+
vec< 1, i16, mediump > mediump_i16vec1
Medium qualifier 16 bit signed integer scalar type.
Definition: fwd.hpp:247
+
mat< 2, 4, double, defaultp > dmat2x4
2 columns of 4 components matrix of double-precision floating-point numbers.
+
mat< 3, 2, double, highp > highp_dmat3x2
3 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
+
mat< 2, 4, f32, defaultp > fmat2x4
Single-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:666
+
mat< 2, 2, f32, highp > highp_fmat2x2
High single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:650
+
vec< 4, float, highp > highp_fvec4
High Single-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:439
+
mat< 3, 3, f64, highp > highp_f64mat3x3
High double-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:774
+
int32 mediump_i32
Medium qualifier 32 bit signed integer type.
Definition: fwd.hpp:60
+
vec< 3, float, mediump > mediump_vec3
3 components vector of medium single-qualifier floating-point numbers.
+
vec< 2, u16, lowp > lowp_u16vec2
Low qualifier 16 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:345
+
vec< 4, u32, highp > highp_u32vec4
High qualifier 32 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:377
+
mat< 4, 2, double, defaultp > dmat4x2
4 columns of 2 components matrix of double-precision floating-point numbers.
+
vec< 4, double, lowp > lowp_dvec4
4 components vector of low double-qualifier floating-point numbers.
+
float lowp_float32_t
Low 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:157
+
uint64 highp_uint64_t
High qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:142
+
vec< 2, f32, lowp > lowp_f32vec2
Low single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:447
+
vec< 4, u32, defaultp > u32vec4
Default qualifier 32 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:382
+
mat< 2, 2, f64, mediump > mediump_f64mat2
Medium double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:576
+
qua< float, mediump > mediump_quat
Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs...
+
mat< 4, 3, f32, highp > highp_f32mat4x3
High single-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:697
+
vec< 3, unsigned int, lowp > lowp_uvec3
3 components vector of low qualifier unsigned integer numbers.
+
mat< 2, 2, float, lowp > lowp_mat2x2
2 columns of 2 components matrix of single-precision floating-point numbers using low precision arith...
+
qua< f32, defaultp > f32quat
Single-qualifier floating-point quaternion.
Definition: fwd.hpp:805
+
detail::int64 int64
64 bit signed integer type.
+
qua< double, lowp > lowp_dquat
Quaternion of double-precision floating-point numbers using high precision arithmetic in term of ULPs...
+
vec< 1, u64, highp > highp_u64vec1
High qualifier 64 bit unsigned integer scalar type.
Definition: fwd.hpp:394
+
mat< 3, 4, float, mediump > mediump_mat3x4
3 columns of 4 components matrix of single-precision floating-point numbers using medium precision ar...
+
mat< 2, 3, f64, highp > highp_f64mat2x3
High double-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:771
+
vec< 4, i8, lowp > lowp_i8vec4
Low qualifier 8 bit signed integer vector of 4 components type.
Definition: fwd.hpp:225
+
mat< 4, 3, f32, lowp > lowp_fmat4x3
Low single-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:637
+
float f32
Default 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:150
+
vec< 2, i32, highp > highp_i32vec2
High qualifier 32 bit signed integer vector of 2 components type.
Definition: fwd.hpp:273
+
vec< 1, u8, mediump > mediump_u8vec1
Medium qualifier 8 bit unsigned integer scalar type.
Definition: fwd.hpp:329
+
mat< 4, 3, f32, highp > highp_fmat4x3
High single-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:657
+
mat< 3, 2, double, defaultp > dmat3x2
3 columns of 2 components matrix of double-precision floating-point numbers.
+
vec< 4, i16, mediump > mediump_i16vec4
Medium qualifier 16 bit signed integer vector of 4 components type.
Definition: fwd.hpp:250
+
mat< 4, 2, f64, defaultp > f64mat4x2
Double-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:782
+
mat< 2, 3, f32, defaultp > fmat2x3
Single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:663
+
mat< 4, 4, f64, mediump > mediump_f64mat4
Medium double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:578
+
vec< 4, u8, mediump > mediump_u8vec4
Medium qualifier 8 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:332
+
vec< 3, double, highp > highp_dvec3
3 components vector of high double-qualifier floating-point numbers.
+
mat< 3, 4, f32, lowp > lowp_f32mat3x4
Low single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:675
+
double mediump_float64_t
Medium 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:174
+
mat< 2, 2, float, highp > highp_mat2x2
2 columns of 2 components matrix of single-precision floating-point numbers using high precision arit...
+
mat< 4, 3, float, lowp > lowp_mat4x3
4 columns of 3 components matrix of single-precision floating-point numbers using low precision arith...
+
vec< 2, float, highp > highp_fvec2
High Single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:437
+
uint16 u16
Default qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:106
+
int64 lowp_i64
Low qualifier 64 bit signed integer type.
Definition: fwd.hpp:73
+
vec< 1, unsigned int, lowp > lowp_uvec1
1 component vector of unsigned integer values.
+
vec< 2, int, defaultp > ivec2
2 components vector of signed integer numbers.
Definition: vector_int2.hpp:15
+
mat< 4, 4, f32, defaultp > f32mat4
Single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:554
+
mat< 4, 2, f32, mediump > mediump_fmat4x2
Medium single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:646
+
mat< 2, 2, f64, lowp > lowp_f64mat2
Low double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:572
+
int8 mediump_int8_t
Medium qualifier 8 bit signed integer type.
Definition: fwd.hpp:41
+
mat< 3, 3, f32, lowp > lowp_fmat3x3
Low single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:634
+
double lowp_float64_t
Low 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:173
+
int16 highp_int16_t
High qualifier 16 bit signed integer type.
Definition: fwd.hpp:56
+
mat< 3, 3, f32, highp > highp_fmat3x3
High single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:654
+
mat< 4, 4, double, defaultp > dmat4
4 columns of 4 components matrix of double-precision floating-point numbers.
+
vec< 1, i64, defaultp > i64vec1
64 bit signed integer scalar type.
Definition: fwd.hpp:297
+
uint32 lowp_u32
Low qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:117
+
mat< 4, 3, float, mediump > mediump_mat4x3
4 columns of 3 components matrix of single-precision floating-point numbers using medium precision ar...
+
vec< 1, u8, lowp > lowp_u8vec1
Low qualifier 8 bit unsigned integer scalar type.
Definition: fwd.hpp:324
+
vec< 3, i64, mediump > mediump_i64vec3
Medium qualifier 64 bit signed integer vector of 3 components type.
Definition: fwd.hpp:289
+
vec< 1, int, defaultp > ivec1
1 component vector of signed integer numbers.
Definition: vector_int1.hpp:28
+
qua< f32, highp > highp_f32quat
High single-qualifier floating-point quaternion.
Definition: fwd.hpp:804
+
uint16 highp_u16
High qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:105
+
vec< 1, f32, defaultp > fvec1
Single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:441
+
mat< 3, 2, float, mediump > mediump_mat3x2
3 columns of 2 components matrix of single-precision floating-point numbers using medium precision ar...
+
vec< 2, bool, lowp > lowp_bvec2
2 components vector of low qualifier bool numbers.
+
vec< 2, u8, mediump > mediump_u8vec2
Medium qualifier 8 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:330
+
int32 lowp_int32_t
Low qualifier 32 bit signed integer type.
Definition: fwd.hpp:68
+
vec< 1, u16, lowp > lowp_u16vec1
Low qualifier 16 bit unsigned integer scalar type.
Definition: fwd.hpp:344
+
mat< 4, 4, f32, highp > highp_fmat4x4
High single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:658
+
mat< 3, 4, f32, highp > highp_f32mat3x4
High single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:695
+
vec< 3, bool, defaultp > bvec3
3 components vector of boolean.
+
vec< 2, f32, defaultp > f32vec2
Single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:462
+
vec< 3, u16, highp > highp_u16vec3
High qualifier 16 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:356
+
float mediump_float32_t
Medium 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:158
+
mat< 2, 2, f32, defaultp > fmat2x2
Single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:660
+
float mediump_f32
Medium 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:148
+
mat< 4, 4, f32, mediump > mediump_f32mat4x4
Medium single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:688
+
qua< float, lowp > lowp_quat
Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs...
+
vec< 2, f32, mediump > mediump_f32vec2
Medium single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:452
+
int8 lowp_int8
Low qualifier 8 bit signed integer type.
Definition: fwd.hpp:36
+
mat< 2, 3, float, defaultp > mat2x3
2 columns of 3 components matrix of single-precision floating-point numbers.
+
vec< 1, f64, lowp > lowp_f64vec1
Low double-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:486
+
mat< 3, 2, f32, highp > highp_f32mat3x2
High single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:693
+
mat< 3, 2, f64, mediump > mediump_f64mat3x2
Medium double-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:763
+
mat< 3, 3, double, mediump > mediump_dmat3
3 columns of 3 components matrix of double-precision floating-point numbers using medium precision ar...
+
vec< 3, u8, mediump > mediump_u8vec3
Medium qualifier 8 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:331
+
mat< 2, 3, double, defaultp > dmat2x3
2 columns of 3 components matrix of double-precision floating-point numbers.
+
mat< 4, 4, f64, lowp > lowp_f64mat4x4
Low double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:758
+
vec< 1, i16, lowp > lowp_i16vec1
Low qualifier 16 bit signed integer scalar type.
Definition: fwd.hpp:242
+
vec< 3, double, defaultp > dvec3
3 components vector of double-precision floating-point numbers.
+
mat< 2, 4, double, lowp > lowp_dmat2x4
2 columns of 4 components matrix of double-precision floating-point numbers using low precision arith...
+
int8 lowp_int8_t
Low qualifier 8 bit signed integer type.
Definition: fwd.hpp:40
+
vec< 2, u32, lowp > lowp_u32vec2
Low qualifier 32 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:365
+
mat< 2, 4, f32, mediump > mediump_f32mat2x4
Medium single-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:682
+
mat< 4, 3, f64, defaultp > f64mat4x3
Double-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:785
+
vec< 2, i64, highp > highp_i64vec2
High qualifier 64 bit signed integer vector of 2 components type.
Definition: fwd.hpp:293
+
mat< 4, 4, f32, mediump > mediump_f32mat4
Medium single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:546
+
mat< 3, 2, float, highp > highp_mat3x2
3 columns of 2 components matrix of single-precision floating-point numbers using high precision arit...
+
mat< 4, 4, float, highp > highp_mat4x4
4 columns of 4 components matrix of single-precision floating-point numbers using high precision arit...
+
vec< 2, double, mediump > mediump_dvec2
2 components vector of medium double-qualifier floating-point numbers.
+
mat< 2, 2, double, lowp > lowp_dmat2x2
2 columns of 2 components matrix of double-precision floating-point numbers using low precision arith...
+
int64 i64
64 bit signed integer type.
Definition: fwd.hpp:76
+
double f64
Default 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:166
+
vec< 3, bool, lowp > lowp_bvec3
3 components vector of low qualifier bool numbers.
+
mat< 3, 4, float, lowp > lowp_mat3x4
3 columns of 4 components matrix of single-precision floating-point numbers using low precision arith...
+
mat< 4, 4, float, lowp > lowp_mat4x4
4 columns of 4 components matrix of single-precision floating-point numbers using low precision arith...
+
vec< 1, float, highp > highp_vec1
1 component vector of single-precision floating-point numbers using high precision arithmetic in term...
+
vec< 1, f32, mediump > mediump_f32vec1
Medium single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:451
+
mat< 3, 4, f32, mediump > mediump_f32mat3x4
Medium single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:685
+
mat< 2, 2, f32, highp > highp_fmat2
High single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:532
+
vec< 2, unsigned int, highp > highp_uvec2
2 components vector of high qualifier unsigned integer numbers.
+
vec< 3, f32, highp > highp_f32vec3
High single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:458
+
mat< 2, 2, float, mediump > mediump_mat2x2
2 columns of 2 components matrix of single-precision floating-point numbers using medium precision ar...
+
vec< 4, i8, mediump > mediump_i8vec4
Medium qualifier 8 bit signed integer vector of 4 components type.
Definition: fwd.hpp:230
+
float lowp_float32
Low 32 bit single-qualifier floating-point scalar.
Definition: fwd.hpp:152
+
vec< 2, u32, defaultp > u32vec2
Default qualifier 32 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:380
+
vec< 2, unsigned int, mediump > mediump_uvec2
2 components vector of medium qualifier unsigned integer numbers.
+
qua< float, defaultp > quat
Quaternion of single-precision floating-point numbers.
+
vec< 2, double, highp > highp_dvec2
2 components vector of high double-qualifier floating-point numbers.
+
vec< 4, float, mediump > mediump_fvec4
Medium Single-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:434
+
int32 mediump_int32
Medium qualifier 32 bit signed integer type.
Definition: fwd.hpp:65
+
vec< 2, i64, defaultp > i64vec2
64 bit signed integer vector of 2 components type.
Definition: fwd.hpp:298
+
int16 i16
16 bit signed integer type.
Definition: fwd.hpp:48
+
vec< 4, double, defaultp > dvec4
4 components vector of double-precision floating-point numbers.
+
mat< 4, 4, f32, defaultp > fmat4x4
Single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:668
+
mat< 2, 2, float, mediump > mediump_mat2
2 columns of 2 components matrix of single-precision floating-point numbers using medium precision ar...
+
qua< f64, lowp > lowp_f64quat
Low double-qualifier floating-point quaternion.
Definition: fwd.hpp:812
+
mat< 2, 2, float, defaultp > mat2
2 columns of 2 components matrix of single-precision floating-point numbers.
+
mat< 3, 2, f32, defaultp > fmat3x2
Single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:661
+
mat< 4, 3, double, defaultp > dmat4x3
4 columns of 3 components matrix of double-precision floating-point numbers.
+
mat< 4, 2, double, highp > highp_dmat4x2
4 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
+
vec< 4, u16, defaultp > u16vec4
Default qualifier 16 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:362
+
vec< 2, u16, defaultp > u16vec2
Default qualifier 16 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:360
+
uint8 mediump_u8
Medium qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:90
+
mat< 2, 2, f32, lowp > lowp_fmat2x2
Low single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:630
+
vec< 4, i8, highp > highp_i8vec4
High qualifier 8 bit signed integer vector of 4 components type.
Definition: fwd.hpp:235
+
vec< 4, u64, lowp > lowp_u64vec4
Low qualifier 64 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:387
+
vec< 2, i64, mediump > mediump_i64vec2
Medium qualifier 64 bit signed integer vector of 2 components type.
Definition: fwd.hpp:288
+
mat< 4, 2, f64, highp > highp_f64mat4x2
High double-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:776
+
mat< 4, 4, float, highp > highp_mat4
4 columns of 4 components matrix of single-precision floating-point numbers using high precision arit...
+
int16 mediump_int16_t
Medium qualifier 16 bit signed integer type.
Definition: fwd.hpp:55
+
int8 lowp_i8
Low qualifier 8 bit signed integer type.
Definition: fwd.hpp:31
+
mat< 4, 2, float, highp > highp_mat4x2
4 columns of 2 components matrix of single-precision floating-point numbers using high precision arit...
+
vec< 3, i64, defaultp > i64vec3
64 bit signed integer vector of 3 components type.
Definition: fwd.hpp:299
+
vec< 2, i32, lowp > lowp_i32vec2
Low qualifier 32 bit signed integer vector of 2 components type.
Definition: fwd.hpp:263
+
qua< f64, highp > highp_f64quat
High double-qualifier floating-point quaternion.
Definition: fwd.hpp:814
+
mat< 3, 3, float, defaultp > mat3
3 columns of 3 components matrix of single-precision floating-point numbers.
+
vec< 2, f64, mediump > mediump_f64vec2
Medium double-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:492
+
uint16 highp_uint16_t
High qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:114
+
vec< 1, float, lowp > lowp_fvec1
Low single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:426
+
int8 i8
8 bit signed integer type.
Definition: fwd.hpp:34
+
uint64 mediump_uint64_t
Medium qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:141
+
vec< 1, u64, mediump > mediump_u64vec1
Medium qualifier 64 bit unsigned integer scalar type.
Definition: fwd.hpp:389
+
mat< 2, 2, f32, mediump > mediump_f32mat2
Medium single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:544
+
vec< 4, int, mediump > mediump_ivec4
4 components vector of medium qualifier signed integer numbers.
+
mat< 2, 4, float, highp > highp_mat2x4
2 columns of 4 components matrix of single-precision floating-point numbers using high precision arit...
+
uint8 mediump_uint8_t
Medium qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:99
+
Definition: common.hpp:20
+
double mediump_f64
Medium 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:164
+
vec< 1, float, mediump > mediump_fvec1
Medium single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:431
+
uint16 mediump_uint16
Medium qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:109
+
vec< 4, u8, highp > highp_u8vec4
High qualifier 8 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:337
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00036.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00036.html new file mode 100644 index 0000000000000000000000000000000000000000..e9fca8f80752628bc27af1c42d6ba6e697b921ea --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00036.html @@ -0,0 +1,147 @@ + + + + + + +0.9.9 API documentation: geometric.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
geometric.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename T , qualifier Q>
GLM_FUNC_DECL vec< 3, T, Q > cross (vec< 3, T, Q > const &x, vec< 3, T, Q > const &y)
 Returns the cross product of x and y. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL T distance (vec< L, T, Q > const &p0, vec< L, T, Q > const &p1)
 Returns the distance betwwen p0 and p1, i.e., length(p0 - p1). More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL T dot (vec< L, T, Q > const &x, vec< L, T, Q > const &y)
 Returns the dot product of x and y, i.e., result = x * y. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > faceforward (vec< L, T, Q > const &N, vec< L, T, Q > const &I, vec< L, T, Q > const &Nref)
 If dot(Nref, I) < 0.0, return N, otherwise, return -N. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL T length (vec< L, T, Q > const &x)
 Returns the length of x, i.e., sqrt(x * x). More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > normalize (vec< L, T, Q > const &x)
 Returns a vector in the same direction as x but with length of 1. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > reflect (vec< L, T, Q > const &I, vec< L, T, Q > const &N)
 For the incident vector I and surface orientation N, returns the reflection direction : result = I - 2.0 * dot(N, I) * N. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > refract (vec< L, T, Q > const &I, vec< L, T, Q > const &N, T eta)
 For the incident vector I and surface normal N, and the ratio of indices of refraction eta, return the refraction vector. More...
 
+

Detailed Description

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00036_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00036_source.html new file mode 100644 index 0000000000000000000000000000000000000000..2115bb4cb723ca7d0d88e4727c0471ae712da69f --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00036_source.html @@ -0,0 +1,152 @@ + + + + + + +0.9.9 API documentation: geometric.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
geometric.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 #include "detail/type_vec3.hpp"
+
16 
+
17 namespace glm
+
18 {
+
21 
+
29  template<length_t L, typename T, qualifier Q>
+
30  GLM_FUNC_DECL T length(vec<L, T, Q> const& x);
+
31 
+
39  template<length_t L, typename T, qualifier Q>
+
40  GLM_FUNC_DECL T distance(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1);
+
41 
+
49  template<length_t L, typename T, qualifier Q>
+
50  GLM_FUNC_DECL T dot(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
51 
+
58  template<typename T, qualifier Q>
+
59  GLM_FUNC_DECL vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y);
+
60 
+
69  template<length_t L, typename T, qualifier Q>
+
70  GLM_FUNC_DECL vec<L, T, Q> normalize(vec<L, T, Q> const& x);
+
71 
+
79  template<length_t L, typename T, qualifier Q>
+
80  GLM_FUNC_DECL vec<L, T, Q> faceforward(
+
81  vec<L, T, Q> const& N,
+
82  vec<L, T, Q> const& I,
+
83  vec<L, T, Q> const& Nref);
+
84 
+
93  template<length_t L, typename T, qualifier Q>
+
94  GLM_FUNC_DECL vec<L, T, Q> reflect(
+
95  vec<L, T, Q> const& I,
+
96  vec<L, T, Q> const& N);
+
97 
+
107  template<length_t L, typename T, qualifier Q>
+
108  GLM_FUNC_DECL vec<L, T, Q> refract(
+
109  vec<L, T, Q> const& I,
+
110  vec<L, T, Q> const& N,
+
111  T eta);
+
112 
+
114 }//namespace glm
+
115 
+
116 #include "detail/func_geometric.inl"
+
GLM_FUNC_DECL vec< L, T, Q > reflect(vec< L, T, Q > const &I, vec< L, T, Q > const &N)
For the incident vector I and surface orientation N, returns the reflection direction : result = I - ...
+
GLM_FUNC_DECL vec< L, T, Q > faceforward(vec< L, T, Q > const &N, vec< L, T, Q > const &I, vec< L, T, Q > const &Nref)
If dot(Nref, I) < 0.0, return N, otherwise, return -N.
+
GLM_FUNC_DECL T length(vec< L, T, Q > const &x)
Returns the length of x, i.e., sqrt(x * x).
+
GLM_FUNC_DECL vec< 3, T, Q > cross(vec< 3, T, Q > const &x, vec< 3, T, Q > const &y)
Returns the cross product of x and y.
+
GLM_FUNC_DECL vec< L, T, Q > refract(vec< L, T, Q > const &I, vec< L, T, Q > const &N, T eta)
For the incident vector I and surface normal N, and the ratio of indices of refraction eta...
+
GLM_FUNC_DECL vec< L, T, Q > normalize(vec< L, T, Q > const &x)
Returns a vector in the same direction as x but with length of 1.
+
Core features
+
GLM_FUNC_DECL T distance(vec< L, T, Q > const &p0, vec< L, T, Q > const &p1)
Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+
GLM_FUNC_DECL T dot(vec< L, T, Q > const &x, vec< L, T, Q > const &y)
Returns the dot product of x and y, i.e., result = x * y.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00037.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00037.html new file mode 100644 index 0000000000000000000000000000000000000000..b1a7039b3d7a547a165011db8ce96f5d7d9558f6 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00037.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: glm.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
glm.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features

+ +

Definition in file glm.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00037_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00037_source.html new file mode 100644 index 0000000000000000000000000000000000000000..775648f23b594cbc76f9cba1ae776186cd7ec374 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00037_source.html @@ -0,0 +1,154 @@ + + + + + + +0.9.9 API documentation: glm.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
glm.hpp
+
+
+Go to the documentation of this file.
1 
+
103 #include "detail/_fixes.hpp"
+
104 
+
105 #include "detail/setup.hpp"
+
106 
+
107 #pragma once
+
108 
+
109 #include <cmath>
+
110 #include <climits>
+
111 #include <cfloat>
+
112 #include <limits>
+
113 #include <cassert>
+
114 #include "fwd.hpp"
+
115 
+
116 #include "vec2.hpp"
+
117 #include "vec3.hpp"
+
118 #include "vec4.hpp"
+
119 #include "mat2x2.hpp"
+
120 #include "mat2x3.hpp"
+
121 #include "mat2x4.hpp"
+
122 #include "mat3x2.hpp"
+
123 #include "mat3x3.hpp"
+
124 #include "mat3x4.hpp"
+
125 #include "mat4x2.hpp"
+
126 #include "mat4x3.hpp"
+
127 #include "mat4x4.hpp"
+
128 
+
129 #include "trigonometric.hpp"
+
130 #include "exponential.hpp"
+
131 #include "common.hpp"
+
132 #include "packing.hpp"
+
133 #include "geometric.hpp"
+
134 #include "matrix.hpp"
+
135 #include "vector_relational.hpp"
+
136 #include "integer.hpp"
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
Core features
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00038.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00038.html new file mode 100644 index 0000000000000000000000000000000000000000..9854848ca92827c9998447d7797963e5ad207155 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00038.html @@ -0,0 +1,125 @@ + + + + + + +0.9.9 API documentation: gradient_paint.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
gradient_paint.hpp File Reference
+
+
+ +

GLM_GTX_gradient_paint +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + +

+Functions

template<typename T , qualifier Q>
GLM_FUNC_DECL T linearGradient (vec< 2, T, Q > const &Point0, vec< 2, T, Q > const &Point1, vec< 2, T, Q > const &Position)
 Return a color from a linear gradient. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL T radialGradient (vec< 2, T, Q > const &Center, T const &Radius, vec< 2, T, Q > const &Focal, vec< 2, T, Q > const &Position)
 Return a color from a radial gradient. More...
 
+

Detailed Description

+

GLM_GTX_gradient_paint

+
See also
Core features (dependence)
+
+GLM_GTX_optimum_pow (dependence)
+ +

Definition in file gradient_paint.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00038_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00038_source.html new file mode 100644 index 0000000000000000000000000000000000000000..0e82da1461f3a17a6fc707d9beba977d35b02473 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00038_source.html @@ -0,0 +1,136 @@ + + + + + + +0.9.9 API documentation: gradient_paint.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
gradient_paint.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependency:
+
17 #include "../glm.hpp"
+
18 #include "../gtx/optimum_pow.hpp"
+
19 
+
20 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
21 # ifndef GLM_ENABLE_EXPERIMENTAL
+
22 # pragma message("GLM: GLM_GTX_gradient_paint is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
23 # else
+
24 # pragma message("GLM: GLM_GTX_gradient_paint extension included")
+
25 # endif
+
26 #endif
+
27 
+
28 namespace glm
+
29 {
+
32 
+
35  template<typename T, qualifier Q>
+
36  GLM_FUNC_DECL T radialGradient(
+
37  vec<2, T, Q> const& Center,
+
38  T const& Radius,
+
39  vec<2, T, Q> const& Focal,
+
40  vec<2, T, Q> const& Position);
+
41 
+
44  template<typename T, qualifier Q>
+
45  GLM_FUNC_DECL T linearGradient(
+
46  vec<2, T, Q> const& Point0,
+
47  vec<2, T, Q> const& Point1,
+
48  vec<2, T, Q> const& Position);
+
49 
+
51 }// namespace glm
+
52 
+
53 #include "gradient_paint.inl"
+
GLM_FUNC_DECL T radialGradient(vec< 2, T, Q > const &Center, T const &Radius, vec< 2, T, Q > const &Focal, vec< 2, T, Q > const &Position)
Return a color from a radial gradient.
+
GLM_FUNC_DECL T linearGradient(vec< 2, T, Q > const &Point0, vec< 2, T, Q > const &Point1, vec< 2, T, Q > const &Position)
Return a color from a linear gradient.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00039.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00039.html new file mode 100644 index 0000000000000000000000000000000000000000..9959600bcb66861c44a9ddbe8f04b4ffea4c6c6c --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00039.html @@ -0,0 +1,123 @@ + + + + + + +0.9.9 API documentation: handed_coordinate_space.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
handed_coordinate_space.hpp File Reference
+
+
+ +

GLM_GTX_handed_coordinate_space +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + +

+Functions

template<typename T , qualifier Q>
GLM_FUNC_DECL bool leftHanded (vec< 3, T, Q > const &tangent, vec< 3, T, Q > const &binormal, vec< 3, T, Q > const &normal)
 Return if a trihedron left handed or not. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL bool rightHanded (vec< 3, T, Q > const &tangent, vec< 3, T, Q > const &binormal, vec< 3, T, Q > const &normal)
 Return if a trihedron right handed or not. More...
 
+

Detailed Description

+

GLM_GTX_handed_coordinate_space

+
See also
Core features (dependence)
+ +

Definition in file handed_coordinate_space.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00039_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00039_source.html new file mode 100644 index 0000000000000000000000000000000000000000..aaf7013fa4f1e17462ac3e4d5d724ed3c268706f --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00039_source.html @@ -0,0 +1,134 @@ + + + + + + +0.9.9 API documentation: handed_coordinate_space.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
handed_coordinate_space.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../glm.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # ifndef GLM_ENABLE_EXPERIMENTAL
+
20 # pragma message("GLM: GLM_GTX_handed_coordinate_space is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
21 # else
+
22 # pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
+
23 # endif
+
24 #endif
+
25 
+
26 namespace glm
+
27 {
+
30 
+
33  template<typename T, qualifier Q>
+
34  GLM_FUNC_DECL bool rightHanded(
+
35  vec<3, T, Q> const& tangent,
+
36  vec<3, T, Q> const& binormal,
+
37  vec<3, T, Q> const& normal);
+
38 
+
41  template<typename T, qualifier Q>
+
42  GLM_FUNC_DECL bool leftHanded(
+
43  vec<3, T, Q> const& tangent,
+
44  vec<3, T, Q> const& binormal,
+
45  vec<3, T, Q> const& normal);
+
46 
+
48 }// namespace glm
+
49 
+
50 #include "handed_coordinate_space.inl"
+
GLM_FUNC_DECL bool leftHanded(vec< 3, T, Q > const &tangent, vec< 3, T, Q > const &binormal, vec< 3, T, Q > const &normal)
Return if a trihedron left handed or not.
+
GLM_FUNC_DECL bool rightHanded(vec< 3, T, Q > const &tangent, vec< 3, T, Q > const &binormal, vec< 3, T, Q > const &normal)
Return if a trihedron right handed or not.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00040.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00040.html new file mode 100644 index 0000000000000000000000000000000000000000..ba2c95e1cf21add15fec92986e6ef244b13f4be0 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00040.html @@ -0,0 +1,109 @@ + + + + + + +0.9.9 API documentation: hash.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
hash.hpp File Reference
+
+
+ +

GLM_GTX_hash +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

GLM_GTX_hash

+
See also
Core features (dependence)
+ +

Definition in file hash.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00040_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00040_source.html new file mode 100644 index 0000000000000000000000000000000000000000..14bcfe6ad009f2db74de37f7789c7772c8777ac2 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00040_source.html @@ -0,0 +1,232 @@ + + + + + + +0.9.9 API documentation: hash.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
hash.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
16 # ifndef GLM_ENABLE_EXPERIMENTAL
+
17 # pragma message("GLM: GLM_GTX_hash is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
18 # else
+
19 # pragma message("GLM: GLM_GTX_hash extension included")
+
20 # endif
+
21 #endif
+
22 
+
23 #include <functional>
+
24 
+
25 #include "../vec2.hpp"
+
26 #include "../vec3.hpp"
+
27 #include "../vec4.hpp"
+
28 #include "../gtc/vec1.hpp"
+
29 
+
30 #include "../gtc/quaternion.hpp"
+
31 #include "../gtx/dual_quaternion.hpp"
+
32 
+
33 #include "../mat2x2.hpp"
+
34 #include "../mat2x3.hpp"
+
35 #include "../mat2x4.hpp"
+
36 
+
37 #include "../mat3x2.hpp"
+
38 #include "../mat3x3.hpp"
+
39 #include "../mat3x4.hpp"
+
40 
+
41 #include "../mat4x2.hpp"
+
42 #include "../mat4x3.hpp"
+
43 #include "../mat4x4.hpp"
+
44 
+
45 #if !GLM_HAS_CXX11_STL
+
46 # error "GLM_GTX_hash requires C++11 standard library support"
+
47 #endif
+
48 
+
49 namespace std
+
50 {
+
51  template<typename T, glm::qualifier Q>
+
52  struct hash<glm::vec<1, T,Q> >
+
53  {
+
54  GLM_FUNC_DECL size_t operator()(glm::vec<1, T, Q> const& v) const;
+
55  };
+
56 
+
57  template<typename T, glm::qualifier Q>
+
58  struct hash<glm::vec<2, T,Q> >
+
59  {
+
60  GLM_FUNC_DECL size_t operator()(glm::vec<2, T, Q> const& v) const;
+
61  };
+
62 
+
63  template<typename T, glm::qualifier Q>
+
64  struct hash<glm::vec<3, T,Q> >
+
65  {
+
66  GLM_FUNC_DECL size_t operator()(glm::vec<3, T, Q> const& v) const;
+
67  };
+
68 
+
69  template<typename T, glm::qualifier Q>
+
70  struct hash<glm::vec<4, T,Q> >
+
71  {
+
72  GLM_FUNC_DECL size_t operator()(glm::vec<4, T, Q> const& v) const;
+
73  };
+
74 
+
75  template<typename T, glm::qualifier Q>
+
76  struct hash<glm::qua<T,Q>>
+
77  {
+
78  GLM_FUNC_DECL size_t operator()(glm::qua<T, Q> const& q) const;
+
79  };
+
80 
+
81  template<typename T, glm::qualifier Q>
+
82  struct hash<glm::tdualquat<T,Q> >
+
83  {
+
84  GLM_FUNC_DECL size_t operator()(glm::tdualquat<T,Q> const& q) const;
+
85  };
+
86 
+
87  template<typename T, glm::qualifier Q>
+
88  struct hash<glm::mat<2, 2, T,Q> >
+
89  {
+
90  GLM_FUNC_DECL size_t operator()(glm::mat<2, 2, T,Q> const& m) const;
+
91  };
+
92 
+
93  template<typename T, glm::qualifier Q>
+
94  struct hash<glm::mat<2, 3, T,Q> >
+
95  {
+
96  GLM_FUNC_DECL size_t operator()(glm::mat<2, 3, T,Q> const& m) const;
+
97  };
+
98 
+
99  template<typename T, glm::qualifier Q>
+
100  struct hash<glm::mat<2, 4, T,Q> >
+
101  {
+
102  GLM_FUNC_DECL size_t operator()(glm::mat<2, 4, T,Q> const& m) const;
+
103  };
+
104 
+
105  template<typename T, glm::qualifier Q>
+
106  struct hash<glm::mat<3, 2, T,Q> >
+
107  {
+
108  GLM_FUNC_DECL size_t operator()(glm::mat<3, 2, T,Q> const& m) const;
+
109  };
+
110 
+
111  template<typename T, glm::qualifier Q>
+
112  struct hash<glm::mat<3, 3, T,Q> >
+
113  {
+
114  GLM_FUNC_DECL size_t operator()(glm::mat<3, 3, T,Q> const& m) const;
+
115  };
+
116 
+
117  template<typename T, glm::qualifier Q>
+
118  struct hash<glm::mat<3, 4, T,Q> >
+
119  {
+
120  GLM_FUNC_DECL size_t operator()(glm::mat<3, 4, T,Q> const& m) const;
+
121  };
+
122 
+
123  template<typename T, glm::qualifier Q>
+
124  struct hash<glm::mat<4, 2, T,Q> >
+
125  {
+
126  GLM_FUNC_DECL size_t operator()(glm::mat<4, 2, T,Q> const& m) const;
+
127  };
+
128 
+
129  template<typename T, glm::qualifier Q>
+
130  struct hash<glm::mat<4, 3, T,Q> >
+
131  {
+
132  GLM_FUNC_DECL size_t operator()(glm::mat<4, 3, T,Q> const& m) const;
+
133  };
+
134 
+
135  template<typename T, glm::qualifier Q>
+
136  struct hash<glm::mat<4, 4, T,Q> >
+
137  {
+
138  GLM_FUNC_DECL size_t operator()(glm::mat<4, 4, T,Q> const& m) const;
+
139  };
+
140 } // namespace std
+
141 
+
142 #include "hash.inl"
+
Definition: hash.hpp:49
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00041.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00041.html new file mode 100644 index 0000000000000000000000000000000000000000..2996ba259a3b3096471084a07cd2c4c07bb20ad6 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00041.html @@ -0,0 +1,129 @@ + + + + + + +0.9.9 API documentation: integer.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
gtc/integer.hpp File Reference
+
+
+ +

GLM_GTC_integer +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + +

+Functions

template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, int, Q > iround (vec< L, T, Q > const &x)
 Returns a value equal to the nearest integer to x. More...
 
template<typename genIUType >
GLM_FUNC_DECL genIUType log2 (genIUType x)
 Returns the log2 of x for integer values. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, uint, Q > uround (vec< L, T, Q > const &x)
 Returns a value equal to the nearest integer to x. More...
 
+

Detailed Description

+

GLM_GTC_integer

+
See also
Core features (dependence)
+
+GLM_GTC_integer (dependence)
+ +

Definition in file gtc/integer.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00041_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00041_source.html new file mode 100644 index 0000000000000000000000000000000000000000..ac897205de20b155c61b21d0650212b8fd6ed91c --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00041_source.html @@ -0,0 +1,133 @@ + + + + + + +0.9.9 API documentation: integer.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
gtc/integer.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependencies
+
17 #include "../detail/setup.hpp"
+
18 #include "../detail/qualifier.hpp"
+
19 #include "../common.hpp"
+
20 #include "../integer.hpp"
+
21 #include "../exponential.hpp"
+
22 #include <limits>
+
23 
+
24 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
25 # pragma message("GLM: GLM_GTC_integer extension included")
+
26 #endif
+
27 
+
28 namespace glm
+
29 {
+
32 
+
35  template<typename genIUType>
+
36  GLM_FUNC_DECL genIUType log2(genIUType x);
+
37 
+
47  template<length_t L, typename T, qualifier Q>
+
48  GLM_FUNC_DECL vec<L, int, Q> iround(vec<L, T, Q> const& x);
+
49 
+
59  template<length_t L, typename T, qualifier Q>
+
60  GLM_FUNC_DECL vec<L, uint, Q> uround(vec<L, T, Q> const& x);
+
61 
+
63 } //namespace glm
+
64 
+
65 #include "integer.inl"
+
GLM_FUNC_DECL vec< L, uint, Q > uround(vec< L, T, Q > const &x)
Returns a value equal to the nearest integer to x.
+
GLM_FUNC_DECL genIUType log2(genIUType x)
Returns the log2 of x for integer values.
+
GLM_FUNC_DECL vec< L, int, Q > iround(vec< L, T, Q > const &x)
Returns a value equal to the nearest integer to x.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00042.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00042.html new file mode 100644 index 0000000000000000000000000000000000000000..8779f988b907ce23cc71adc6fd63488708e3c45d --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00042.html @@ -0,0 +1,150 @@ + + + + + + +0.9.9 API documentation: integer.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
gtx/integer.hpp File Reference
+
+
+ +

GLM_GTX_integer +More...

+ +

Go to the source code of this file.

+ + + + + +

+Typedefs

typedef signed int sint
 32bit signed integer. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL genType factorial (genType const &x)
 Return the factorial value of a number (!12 max, integer only) From GLM_GTX_integer extension. More...
 
GLM_FUNC_DECL unsigned int floor_log2 (unsigned int x)
 Returns the floor log2 of x. More...
 
GLM_FUNC_DECL int mod (int x, int y)
 Modulus. More...
 
GLM_FUNC_DECL uint mod (uint x, uint y)
 Modulus. More...
 
GLM_FUNC_DECL uint nlz (uint x)
 Returns the number of leading zeros. More...
 
GLM_FUNC_DECL int pow (int x, uint y)
 Returns x raised to the y power. More...
 
GLM_FUNC_DECL uint pow (uint x, uint y)
 Returns x raised to the y power. More...
 
GLM_FUNC_DECL int sqrt (int x)
 Returns the positive square root of x. More...
 
GLM_FUNC_DECL uint sqrt (uint x)
 Returns the positive square root of x. More...
 
+

Detailed Description

+

GLM_GTX_integer

+
See also
Core features (dependence)
+ +

Definition in file gtx/integer.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00042_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00042_source.html new file mode 100644 index 0000000000000000000000000000000000000000..9093e881b5ba2fb0c55da976270e4e19020e6927 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00042_source.html @@ -0,0 +1,149 @@ + + + + + + +0.9.9 API documentation: integer.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
gtx/integer.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../glm.hpp"
+
17 #include "../gtc/integer.hpp"
+
18 
+
19 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
20 # ifndef GLM_ENABLE_EXPERIMENTAL
+
21 # pragma message("GLM: GLM_GTX_integer is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
22 # else
+
23 # pragma message("GLM: GLM_GTX_integer extension included")
+
24 # endif
+
25 #endif
+
26 
+
27 namespace glm
+
28 {
+
31 
+
34  GLM_FUNC_DECL int pow(int x, uint y);
+
35 
+
38  GLM_FUNC_DECL int sqrt(int x);
+
39 
+
42  GLM_FUNC_DECL unsigned int floor_log2(unsigned int x);
+
43 
+
46  GLM_FUNC_DECL int mod(int x, int y);
+
47 
+
50  template<typename genType>
+
51  GLM_FUNC_DECL genType factorial(genType const& x);
+
52 
+
55  typedef signed int sint;
+
56 
+
59  GLM_FUNC_DECL uint pow(uint x, uint y);
+
60 
+
63  GLM_FUNC_DECL uint sqrt(uint x);
+
64 
+
67  GLM_FUNC_DECL uint mod(uint x, uint y);
+
68 
+
71  GLM_FUNC_DECL uint nlz(uint x);
+
72 
+
74 }//namespace glm
+
75 
+
76 #include "integer.inl"
+
GLM_FUNC_DECL uint nlz(uint x)
Returns the number of leading zeros.
+
GLM_FUNC_DECL uint mod(uint x, uint y)
Modulus.
+
GLM_FUNC_DECL unsigned int floor_log2(unsigned int x)
Returns the floor log2 of x.
+
signed int sint
32bit signed integer.
Definition: gtx/integer.hpp:55
+
GLM_FUNC_DECL genType factorial(genType const &x)
Return the factorial value of a number (!12 max, integer only) From GLM_GTX_integer extension...
+
GLM_FUNC_DECL uint pow(uint x, uint y)
Returns x raised to the y power.
+
GLM_FUNC_DECL uint sqrt(uint x)
Returns the positive square root of x.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00043.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00043.html new file mode 100644 index 0000000000000000000000000000000000000000..02da2db62f2d612290d728822f856dff71cfeb9a --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00043.html @@ -0,0 +1,167 @@ + + + + + + +0.9.9 API documentation: integer.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
integer.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL int bitCount (genType v)
 Returns the number of bits set to 1 in the binary representation of value. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, int, Q > bitCount (vec< L, T, Q > const &v)
 Returns the number of bits set to 1 in the binary representation of value. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > bitfieldExtract (vec< L, T, Q > const &Value, int Offset, int Bits)
 Extracts bits [offset, offset + bits - 1] from value, returning them in the least significant bits of the result. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > bitfieldInsert (vec< L, T, Q > const &Base, vec< L, T, Q > const &Insert, int Offset, int Bits)
 Returns the insertion the bits least-significant bits of insert into base. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > bitfieldReverse (vec< L, T, Q > const &v)
 Returns the reversal of the bits of value. More...
 
template<typename genIUType >
GLM_FUNC_DECL int findLSB (genIUType x)
 Returns the bit number of the least significant bit set to 1 in the binary representation of value. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, int, Q > findLSB (vec< L, T, Q > const &v)
 Returns the bit number of the least significant bit set to 1 in the binary representation of value. More...
 
template<typename genIUType >
GLM_FUNC_DECL int findMSB (genIUType x)
 Returns the bit number of the most significant bit in the binary representation of value. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, int, Q > findMSB (vec< L, T, Q > const &v)
 Returns the bit number of the most significant bit in the binary representation of value. More...
 
template<length_t L, qualifier Q>
GLM_FUNC_DECL void imulExtended (vec< L, int, Q > const &x, vec< L, int, Q > const &y, vec< L, int, Q > &msb, vec< L, int, Q > &lsb)
 Multiplies 32-bit integers x and y, producing a 64-bit result. More...
 
template<length_t L, qualifier Q>
GLM_FUNC_DECL vec< L, uint, Q > uaddCarry (vec< L, uint, Q > const &x, vec< L, uint, Q > const &y, vec< L, uint, Q > &carry)
 Adds 32-bit unsigned integer x and y, returning the sum modulo pow(2, 32). More...
 
template<length_t L, qualifier Q>
GLM_FUNC_DECL void umulExtended (vec< L, uint, Q > const &x, vec< L, uint, Q > const &y, vec< L, uint, Q > &msb, vec< L, uint, Q > &lsb)
 Multiplies 32-bit integers x and y, producing a 64-bit result. More...
 
template<length_t L, qualifier Q>
GLM_FUNC_DECL vec< L, uint, Q > usubBorrow (vec< L, uint, Q > const &x, vec< L, uint, Q > const &y, vec< L, uint, Q > &borrow)
 Subtracts the 32-bit unsigned integer y from x, returning the difference if non-negative, or pow(2, 32) plus the difference otherwise. More...
 
+

Detailed Description

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00043_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00043_source.html new file mode 100644 index 0000000000000000000000000000000000000000..675e0f0c82f2afcffc7bc225dc2ba176e87a5446 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00043_source.html @@ -0,0 +1,185 @@ + + + + + + +0.9.9 API documentation: integer.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
integer.hpp
+
+
+Go to the documentation of this file.
1 
+
17 #pragma once
+
18 
+
19 #include "detail/qualifier.hpp"
+
20 #include "common.hpp"
+
21 #include "vector_relational.hpp"
+
22 
+
23 namespace glm
+
24 {
+
27 
+
36  template<length_t L, qualifier Q>
+
37  GLM_FUNC_DECL vec<L, uint, Q> uaddCarry(
+
38  vec<L, uint, Q> const& x,
+
39  vec<L, uint, Q> const& y,
+
40  vec<L, uint, Q> & carry);
+
41 
+
50  template<length_t L, qualifier Q>
+
51  GLM_FUNC_DECL vec<L, uint, Q> usubBorrow(
+
52  vec<L, uint, Q> const& x,
+
53  vec<L, uint, Q> const& y,
+
54  vec<L, uint, Q> & borrow);
+
55 
+
64  template<length_t L, qualifier Q>
+
65  GLM_FUNC_DECL void umulExtended(
+
66  vec<L, uint, Q> const& x,
+
67  vec<L, uint, Q> const& y,
+
68  vec<L, uint, Q> & msb,
+
69  vec<L, uint, Q> & lsb);
+
70 
+
79  template<length_t L, qualifier Q>
+
80  GLM_FUNC_DECL void imulExtended(
+
81  vec<L, int, Q> const& x,
+
82  vec<L, int, Q> const& y,
+
83  vec<L, int, Q> & msb,
+
84  vec<L, int, Q> & lsb);
+
85 
+
102  template<length_t L, typename T, qualifier Q>
+
103  GLM_FUNC_DECL vec<L, T, Q> bitfieldExtract(
+
104  vec<L, T, Q> const& Value,
+
105  int Offset,
+
106  int Bits);
+
107 
+
123  template<length_t L, typename T, qualifier Q>
+
124  GLM_FUNC_DECL vec<L, T, Q> bitfieldInsert(
+
125  vec<L, T, Q> const& Base,
+
126  vec<L, T, Q> const& Insert,
+
127  int Offset,
+
128  int Bits);
+
129 
+
139  template<length_t L, typename T, qualifier Q>
+
140  GLM_FUNC_DECL vec<L, T, Q> bitfieldReverse(vec<L, T, Q> const& v);
+
141 
+
148  template<typename genType>
+
149  GLM_FUNC_DECL int bitCount(genType v);
+
150 
+
158  template<length_t L, typename T, qualifier Q>
+
159  GLM_FUNC_DECL vec<L, int, Q> bitCount(vec<L, T, Q> const& v);
+
160 
+
169  template<typename genIUType>
+
170  GLM_FUNC_DECL int findLSB(genIUType x);
+
171 
+
181  template<length_t L, typename T, qualifier Q>
+
182  GLM_FUNC_DECL vec<L, int, Q> findLSB(vec<L, T, Q> const& v);
+
183 
+
193  template<typename genIUType>
+
194  GLM_FUNC_DECL int findMSB(genIUType x);
+
195 
+
206  template<length_t L, typename T, qualifier Q>
+
207  GLM_FUNC_DECL vec<L, int, Q> findMSB(vec<L, T, Q> const& v);
+
208 
+
210 }//namespace glm
+
211 
+
212 #include "detail/func_integer.inl"
+
Core features
+
GLM_FUNC_DECL vec< L, int, Q > findMSB(vec< L, T, Q > const &v)
Returns the bit number of the most significant bit in the binary representation of value...
+
GLM_FUNC_DECL void umulExtended(vec< L, uint, Q > const &x, vec< L, uint, Q > const &y, vec< L, uint, Q > &msb, vec< L, uint, Q > &lsb)
Multiplies 32-bit integers x and y, producing a 64-bit result.
+
GLM_FUNC_DECL void imulExtended(vec< L, int, Q > const &x, vec< L, int, Q > const &y, vec< L, int, Q > &msb, vec< L, int, Q > &lsb)
Multiplies 32-bit integers x and y, producing a 64-bit result.
+
GLM_FUNC_DECL vec< L, int, Q > bitCount(vec< L, T, Q > const &v)
Returns the number of bits set to 1 in the binary representation of value.
+
GLM_FUNC_DECL vec< L, uint, Q > uaddCarry(vec< L, uint, Q > const &x, vec< L, uint, Q > const &y, vec< L, uint, Q > &carry)
Adds 32-bit unsigned integer x and y, returning the sum modulo pow(2, 32).
+
GLM_FUNC_DECL vec< L, T, Q > bitfieldExtract(vec< L, T, Q > const &Value, int Offset, int Bits)
Extracts bits [offset, offset + bits - 1] from value, returning them in the least significant bits of...
+
GLM_FUNC_DECL vec< L, T, Q > bitfieldInsert(vec< L, T, Q > const &Base, vec< L, T, Q > const &Insert, int Offset, int Bits)
Returns the insertion the bits least-significant bits of insert into base.
+
Core features
+
GLM_FUNC_DECL vec< L, T, Q > bitfieldReverse(vec< L, T, Q > const &v)
Returns the reversal of the bits of value.
+
GLM_FUNC_DECL vec< L, uint, Q > usubBorrow(vec< L, uint, Q > const &x, vec< L, uint, Q > const &y, vec< L, uint, Q > &borrow)
Subtracts the 32-bit unsigned integer y from x, returning the difference if non-negative, or pow(2, 32) plus the difference otherwise.
+
GLM_FUNC_DECL vec< L, int, Q > findLSB(vec< L, T, Q > const &v)
Returns the bit number of the least significant bit set to 1 in the binary representation of value...
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00044.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00044.html new file mode 100644 index 0000000000000000000000000000000000000000..86892f43a0edd90421afd3e492920c8311a881d1 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00044.html @@ -0,0 +1,141 @@ + + + + + + +0.9.9 API documentation: intersect.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
intersect.hpp File Reference
+
+
+ +

GLM_GTX_intersect +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL bool intersectLineSphere (genType const &point0, genType const &point1, genType const &sphereCenter, typename genType::value_type sphereRadius, genType &intersectionPosition1, genType &intersectionNormal1, genType &intersectionPosition2=genType(), genType &intersectionNormal2=genType())
 Compute the intersection of a line and a sphere. More...
 
template<typename genType >
GLM_FUNC_DECL bool intersectLineTriangle (genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &position)
 Compute the intersection of a line and a triangle. More...
 
template<typename genType >
GLM_FUNC_DECL bool intersectRayPlane (genType const &orig, genType const &dir, genType const &planeOrig, genType const &planeNormal, typename genType::value_type &intersectionDistance)
 Compute the intersection of a ray and a plane. More...
 
template<typename genType >
GLM_FUNC_DECL bool intersectRaySphere (genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, typename genType::value_type const sphereRadiusSquared, typename genType::value_type &intersectionDistance)
 Compute the intersection distance of a ray and a sphere. More...
 
template<typename genType >
GLM_FUNC_DECL bool intersectRaySphere (genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, const typename genType::value_type sphereRadius, genType &intersectionPosition, genType &intersectionNormal)
 Compute the intersection of a ray and a sphere. More...
 
template<typename T , qualifier Q>
GLM_FUNC_DECL bool intersectRayTriangle (vec< 3, T, Q > const &orig, vec< 3, T, Q > const &dir, vec< 3, T, Q > const &v0, vec< 3, T, Q > const &v1, vec< 3, T, Q > const &v2, vec< 2, T, Q > &baryPosition, T &distance)
 Compute the intersection of a ray and a triangle. More...
 
+

Detailed Description

+

GLM_GTX_intersect

+
See also
Core features (dependence)
+
+GLM_GTX_closest_point (dependence)
+ +

Definition in file intersect.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00044_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00044_source.html new file mode 100644 index 0000000000000000000000000000000000000000..f11348274faa882f630932affe22989c3485ebd6 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00044_source.html @@ -0,0 +1,168 @@ + + + + + + +0.9.9 API documentation: intersect.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
intersect.hpp
+
+
+Go to the documentation of this file.
1 
+
14 #pragma once
+
15 
+
16 // Dependency:
+
17 #include <cfloat>
+
18 #include <limits>
+
19 #include "../glm.hpp"
+
20 #include "../geometric.hpp"
+
21 #include "../gtx/closest_point.hpp"
+
22 #include "../gtx/vector_query.hpp"
+
23 
+
24 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
25 # ifndef GLM_ENABLE_EXPERIMENTAL
+
26 # pragma message("GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
27 # else
+
28 # pragma message("GLM: GLM_GTX_closest_point extension included")
+
29 # endif
+
30 #endif
+
31 
+
32 namespace glm
+
33 {
+
36 
+
40  template<typename genType>
+
41  GLM_FUNC_DECL bool intersectRayPlane(
+
42  genType const& orig, genType const& dir,
+
43  genType const& planeOrig, genType const& planeNormal,
+
44  typename genType::value_type & intersectionDistance);
+
45 
+
49  template<typename T, qualifier Q>
+
50  GLM_FUNC_DECL bool intersectRayTriangle(
+
51  vec<3, T, Q> const& orig, vec<3, T, Q> const& dir,
+
52  vec<3, T, Q> const& v0, vec<3, T, Q> const& v1, vec<3, T, Q> const& v2,
+
53  vec<2, T, Q>& baryPosition, T& distance);
+
54 
+
57  template<typename genType>
+
58  GLM_FUNC_DECL bool intersectLineTriangle(
+
59  genType const& orig, genType const& dir,
+
60  genType const& vert0, genType const& vert1, genType const& vert2,
+
61  genType & position);
+
62 
+
66  template<typename genType>
+
67  GLM_FUNC_DECL bool intersectRaySphere(
+
68  genType const& rayStarting, genType const& rayNormalizedDirection,
+
69  genType const& sphereCenter, typename genType::value_type const sphereRadiusSquared,
+
70  typename genType::value_type & intersectionDistance);
+
71 
+
74  template<typename genType>
+
75  GLM_FUNC_DECL bool intersectRaySphere(
+
76  genType const& rayStarting, genType const& rayNormalizedDirection,
+
77  genType const& sphereCenter, const typename genType::value_type sphereRadius,
+
78  genType & intersectionPosition, genType & intersectionNormal);
+
79 
+
82  template<typename genType>
+
83  GLM_FUNC_DECL bool intersectLineSphere(
+
84  genType const& point0, genType const& point1,
+
85  genType const& sphereCenter, typename genType::value_type sphereRadius,
+
86  genType & intersectionPosition1, genType & intersectionNormal1,
+
87  genType & intersectionPosition2 = genType(), genType & intersectionNormal2 = genType());
+
88 
+
90 }//namespace glm
+
91 
+
92 #include "intersect.inl"
+
GLM_FUNC_DECL bool intersectRayTriangle(vec< 3, T, Q > const &orig, vec< 3, T, Q > const &dir, vec< 3, T, Q > const &v0, vec< 3, T, Q > const &v1, vec< 3, T, Q > const &v2, vec< 2, T, Q > &baryPosition, T &distance)
Compute the intersection of a ray and a triangle.
+
GLM_FUNC_DECL bool intersectRaySphere(genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, const typename genType::value_type sphereRadius, genType &intersectionPosition, genType &intersectionNormal)
Compute the intersection of a ray and a sphere.
+
GLM_FUNC_DECL bool intersectRayPlane(genType const &orig, genType const &dir, genType const &planeOrig, genType const &planeNormal, typename genType::value_type &intersectionDistance)
Compute the intersection of a ray and a plane.
+
GLM_FUNC_DECL bool intersectLineTriangle(genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &position)
Compute the intersection of a line and a triangle.
+
GLM_FUNC_DECL bool intersectLineSphere(genType const &point0, genType const &point1, genType const &sphereCenter, typename genType::value_type sphereRadius, genType &intersectionPosition1, genType &intersectionNormal1, genType &intersectionPosition2=genType(), genType &intersectionNormal2=genType())
Compute the intersection of a line and a sphere.
+
GLM_FUNC_DECL T distance(vec< L, T, Q > const &p0, vec< L, T, Q > const &p1)
Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00045.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00045.html new file mode 100644 index 0000000000000000000000000000000000000000..a0bd7057f5f3114a63c7625aadb70853b0fcaec0 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00045.html @@ -0,0 +1,114 @@ + + + + + + +0.9.9 API documentation: io.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
io.hpp File Reference
+
+
+ +

GLM_GTX_io +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

GLM_GTX_io

+
Author
Jan P Springer (regni.nosp@m.rpsj.nosp@m.@gmai.nosp@m.l.co.nosp@m.m)
+
See also
Core features (dependence)
+
+GLM_GTC_matrix_access (dependence)
+
+GLM_GTC_quaternion (dependence)
+ +

Definition in file io.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00045_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00045_source.html new file mode 100644 index 0000000000000000000000000000000000000000..93b422871f012fedb3d448fa67ebd0757400e544 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00045_source.html @@ -0,0 +1,280 @@ + + + + + + +0.9.9 API documentation: io.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
io.hpp
+
+
+Go to the documentation of this file.
1 
+
20 #pragma once
+
21 
+
22 // Dependency:
+
23 #include "../glm.hpp"
+
24 #include "../gtx/quaternion.hpp"
+
25 
+
26 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
27 # ifndef GLM_ENABLE_EXPERIMENTAL
+
28 # pragma message("GLM: GLM_GTX_io is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
29 # else
+
30 # pragma message("GLM: GLM_GTX_io extension included")
+
31 # endif
+
32 #endif
+
33 
+
34 #include <iosfwd> // std::basic_ostream<> (fwd)
+
35 #include <locale> // std::locale, std::locale::facet, std::locale::id
+
36 #include <utility> // std::pair<>
+
37 
+
38 namespace glm
+
39 {
+
42 
+
43  namespace io
+
44  {
+
45  enum order_type { column_major, row_major};
+
46 
+
47  template<typename CTy>
+
48  class format_punct : public std::locale::facet
+
49  {
+
50  typedef CTy char_type;
+
51 
+
52  public:
+
53 
+
54  static std::locale::id id;
+
55 
+
56  bool formatted;
+
57  unsigned precision;
+
58  unsigned width;
+
59  char_type separator;
+
60  char_type delim_left;
+
61  char_type delim_right;
+
62  char_type space;
+
63  char_type newline;
+
64  order_type order;
+
65 
+
66  GLM_FUNC_DECL explicit format_punct(size_t a = 0);
+
67  GLM_FUNC_DECL explicit format_punct(format_punct const&);
+
68  };
+
69 
+
70  template<typename CTy, typename CTr = std::char_traits<CTy> >
+
71  class basic_state_saver {
+
72 
+
73  public:
+
74 
+
75  GLM_FUNC_DECL explicit basic_state_saver(std::basic_ios<CTy,CTr>&);
+
76  GLM_FUNC_DECL ~basic_state_saver();
+
77 
+
78  private:
+
79 
+
80  typedef ::std::basic_ios<CTy,CTr> state_type;
+
81  typedef typename state_type::char_type char_type;
+
82  typedef ::std::ios_base::fmtflags flags_type;
+
83  typedef ::std::streamsize streamsize_type;
+
84  typedef ::std::locale const locale_type;
+
85 
+
86  state_type& state_;
+
87  flags_type flags_;
+
88  streamsize_type precision_;
+
89  streamsize_type width_;
+
90  char_type fill_;
+
91  locale_type locale_;
+
92 
+
93  GLM_FUNC_DECL basic_state_saver& operator=(basic_state_saver const&);
+
94  };
+
95 
+
96  typedef basic_state_saver<char> state_saver;
+
97  typedef basic_state_saver<wchar_t> wstate_saver;
+
98 
+
99  template<typename CTy, typename CTr = std::char_traits<CTy> >
+
100  class basic_format_saver
+
101  {
+
102  public:
+
103 
+
104  GLM_FUNC_DECL explicit basic_format_saver(std::basic_ios<CTy,CTr>&);
+
105  GLM_FUNC_DECL ~basic_format_saver();
+
106 
+
107  private:
+
108 
+
109  basic_state_saver<CTy> const bss_;
+
110 
+
111  GLM_FUNC_DECL basic_format_saver& operator=(basic_format_saver const&);
+
112  };
+
113 
+
114  typedef basic_format_saver<char> format_saver;
+
115  typedef basic_format_saver<wchar_t> wformat_saver;
+
116 
+
117  struct precision
+
118  {
+
119  unsigned value;
+
120 
+
121  GLM_FUNC_DECL explicit precision(unsigned);
+
122  };
+
123 
+
124  struct width
+
125  {
+
126  unsigned value;
+
127 
+
128  GLM_FUNC_DECL explicit width(unsigned);
+
129  };
+
130 
+
131  template<typename CTy>
+
132  struct delimeter
+
133  {
+
134  CTy value[3];
+
135 
+
136  GLM_FUNC_DECL explicit delimeter(CTy /* left */, CTy /* right */, CTy /* separator */ = ',');
+
137  };
+
138 
+
139  struct order
+
140  {
+
141  order_type value;
+
142 
+
143  GLM_FUNC_DECL explicit order(order_type);
+
144  };
+
145 
+
146  // functions, inlined (inline)
+
147 
+
148  template<typename FTy, typename CTy, typename CTr>
+
149  FTy const& get_facet(std::basic_ios<CTy,CTr>&);
+
150  template<typename FTy, typename CTy, typename CTr>
+
151  std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>&);
+
152  template<typename FTy, typename CTy, typename CTr>
+
153  std::basic_ios<CTy,CTr>& unformattet(std::basic_ios<CTy,CTr>&);
+
154 
+
155  template<typename CTy, typename CTr>
+
156  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, precision const&);
+
157  template<typename CTy, typename CTr>
+
158  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, width const&);
+
159  template<typename CTy, typename CTr>
+
160  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, delimeter<CTy> const&);
+
161  template<typename CTy, typename CTr>
+
162  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order const&);
+
163  }//namespace io
+
164 
+
165  template<typename CTy, typename CTr, typename T, qualifier Q>
+
166  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, qua<T, Q> const&);
+
167  template<typename CTy, typename CTr, typename T, qualifier Q>
+
168  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<1, T, Q> const&);
+
169  template<typename CTy, typename CTr, typename T, qualifier Q>
+
170  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<2, T, Q> const&);
+
171  template<typename CTy, typename CTr, typename T, qualifier Q>
+
172  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<3, T, Q> const&);
+
173  template<typename CTy, typename CTr, typename T, qualifier Q>
+
174  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<4, T, Q> const&);
+
175  template<typename CTy, typename CTr, typename T, qualifier Q>
+
176  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 2, T, Q> const&);
+
177  template<typename CTy, typename CTr, typename T, qualifier Q>
+
178  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 3, T, Q> const&);
+
179  template<typename CTy, typename CTr, typename T, qualifier Q>
+
180  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 4, T, Q> const&);
+
181  template<typename CTy, typename CTr, typename T, qualifier Q>
+
182  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 2, T, Q> const&);
+
183  template<typename CTy, typename CTr, typename T, qualifier Q>
+
184  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 3, T, Q> const&);
+
185  template<typename CTy, typename CTr, typename T, qualifier Q>
+
186  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 4, T, Q> const&);
+
187  template<typename CTy, typename CTr, typename T, qualifier Q>
+
188  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 2, T, Q> const&);
+
189  template<typename CTy, typename CTr, typename T, qualifier Q>
+
190  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 3, T, Q> const&);
+
191  template<typename CTy, typename CTr, typename T, qualifier Q>
+
192  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 4, T, Q> const&);
+
193 
+
194  template<typename CTy, typename CTr, typename T, qualifier Q>
+
195  GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr> &,
+
196  std::pair<mat<4, 4, T, Q> const, mat<4, 4, T, Q> const> const&);
+
197 
+
199 }//namespace glm
+
200 
+
201 #include "io.inl"
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00046.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00046.html new file mode 100644 index 0000000000000000000000000000000000000000..1f92ed357d70573df8b2e210c13f8ff05923170a --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00046.html @@ -0,0 +1,123 @@ + + + + + + +0.9.9 API documentation: log_base.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
log_base.hpp File Reference
+
+
+ +

GLM_GTX_log_base +More...

+ +

Go to the source code of this file.

+ + + + + + + + + + +

+Functions

template<typename genType >
GLM_FUNC_DECL genType log (genType const &x, genType const &base)
 Logarithm for any base. More...
 
template<length_t L, typename T , qualifier Q>
GLM_FUNC_DECL vec< L, T, Q > sign (vec< L, T, Q > const &x, vec< L, T, Q > const &base)
 Logarithm for any base. More...
 
+

Detailed Description

+

GLM_GTX_log_base

+
See also
Core features (dependence)
+ +

Definition in file log_base.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00046_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00046_source.html new file mode 100644 index 0000000000000000000000000000000000000000..4e8dc6dbe6997f6c9bcddf67cb3a8bdfc242923d --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00046_source.html @@ -0,0 +1,132 @@ + + + + + + +0.9.9 API documentation: log_base.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
log_base.hpp
+
+
+Go to the documentation of this file.
1 
+
13 #pragma once
+
14 
+
15 // Dependency:
+
16 #include "../glm.hpp"
+
17 
+
18 #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+
19 # ifndef GLM_ENABLE_EXPERIMENTAL
+
20 # pragma message("GLM: GLM_GTX_log_base is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
+
21 # else
+
22 # pragma message("GLM: GLM_GTX_log_base extension included")
+
23 # endif
+
24 #endif
+
25 
+
26 namespace glm
+
27 {
+
30 
+
33  template<typename genType>
+
34  GLM_FUNC_DECL genType log(
+
35  genType const& x,
+
36  genType const& base);
+
37 
+
40  template<length_t L, typename T, qualifier Q>
+
41  GLM_FUNC_DECL vec<L, T, Q> sign(
+
42  vec<L, T, Q> const& x,
+
43  vec<L, T, Q> const& base);
+
44 
+
46 }//namespace glm
+
47 
+
48 #include "log_base.inl"
+
GLM_FUNC_DECL vec< L, T, Q > sign(vec< L, T, Q > const &x, vec< L, T, Q > const &base)
Logarithm for any base.
+
GLM_FUNC_DECL genType log(genType const &x, genType const &base)
Logarithm for any base.
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00047_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00047_source.html new file mode 100644 index 0000000000000000000000000000000000000000..0b8b70ccd6538a14c4a3bc45578c65150345a5ca --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00047_source.html @@ -0,0 +1,2515 @@ + + + + + + +0.9.9 API documentation: man.doxy Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
man.doxy
+
+
+
1 # Doxyfile 1.8.10
+
2 
+
3 # This file describes the settings to be used by the documentation system
+
4 # doxygen (www.doxygen.org) for a project.
+
5 #
+
6 # All text after a double hash (##) is considered a comment and is placed in
+
7 # front of the TAG it is preceding.
+
8 #
+
9 # All text after a single hash (#) is considered a comment and will be ignored.
+
10 # The format is:
+
11 # TAG = value [value, ...]
+
12 # For lists, items can also be appended using:
+
13 # TAG += value [value, ...]
+
14 # Values that contain spaces should be placed between quotes (\" \").
+
15 
+
16 #---------------------------------------------------------------------------
+
17 # Project related configuration options
+
18 #---------------------------------------------------------------------------
+
19 
+
20 # This tag specifies the encoding used for all characters in the config file
+
21 # that follow. The default is UTF-8 which is also the encoding used for all text
+
22 # before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
+
23 # built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
+
24 # for the list of possible encodings.
+
25 # The default value is: UTF-8.
+
26 
+
27 DOXYFILE_ENCODING = UTF-8
+
28 
+
29 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+
30 # double-quotes, unless you are using Doxywizard) that should identify the
+
31 # project for which the documentation is generated. This name is used in the
+
32 # title of most generated pages and in a few other places.
+
33 # The default value is: My Project.
+
34 
+
35 PROJECT_NAME = "0.9.9 API documentation"
+
36 
+
37 # The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+
38 # could be handy for archiving the generated documentation or if some version
+
39 # control system is used.
+
40 
+
41 PROJECT_NUMBER =
+
42 
+
43 # Using the PROJECT_BRIEF tag one can provide an optional one line description
+
44 # for a project that appears at the top of each page and should give viewer a
+
45 # quick idea about the purpose of the project. Keep the description short.
+
46 
+
47 PROJECT_BRIEF =
+
48 
+
49 # With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+
50 # in the documentation. The maximum height of the logo should not exceed 55
+
51 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+
52 # the logo to the output directory.
+
53 
+
54 PROJECT_LOGO = theme/logo-mini.png
+
55 
+
56 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+
57 # into which the generated documentation will be written. If a relative path is
+
58 # entered, it will be relative to the location where doxygen was started. If
+
59 # left blank the current directory will be used.
+
60 
+
61 OUTPUT_DIRECTORY = .
+
62 
+
63 # If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
+
64 # directories (in 2 levels) under the output directory of each output format and
+
65 # will distribute the generated files over these directories. Enabling this
+
66 # option can be useful when feeding doxygen a huge amount of source files, where
+
67 # putting all generated files in the same directory would otherwise causes
+
68 # performance problems for the file system.
+
69 # The default value is: NO.
+
70 
+
71 CREATE_SUBDIRS = NO
+
72 
+
73 # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+
74 # characters to appear in the names of generated files. If set to NO, non-ASCII
+
75 # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+
76 # U+3044.
+
77 # The default value is: NO.
+
78 
+
79 ALLOW_UNICODE_NAMES = NO
+
80 
+
81 # The OUTPUT_LANGUAGE tag is used to specify the language in which all
+
82 # documentation generated by doxygen is written. Doxygen will use this
+
83 # information to generate all constant output in the proper language.
+
84 # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+
85 # Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+
86 # Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+
87 # Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+
88 # Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+
89 # Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+
90 # Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+
91 # Ukrainian and Vietnamese.
+
92 # The default value is: English.
+
93 
+
94 OUTPUT_LANGUAGE = English
+
95 
+
96 # If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+
97 # descriptions after the members that are listed in the file and class
+
98 # documentation (similar to Javadoc). Set to NO to disable this.
+
99 # The default value is: YES.
+
100 
+
101 BRIEF_MEMBER_DESC = YES
+
102 
+
103 # If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+
104 # description of a member or function before the detailed description
+
105 #
+
106 # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+
107 # brief descriptions will be completely suppressed.
+
108 # The default value is: YES.
+
109 
+
110 REPEAT_BRIEF = YES
+
111 
+
112 # This tag implements a quasi-intelligent brief description abbreviator that is
+
113 # used to form the text in various listings. Each string in this list, if found
+
114 # as the leading text of the brief description, will be stripped from the text
+
115 # and the result, after processing the whole list, is used as the annotated
+
116 # text. Otherwise, the brief description is used as-is. If left blank, the
+
117 # following values are used ($name is automatically replaced with the name of
+
118 # the entity):The $name class, The $name widget, The $name file, is, provides,
+
119 # specifies, contains, represents, a, an and the.
+
120 
+
121 ABBREVIATE_BRIEF = "The $name class " \
+
122  "The $name widget " \
+
123  "The $name file " \
+
124  is \
+
125  provides \
+
126  specifies \
+
127  contains \
+
128  represents \
+
129  a \
+
130  an \
+
131  the
+
132 
+
133 # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+
134 # doxygen will generate a detailed section even if there is only a brief
+
135 # description.
+
136 # The default value is: NO.
+
137 
+
138 ALWAYS_DETAILED_SEC = NO
+
139 
+
140 # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+
141 # inherited members of a class in the documentation of that class as if those
+
142 # members were ordinary class members. Constructors, destructors and assignment
+
143 # operators of the base classes will not be shown.
+
144 # The default value is: NO.
+
145 
+
146 INLINE_INHERITED_MEMB = NO
+
147 
+
148 # If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+
149 # before files name in the file list and in the header files. If set to NO the
+
150 # shortest path that makes the file name unique will be used
+
151 # The default value is: YES.
+
152 
+
153 FULL_PATH_NAMES = NO
+
154 
+
155 # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+
156 # Stripping is only done if one of the specified strings matches the left-hand
+
157 # part of the path. The tag can be used to show relative paths in the file list.
+
158 # If left blank the directory from which doxygen is run is used as the path to
+
159 # strip.
+
160 #
+
161 # Note that you can specify absolute paths here, but also relative paths, which
+
162 # will be relative from the directory where doxygen is started.
+
163 # This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
164 
+
165 STRIP_FROM_PATH = "C:/Documents and Settings/Groove/ "
+
166 
+
167 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+
168 # path mentioned in the documentation of a class, which tells the reader which
+
169 # header file to include in order to use a class. If left blank only the name of
+
170 # the header file containing the class definition is used. Otherwise one should
+
171 # specify the list of include paths that are normally passed to the compiler
+
172 # using the -I flag.
+
173 
+
174 STRIP_FROM_INC_PATH =
+
175 
+
176 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+
177 # less readable) file names. This can be useful is your file systems doesn't
+
178 # support long names like on DOS, Mac, or CD-ROM.
+
179 # The default value is: NO.
+
180 
+
181 SHORT_NAMES = YES
+
182 
+
183 # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+
184 # first line (until the first dot) of a Javadoc-style comment as the brief
+
185 # description. If set to NO, the Javadoc-style will behave just like regular Qt-
+
186 # style comments (thus requiring an explicit @brief command for a brief
+
187 # description.)
+
188 # The default value is: NO.
+
189 
+
190 JAVADOC_AUTOBRIEF = YES
+
191 
+
192 # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+
193 # line (until the first dot) of a Qt-style comment as the brief description. If
+
194 # set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+
195 # requiring an explicit \brief command for a brief description.)
+
196 # The default value is: NO.
+
197 
+
198 QT_AUTOBRIEF = NO
+
199 
+
200 # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+
201 # multi-line C++ special comment block (i.e. a block of
+
202 # a brief description. This used to be the default behavior. The new default is
+
203 # to treat a multi-line C++ comment block as a detailed description. Set this
+
204 # tag to YES if you prefer the old behavior instead.
+
205 #
+
206 # Note that setting this tag to YES also means that rational rose comments are
+
207 # not recognized any more.
+
208 # The default value is: NO.
+
209 
+
210 MULTILINE_CPP_IS_BRIEF = NO
+
211 
+
212 # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+
213 # documentation from any documented member that it re-implements.
+
214 # The default value is: YES.
+
215 
+
216 INHERIT_DOCS = YES
+
217 
+
218 # If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+
219 # page for each member. If set to NO, the documentation of a member will be part
+
220 # of the file/class/namespace that contains it.
+
221 # The default value is: NO.
+
222 
+
223 SEPARATE_MEMBER_PAGES = NO
+
224 
+
225 # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+
226 # uses this value to replace tabs by spaces in code fragments.
+
227 # Minimum value: 1, maximum value: 16, default value: 4.
+
228 
+
229 TAB_SIZE = 8
+
230 
+
231 # This tag can be used to specify a number of aliases that act as commands in
+
232 # the documentation. An alias has the form:
+
233 # name=value
+
234 # For example adding
+
235 # "sideeffect=@par Side Effects:\n"
+
236 # will allow you to put the command \sideeffect (or @sideeffect) in the
+
237 # documentation, which will result in a user-defined paragraph with heading
+
238 # "Side Effects:". You can put \n's in the value part of an alias to insert
+
239 # newlines.
+
240 
+
241 ALIASES =
+
242 
+
243 # This tag can be used to specify a number of word-keyword mappings (TCL only).
+
244 # A mapping has the form "name=value". For example adding "class=itcl::class"
+
245 # will allow you to use the command class in the itcl::class meaning.
+
246 
+
247 TCL_SUBST =
+
248 
+
249 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+
250 # only. Doxygen will then generate output that is more tailored for C. For
+
251 # instance, some of the names that are used will be different. The list of all
+
252 # members will be omitted, etc.
+
253 # The default value is: NO.
+
254 
+
255 OPTIMIZE_OUTPUT_FOR_C = NO
+
256 
+
257 # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+
258 # Python sources only. Doxygen will then generate output that is more tailored
+
259 # for that language. For instance, namespaces will be presented as packages,
+
260 # qualified scopes will look different, etc.
+
261 # The default value is: NO.
+
262 
+
263 OPTIMIZE_OUTPUT_JAVA = NO
+
264 
+
265 # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+
266 # sources. Doxygen will then generate output that is tailored for Fortran.
+
267 # The default value is: NO.
+
268 
+
269 OPTIMIZE_FOR_FORTRAN = NO
+
270 
+
271 # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+
272 # sources. Doxygen will then generate output that is tailored for VHDL.
+
273 # The default value is: NO.
+
274 
+
275 OPTIMIZE_OUTPUT_VHDL = NO
+
276 
+
277 # Doxygen selects the parser to use depending on the extension of the files it
+
278 # parses. With this tag you can assign which parser to use for a given
+
279 # extension. Doxygen has a built-in mapping, but you can override or extend it
+
280 # using this tag. The format is ext=language, where ext is a file extension, and
+
281 # language is one of the parsers supported by doxygen: IDL, Java, Javascript,
+
282 # C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
+
283 # FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
+
284 # Fortran. In the later case the parser tries to guess whether the code is fixed
+
285 # or free formatted code, this is the default for Fortran type files), VHDL. For
+
286 # instance to make doxygen treat .inc files as Fortran files (default is PHP),
+
287 # and .f files as C (default is Fortran), use: inc=Fortran f=C.
+
288 #
+
289 # Note: For files without extension you can use no_extension as a placeholder.
+
290 #
+
291 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+
292 # the files are not read by doxygen.
+
293 
+
294 EXTENSION_MAPPING =
+
295 
+
296 # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+
297 # according to the Markdown format, which allows for more readable
+
298 # documentation. See http://daringfireball.net/projects/markdown/ for details.
+
299 # The output of markdown processing is further processed by doxygen, so you can
+
300 # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+
301 # case of backward compatibilities issues.
+
302 # The default value is: YES.
+
303 
+
304 MARKDOWN_SUPPORT = YES
+
305 
+
306 # When enabled doxygen tries to link words that correspond to documented
+
307 # classes, or namespaces to their corresponding documentation. Such a link can
+
308 # be prevented in individual cases by putting a % sign in front of the word or
+
309 # globally by setting AUTOLINK_SUPPORT to NO.
+
310 # The default value is: YES.
+
311 
+
312 AUTOLINK_SUPPORT = YES
+
313 
+
314 # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+
315 # to include (a tag file for) the STL sources as input, then you should set this
+
316 # tag to YES in order to let doxygen match functions declarations and
+
317 # definitions whose arguments contain STL classes (e.g. func(std::string);
+
318 # versus func(std::string) {}). This also make the inheritance and collaboration
+
319 # diagrams that involve STL classes more complete and accurate.
+
320 # The default value is: NO.
+
321 
+
322 BUILTIN_STL_SUPPORT = NO
+
323 
+
324 # If you use Microsoft's C++/CLI language, you should set this option to YES to
+
325 # enable parsing support.
+
326 # The default value is: NO.
+
327 
+
328 CPP_CLI_SUPPORT = NO
+
329 
+
330 # Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+
331 # http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+
332 # will parse them like normal C++ but will assume all classes use public instead
+
333 # of private inheritance when no explicit protection keyword is present.
+
334 # The default value is: NO.
+
335 
+
336 SIP_SUPPORT = NO
+
337 
+
338 # For Microsoft's IDL there are propget and propput attributes to indicate
+
339 # getter and setter methods for a property. Setting this option to YES will make
+
340 # doxygen to replace the get and set methods by a property in the documentation.
+
341 # This will only work if the methods are indeed getting or setting a simple
+
342 # type. If this is not the case, or you want to show the methods anyway, you
+
343 # should set this option to NO.
+
344 # The default value is: YES.
+
345 
+
346 IDL_PROPERTY_SUPPORT = YES
+
347 
+
348 # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+
349 # tag is set to YES then doxygen will reuse the documentation of the first
+
350 # member in the group (if any) for the other members of the group. By default
+
351 # all members of a group must be documented explicitly.
+
352 # The default value is: NO.
+
353 
+
354 DISTRIBUTE_GROUP_DOC = NO
+
355 
+
356 # If one adds a struct or class to a group and this option is enabled, then also
+
357 # any nested class or struct is added to the same group. By default this option
+
358 # is disabled and one has to add nested compounds explicitly via \ingroup.
+
359 # The default value is: NO.
+
360 
+
361 GROUP_NESTED_COMPOUNDS = NO
+
362 
+
363 # Set the SUBGROUPING tag to YES to allow class member groups of the same type
+
364 # (for instance a group of public functions) to be put as a subgroup of that
+
365 # type (e.g. under the Public Functions section). Set it to NO to prevent
+
366 # subgrouping. Alternatively, this can be done per class using the
+
367 # \nosubgrouping command.
+
368 # The default value is: YES.
+
369 
+
370 SUBGROUPING = NO
+
371 
+
372 # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+
373 # are shown inside the group in which they are included (e.g. using \ingroup)
+
374 # instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+
375 # and RTF).
+
376 #
+
377 # Note that this feature does not work in combination with
+
378 # SEPARATE_MEMBER_PAGES.
+
379 # The default value is: NO.
+
380 
+
381 INLINE_GROUPED_CLASSES = NO
+
382 
+
383 # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+
384 # with only public data fields or simple typedef fields will be shown inline in
+
385 # the documentation of the scope in which they are defined (i.e. file,
+
386 # namespace, or group documentation), provided this scope is documented. If set
+
387 # to NO, structs, classes, and unions are shown on a separate page (for HTML and
+
388 # Man pages) or section (for LaTeX and RTF).
+
389 # The default value is: NO.
+
390 
+
391 INLINE_SIMPLE_STRUCTS = NO
+
392 
+
393 # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+
394 # enum is documented as struct, union, or enum with the name of the typedef. So
+
395 # typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+
396 # with name TypeT. When disabled the typedef will appear as a member of a file,
+
397 # namespace, or class. And the struct will be named TypeS. This can typically be
+
398 # useful for C code in case the coding convention dictates that all compound
+
399 # types are typedef'ed and only the typedef is referenced, never the tag name.
+
400 # The default value is: NO.
+
401 
+
402 TYPEDEF_HIDES_STRUCT = NO
+
403 
+
404 # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+
405 # cache is used to resolve symbols given their name and scope. Since this can be
+
406 # an expensive process and often the same symbol appears multiple times in the
+
407 # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+
408 # doxygen will become slower. If the cache is too large, memory is wasted. The
+
409 # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+
410 # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+
411 # symbols. At the end of a run doxygen will report the cache usage and suggest
+
412 # the optimal cache size from a speed point of view.
+
413 # Minimum value: 0, maximum value: 9, default value: 0.
+
414 
+
415 LOOKUP_CACHE_SIZE = 0
+
416 
+
417 #---------------------------------------------------------------------------
+
418 # Build related configuration options
+
419 #---------------------------------------------------------------------------
+
420 
+
421 # If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+
422 # documentation are documented, even if no documentation was available. Private
+
423 # class members and static file members will be hidden unless the
+
424 # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+
425 # Note: This will also disable the warnings about undocumented members that are
+
426 # normally produced when WARNINGS is set to YES.
+
427 # The default value is: NO.
+
428 
+
429 EXTRACT_ALL = NO
+
430 
+
431 # If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+
432 # be included in the documentation.
+
433 # The default value is: NO.
+
434 
+
435 EXTRACT_PRIVATE = NO
+
436 
+
437 # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
+
438 # scope will be included in the documentation.
+
439 # The default value is: NO.
+
440 
+
441 EXTRACT_PACKAGE = NO
+
442 
+
443 # If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+
444 # included in the documentation.
+
445 # The default value is: NO.
+
446 
+
447 EXTRACT_STATIC = YES
+
448 
+
449 # If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+
450 # locally in source files will be included in the documentation. If set to NO,
+
451 # only classes defined in header files are included. Does not have any effect
+
452 # for Java sources.
+
453 # The default value is: YES.
+
454 
+
455 EXTRACT_LOCAL_CLASSES = NO
+
456 
+
457 # This flag is only useful for Objective-C code. If set to YES, local methods,
+
458 # which are defined in the implementation section but not in the interface are
+
459 # included in the documentation. If set to NO, only methods in the interface are
+
460 # included.
+
461 # The default value is: NO.
+
462 
+
463 EXTRACT_LOCAL_METHODS = NO
+
464 
+
465 # If this flag is set to YES, the members of anonymous namespaces will be
+
466 # extracted and appear in the documentation as a namespace called
+
467 # 'anonymous_namespace{file}', where file will be replaced with the base name of
+
468 # the file that contains the anonymous namespace. By default anonymous namespace
+
469 # are hidden.
+
470 # The default value is: NO.
+
471 
+
472 EXTRACT_ANON_NSPACES = NO
+
473 
+
474 # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+
475 # undocumented members inside documented classes or files. If set to NO these
+
476 # members will be included in the various overviews, but no documentation
+
477 # section is generated. This option has no effect if EXTRACT_ALL is enabled.
+
478 # The default value is: NO.
+
479 
+
480 HIDE_UNDOC_MEMBERS = YES
+
481 
+
482 # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+
483 # undocumented classes that are normally visible in the class hierarchy. If set
+
484 # to NO, these classes will be included in the various overviews. This option
+
485 # has no effect if EXTRACT_ALL is enabled.
+
486 # The default value is: NO.
+
487 
+
488 HIDE_UNDOC_CLASSES = YES
+
489 
+
490 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+
491 # (class|struct|union) declarations. If set to NO, these declarations will be
+
492 # included in the documentation.
+
493 # The default value is: NO.
+
494 
+
495 HIDE_FRIEND_COMPOUNDS = YES
+
496 
+
497 # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+
498 # documentation blocks found inside the body of a function. If set to NO, these
+
499 # blocks will be appended to the function's detailed documentation block.
+
500 # The default value is: NO.
+
501 
+
502 HIDE_IN_BODY_DOCS = YES
+
503 
+
504 # The INTERNAL_DOCS tag determines if documentation that is typed after a
+
505 # \internal command is included. If the tag is set to NO then the documentation
+
506 # will be excluded. Set it to YES to include the internal documentation.
+
507 # The default value is: NO.
+
508 
+
509 INTERNAL_DOCS = NO
+
510 
+
511 # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+
512 # names in lower-case letters. If set to YES, upper-case letters are also
+
513 # allowed. This is useful if you have classes or files whose names only differ
+
514 # in case and if your file system supports case sensitive file names. Windows
+
515 # and Mac users are advised to set this option to NO.
+
516 # The default value is: system dependent.
+
517 
+
518 CASE_SENSE_NAMES = YES
+
519 
+
520 # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+
521 # their full class and namespace scopes in the documentation. If set to YES, the
+
522 # scope will be hidden.
+
523 # The default value is: NO.
+
524 
+
525 HIDE_SCOPE_NAMES = YES
+
526 
+
527 # If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+
528 # append additional text to a page's title, such as Class Reference. If set to
+
529 # YES the compound reference will be hidden.
+
530 # The default value is: NO.
+
531 
+
532 HIDE_COMPOUND_REFERENCE= NO
+
533 
+
534 # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+
535 # the files that are included by a file in the documentation of that file.
+
536 # The default value is: YES.
+
537 
+
538 SHOW_INCLUDE_FILES = NO
+
539 
+
540 # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+
541 # grouped member an include statement to the documentation, telling the reader
+
542 # which file to include in order to use the member.
+
543 # The default value is: NO.
+
544 
+
545 SHOW_GROUPED_MEMB_INC = NO
+
546 
+
547 # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+
548 # files with double quotes in the documentation rather than with sharp brackets.
+
549 # The default value is: NO.
+
550 
+
551 FORCE_LOCAL_INCLUDES = NO
+
552 
+
553 # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+
554 # documentation for inline members.
+
555 # The default value is: YES.
+
556 
+
557 INLINE_INFO = NO
+
558 
+
559 # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+
560 # (detailed) documentation of file and class members alphabetically by member
+
561 # name. If set to NO, the members will appear in declaration order.
+
562 # The default value is: YES.
+
563 
+
564 SORT_MEMBER_DOCS = YES
+
565 
+
566 # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+
567 # descriptions of file, namespace and class members alphabetically by member
+
568 # name. If set to NO, the members will appear in declaration order. Note that
+
569 # this will also influence the order of the classes in the class list.
+
570 # The default value is: NO.
+
571 
+
572 SORT_BRIEF_DOCS = YES
+
573 
+
574 # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+
575 # (brief and detailed) documentation of class members so that constructors and
+
576 # destructors are listed first. If set to NO the constructors will appear in the
+
577 # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+
578 # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+
579 # member documentation.
+
580 # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+
581 # detailed member documentation.
+
582 # The default value is: NO.
+
583 
+
584 SORT_MEMBERS_CTORS_1ST = NO
+
585 
+
586 # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+
587 # of group names into alphabetical order. If set to NO the group names will
+
588 # appear in their defined order.
+
589 # The default value is: NO.
+
590 
+
591 SORT_GROUP_NAMES = NO
+
592 
+
593 # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+
594 # fully-qualified names, including namespaces. If set to NO, the class list will
+
595 # be sorted only by class name, not including the namespace part.
+
596 # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+
597 # Note: This option applies only to the class list, not to the alphabetical
+
598 # list.
+
599 # The default value is: NO.
+
600 
+
601 SORT_BY_SCOPE_NAME = YES
+
602 
+
603 # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+
604 # type resolution of all parameters of a function it will reject a match between
+
605 # the prototype and the implementation of a member function even if there is
+
606 # only one candidate or it is obvious which candidate to choose by doing a
+
607 # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+
608 # accept a match between prototype and implementation in such cases.
+
609 # The default value is: NO.
+
610 
+
611 STRICT_PROTO_MATCHING = NO
+
612 
+
613 # The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+
614 # list. This list is created by putting \todo commands in the documentation.
+
615 # The default value is: YES.
+
616 
+
617 GENERATE_TODOLIST = YES
+
618 
+
619 # The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+
620 # list. This list is created by putting \test commands in the documentation.
+
621 # The default value is: YES.
+
622 
+
623 GENERATE_TESTLIST = YES
+
624 
+
625 # The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+
626 # list. This list is created by putting \bug commands in the documentation.
+
627 # The default value is: YES.
+
628 
+
629 GENERATE_BUGLIST = YES
+
630 
+
631 # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+
632 # the deprecated list. This list is created by putting \deprecated commands in
+
633 # the documentation.
+
634 # The default value is: YES.
+
635 
+
636 GENERATE_DEPRECATEDLIST= YES
+
637 
+
638 # The ENABLED_SECTIONS tag can be used to enable conditional documentation
+
639 # sections, marked by \if <section_label> ... \endif and \cond <section_label>
+
640 # ... \endcond blocks.
+
641 
+
642 ENABLED_SECTIONS =
+
643 
+
644 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+
645 # initial value of a variable or macro / define can have for it to appear in the
+
646 # documentation. If the initializer consists of more lines than specified here
+
647 # it will be hidden. Use a value of 0 to hide initializers completely. The
+
648 # appearance of the value of individual variables and macros / defines can be
+
649 # controlled using \showinitializer or \hideinitializer command in the
+
650 # documentation regardless of this setting.
+
651 # Minimum value: 0, maximum value: 10000, default value: 30.
+
652 
+
653 MAX_INITIALIZER_LINES = 30
+
654 
+
655 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+
656 # the bottom of the documentation of classes and structs. If set to YES, the
+
657 # list will mention the files that were used to generate the documentation.
+
658 # The default value is: YES.
+
659 
+
660 SHOW_USED_FILES = NO
+
661 
+
662 # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+
663 # will remove the Files entry from the Quick Index and from the Folder Tree View
+
664 # (if specified).
+
665 # The default value is: YES.
+
666 
+
667 SHOW_FILES = YES
+
668 
+
669 # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+
670 # page. This will remove the Namespaces entry from the Quick Index and from the
+
671 # Folder Tree View (if specified).
+
672 # The default value is: YES.
+
673 
+
674 SHOW_NAMESPACES = YES
+
675 
+
676 # The FILE_VERSION_FILTER tag can be used to specify a program or script that
+
677 # doxygen should invoke to get the current version for each file (typically from
+
678 # the version control system). Doxygen will invoke the program by executing (via
+
679 # popen()) the command command input-file, where command is the value of the
+
680 # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+
681 # by doxygen. Whatever the program writes to standard output is used as the file
+
682 # version. For an example see the documentation.
+
683 
+
684 FILE_VERSION_FILTER =
+
685 
+
686 # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+
687 # by doxygen. The layout file controls the global structure of the generated
+
688 # output files in an output format independent way. To create the layout file
+
689 # that represents doxygen's defaults, run doxygen with the -l option. You can
+
690 # optionally specify a file name after the option, if omitted DoxygenLayout.xml
+
691 # will be used as the name of the layout file.
+
692 #
+
693 # Note that if you run doxygen from a directory containing a file called
+
694 # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+
695 # tag is left empty.
+
696 
+
697 LAYOUT_FILE =
+
698 
+
699 # The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+
700 # the reference definitions. This must be a list of .bib files. The .bib
+
701 # extension is automatically appended if omitted. This requires the bibtex tool
+
702 # to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+
703 # For LaTeX the style of the bibliography can be controlled using
+
704 # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+
705 # search path. See also \cite for info how to create references.
+
706 
+
707 CITE_BIB_FILES =
+
708 
+
709 #---------------------------------------------------------------------------
+
710 # Configuration options related to warning and progress messages
+
711 #---------------------------------------------------------------------------
+
712 
+
713 # The QUIET tag can be used to turn on/off the messages that are generated to
+
714 # standard output by doxygen. If QUIET is set to YES this implies that the
+
715 # messages are off.
+
716 # The default value is: NO.
+
717 
+
718 QUIET = NO
+
719 
+
720 # The WARNINGS tag can be used to turn on/off the warning messages that are
+
721 # generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+
722 # this implies that the warnings are on.
+
723 #
+
724 # Tip: Turn warnings on while writing the documentation.
+
725 # The default value is: YES.
+
726 
+
727 WARNINGS = YES
+
728 
+
729 # If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+
730 # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+
731 # will automatically be disabled.
+
732 # The default value is: YES.
+
733 
+
734 WARN_IF_UNDOCUMENTED = YES
+
735 
+
736 # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+
737 # potential errors in the documentation, such as not documenting some parameters
+
738 # in a documented function, or documenting parameters that don't exist or using
+
739 # markup commands wrongly.
+
740 # The default value is: YES.
+
741 
+
742 WARN_IF_DOC_ERROR = YES
+
743 
+
744 # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+
745 # are documented, but have no documentation for their parameters or return
+
746 # value. If set to NO, doxygen will only warn about wrong or incomplete
+
747 # parameter documentation, but not about the absence of documentation.
+
748 # The default value is: NO.
+
749 
+
750 WARN_NO_PARAMDOC = NO
+
751 
+
752 # The WARN_FORMAT tag determines the format of the warning messages that doxygen
+
753 # can produce. The string should contain the $file, $line, and $text tags, which
+
754 # will be replaced by the file and line number from which the warning originated
+
755 # and the warning text. Optionally the format may contain $version, which will
+
756 # be replaced by the version of the file (if it could be obtained via
+
757 # FILE_VERSION_FILTER)
+
758 # The default value is: $file:$line: $text.
+
759 
+
760 WARN_FORMAT = "$file:$line: $text"
+
761 
+
762 # The WARN_LOGFILE tag can be used to specify a file to which warning and error
+
763 # messages should be written. If left blank the output is written to standard
+
764 # error (stderr).
+
765 
+
766 WARN_LOGFILE =
+
767 
+
768 #---------------------------------------------------------------------------
+
769 # Configuration options related to the input files
+
770 #---------------------------------------------------------------------------
+
771 
+
772 # The INPUT tag is used to specify the files and/or directories that contain
+
773 # documented source files. You may enter file names like myfile.cpp or
+
774 # directories like /usr/src/myproject. Separate the files or directories with
+
775 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+
776 # Note: If this tag is empty the current directory is searched.
+
777 
+
778 INPUT = ../glm \
+
779  .
+
780 
+
781 # This tag can be used to specify the character encoding of the source files
+
782 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+
783 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+
784 # documentation (see: http://www.gnu.org/software/libiconv) for the list of
+
785 # possible encodings.
+
786 # The default value is: UTF-8.
+
787 
+
788 INPUT_ENCODING = UTF-8
+
789 
+
790 # If the value of the INPUT tag contains directories, you can use the
+
791 # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+
792 # *.h) to filter out the source-files in the directories.
+
793 #
+
794 # Note that for custom extensions or not directly supported extensions you also
+
795 # need to set EXTENSION_MAPPING for the extension otherwise the files are not
+
796 # read by doxygen.
+
797 #
+
798 # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+
799 # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+
800 # *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+
801 # *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd,
+
802 # *.vhdl, *.ucf, *.qsf, *.as and *.js.
+
803 
+
804 FILE_PATTERNS = *.hpp \
+
805  *.doxy
+
806 
+
807 # The RECURSIVE tag can be used to specify whether or not subdirectories should
+
808 # be searched for input files as well.
+
809 # The default value is: NO.
+
810 
+
811 RECURSIVE = YES
+
812 
+
813 # The EXCLUDE tag can be used to specify files and/or directories that should be
+
814 # excluded from the INPUT source files. This way you can easily exclude a
+
815 # subdirectory from a directory tree whose root is specified with the INPUT tag.
+
816 #
+
817 # Note that relative paths are relative to the directory from which doxygen is
+
818 # run.
+
819 
+
820 EXCLUDE =
+
821 
+
822 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+
823 # directories that are symbolic links (a Unix file system feature) are excluded
+
824 # from the input.
+
825 # The default value is: NO.
+
826 
+
827 EXCLUDE_SYMLINKS = NO
+
828 
+
829 # If the value of the INPUT tag contains directories, you can use the
+
830 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+
831 # certain files from those directories.
+
832 #
+
833 # Note that the wildcards are matched against the file with absolute path, so to
+
834 # exclude all test directories for example use the pattern */test/*
+
835 
+
836 EXCLUDE_PATTERNS =
+
837 
+
838 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+
839 # (namespaces, classes, functions, etc.) that should be excluded from the
+
840 # output. The symbol name can be a fully qualified name, a word, or if the
+
841 # wildcard * is used, a substring. Examples: ANamespace, AClass,
+
842 # AClass::ANamespace, ANamespace::*Test
+
843 #
+
844 # Note that the wildcards are matched against the file with absolute path, so to
+
845 # exclude all test directories use the pattern */test/*
+
846 
+
847 EXCLUDE_SYMBOLS =
+
848 
+
849 # The EXAMPLE_PATH tag can be used to specify one or more files or directories
+
850 # that contain example code fragments that are included (see the \include
+
851 # command).
+
852 
+
853 EXAMPLE_PATH =
+
854 
+
855 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
+
856 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+
857 # *.h) to filter out the source-files in the directories. If left blank all
+
858 # files are included.
+
859 
+
860 EXAMPLE_PATTERNS = *
+
861 
+
862 # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+
863 # searched for input files to be used with the \include or \dontinclude commands
+
864 # irrespective of the value of the RECURSIVE tag.
+
865 # The default value is: NO.
+
866 
+
867 EXAMPLE_RECURSIVE = NO
+
868 
+
869 # The IMAGE_PATH tag can be used to specify one or more files or directories
+
870 # that contain images that are to be included in the documentation (see the
+
871 # \image command).
+
872 
+
873 IMAGE_PATH =
+
874 
+
875 # The INPUT_FILTER tag can be used to specify a program that doxygen should
+
876 # invoke to filter for each input file. Doxygen will invoke the filter program
+
877 # by executing (via popen()) the command:
+
878 #
+
879 # <filter> <input-file>
+
880 #
+
881 # where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+
882 # name of an input file. Doxygen will then use the output that the filter
+
883 # program writes to standard output. If FILTER_PATTERNS is specified, this tag
+
884 # will be ignored.
+
885 #
+
886 # Note that the filter must not add or remove lines; it is applied before the
+
887 # code is scanned, but not when the output code is generated. If lines are added
+
888 # or removed, the anchors will not be placed correctly.
+
889 
+
890 INPUT_FILTER =
+
891 
+
892 # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+
893 # basis. Doxygen will compare the file name with each pattern and apply the
+
894 # filter if there is a match. The filters are a list of the form: pattern=filter
+
895 # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+
896 # filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+
897 # patterns match the file name, INPUT_FILTER is applied.
+
898 
+
899 FILTER_PATTERNS =
+
900 
+
901 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+
902 # INPUT_FILTER) will also be used to filter the input files that are used for
+
903 # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
904 # The default value is: NO.
+
905 
+
906 FILTER_SOURCE_FILES = NO
+
907 
+
908 # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+
909 # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+
910 # it is also possible to disable source filtering for a specific pattern using
+
911 # *.ext= (so without naming a filter).
+
912 # This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
913 
+
914 FILTER_SOURCE_PATTERNS =
+
915 
+
916 # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+
917 # is part of the input, its contents will be placed on the main page
+
918 # (index.html). This can be useful if you have a project on for instance GitHub
+
919 # and want to reuse the introduction page also for the doxygen output.
+
920 
+
921 USE_MDFILE_AS_MAINPAGE =
+
922 
+
923 #---------------------------------------------------------------------------
+
924 # Configuration options related to source browsing
+
925 #---------------------------------------------------------------------------
+
926 
+
927 # If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+
928 # generated. Documented entities will be cross-referenced with these sources.
+
929 #
+
930 # Note: To get rid of all source code in the generated output, make sure that
+
931 # also VERBATIM_HEADERS is set to NO.
+
932 # The default value is: NO.
+
933 
+
934 SOURCE_BROWSER = YES
+
935 
+
936 # Setting the INLINE_SOURCES tag to YES will include the body of functions,
+
937 # classes and enums directly into the documentation.
+
938 # The default value is: NO.
+
939 
+
940 INLINE_SOURCES = NO
+
941 
+
942 # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+
943 # special comment blocks from generated source code fragments. Normal C, C++ and
+
944 # Fortran comments will always remain visible.
+
945 # The default value is: YES.
+
946 
+
947 STRIP_CODE_COMMENTS = YES
+
948 
+
949 # If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+
950 # function all documented functions referencing it will be listed.
+
951 # The default value is: NO.
+
952 
+
953 REFERENCED_BY_RELATION = YES
+
954 
+
955 # If the REFERENCES_RELATION tag is set to YES then for each documented function
+
956 # all documented entities called/used by that function will be listed.
+
957 # The default value is: NO.
+
958 
+
959 REFERENCES_RELATION = YES
+
960 
+
961 # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+
962 # to YES then the hyperlinks from functions in REFERENCES_RELATION and
+
963 # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+
964 # link to the documentation.
+
965 # The default value is: YES.
+
966 
+
967 REFERENCES_LINK_SOURCE = YES
+
968 
+
969 # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+
970 # source code will show a tooltip with additional information such as prototype,
+
971 # brief description and links to the definition and documentation. Since this
+
972 # will make the HTML file larger and loading of large files a bit slower, you
+
973 # can opt to disable this feature.
+
974 # The default value is: YES.
+
975 # This tag requires that the tag SOURCE_BROWSER is set to YES.
+
976 
+
977 SOURCE_TOOLTIPS = YES
+
978 
+
979 # If the USE_HTAGS tag is set to YES then the references to source code will
+
980 # point to the HTML generated by the htags(1) tool instead of doxygen built-in
+
981 # source browser. The htags tool is part of GNU's global source tagging system
+
982 # (see http://www.gnu.org/software/global/global.html). You will need version
+
983 # 4.8.6 or higher.
+
984 #
+
985 # To use it do the following:
+
986 # - Install the latest version of global
+
987 # - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+
988 # - Make sure the INPUT points to the root of the source tree
+
989 # - Run doxygen as normal
+
990 #
+
991 # Doxygen will invoke htags (and that will in turn invoke gtags), so these
+
992 # tools must be available from the command line (i.e. in the search path).
+
993 #
+
994 # The result: instead of the source browser generated by doxygen, the links to
+
995 # source code will now point to the output of htags.
+
996 # The default value is: NO.
+
997 # This tag requires that the tag SOURCE_BROWSER is set to YES.
+
998 
+
999 USE_HTAGS = NO
+
1000 
+
1001 # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+
1002 # verbatim copy of the header file for each class for which an include is
+
1003 # specified. Set to NO to disable this.
+
1004 # See also: Section \class.
+
1005 # The default value is: YES.
+
1006 
+
1007 VERBATIM_HEADERS = YES
+
1008 
+
1009 # If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+
1010 # clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
+
1011 # cost of reduced performance. This can be particularly helpful with template
+
1012 # rich C++ code for which doxygen's built-in parser lacks the necessary type
+
1013 # information.
+
1014 # Note: The availability of this option depends on whether or not doxygen was
+
1015 # compiled with the --with-libclang option.
+
1016 # The default value is: NO.
+
1017 
+
1018 CLANG_ASSISTED_PARSING = NO
+
1019 
+
1020 # If clang assisted parsing is enabled you can provide the compiler with command
+
1021 # line options that you would normally use when invoking the compiler. Note that
+
1022 # the include paths will already be set by doxygen for the files and directories
+
1023 # specified with INPUT and INCLUDE_PATH.
+
1024 # This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
1025 
+
1026 CLANG_OPTIONS =
+
1027 
+
1028 #---------------------------------------------------------------------------
+
1029 # Configuration options related to the alphabetical class index
+
1030 #---------------------------------------------------------------------------
+
1031 
+
1032 # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+
1033 # compounds will be generated. Enable this if the project contains a lot of
+
1034 # classes, structs, unions or interfaces.
+
1035 # The default value is: YES.
+
1036 
+
1037 ALPHABETICAL_INDEX = NO
+
1038 
+
1039 # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+
1040 # which the alphabetical index list will be split.
+
1041 # Minimum value: 1, maximum value: 20, default value: 5.
+
1042 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
1043 
+
1044 COLS_IN_ALPHA_INDEX = 5
+
1045 
+
1046 # In case all classes in a project start with a common prefix, all classes will
+
1047 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+
1048 # can be used to specify a prefix (or a list of prefixes) that should be ignored
+
1049 # while generating the index headers.
+
1050 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
1051 
+
1052 IGNORE_PREFIX =
+
1053 
+
1054 #---------------------------------------------------------------------------
+
1055 # Configuration options related to the HTML output
+
1056 #---------------------------------------------------------------------------
+
1057 
+
1058 # If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+
1059 # The default value is: YES.
+
1060 
+
1061 GENERATE_HTML = YES
+
1062 
+
1063 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+
1064 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+
1065 # it.
+
1066 # The default directory is: html.
+
1067 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1068 
+
1069 HTML_OUTPUT = html
+
1070 
+
1071 # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+
1072 # generated HTML page (for example: .htm, .php, .asp).
+
1073 # The default value is: .html.
+
1074 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1075 
+
1076 HTML_FILE_EXTENSION = .html
+
1077 
+
1078 # The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+
1079 # each generated HTML page. If the tag is left blank doxygen will generate a
+
1080 # standard header.
+
1081 #
+
1082 # To get valid HTML the header file that includes any scripts and style sheets
+
1083 # that doxygen needs, which is dependent on the configuration options used (e.g.
+
1084 # the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+
1085 # default header using
+
1086 # doxygen -w html new_header.html new_footer.html new_stylesheet.css
+
1087 # YourConfigFile
+
1088 # and then modify the file new_header.html. See also section "Doxygen usage"
+
1089 # for information on how to generate the default header that doxygen normally
+
1090 # uses.
+
1091 # Note: The header is subject to change so you typically have to regenerate the
+
1092 # default header when upgrading to a newer version of doxygen. For a description
+
1093 # of the possible markers and block names see the documentation.
+
1094 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1095 
+
1096 HTML_HEADER =
+
1097 
+
1098 # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+
1099 # generated HTML page. If the tag is left blank doxygen will generate a standard
+
1100 # footer. See HTML_HEADER for more information on how to generate a default
+
1101 # footer and what special commands can be used inside the footer. See also
+
1102 # section "Doxygen usage" for information on how to generate the default footer
+
1103 # that doxygen normally uses.
+
1104 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1105 
+
1106 HTML_FOOTER =
+
1107 
+
1108 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+
1109 # sheet that is used by each HTML page. It can be used to fine-tune the look of
+
1110 # the HTML output. If left blank doxygen will generate a default style sheet.
+
1111 # See also section "Doxygen usage" for information on how to generate the style
+
1112 # sheet that doxygen normally uses.
+
1113 # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+
1114 # it is more robust and this tag (HTML_STYLESHEET) will in the future become
+
1115 # obsolete.
+
1116 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1117 
+
1118 HTML_STYLESHEET =
+
1119 
+
1120 # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+
1121 # cascading style sheets that are included after the standard style sheets
+
1122 # created by doxygen. Using this option one can overrule certain style aspects.
+
1123 # This is preferred over using HTML_STYLESHEET since it does not replace the
+
1124 # standard style sheet and is therefore more robust against future updates.
+
1125 # Doxygen will copy the style sheet files to the output directory.
+
1126 # Note: The order of the extra style sheet files is of importance (e.g. the last
+
1127 # style sheet in the list overrules the setting of the previous ones in the
+
1128 # list). For an example see the documentation.
+
1129 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1130 
+
1131 HTML_EXTRA_STYLESHEET =
+
1132 
+
1133 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+
1134 # other source files which should be copied to the HTML output directory. Note
+
1135 # that these files will be copied to the base HTML output directory. Use the
+
1136 # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+
1137 # files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+
1138 # files will be copied as-is; there are no commands or markers available.
+
1139 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1140 
+
1141 HTML_EXTRA_FILES =
+
1142 
+
1143 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+
1144 # will adjust the colors in the style sheet and background images according to
+
1145 # this color. Hue is specified as an angle on a colorwheel, see
+
1146 # http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+
1147 # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+
1148 # purple, and 360 is red again.
+
1149 # Minimum value: 0, maximum value: 359, default value: 220.
+
1150 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1151 
+
1152 HTML_COLORSTYLE_HUE = 220
+
1153 
+
1154 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+
1155 # in the HTML output. For a value of 0 the output will use grayscales only. A
+
1156 # value of 255 will produce the most vivid colors.
+
1157 # Minimum value: 0, maximum value: 255, default value: 100.
+
1158 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1159 
+
1160 HTML_COLORSTYLE_SAT = 100
+
1161 
+
1162 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+
1163 # luminance component of the colors in the HTML output. Values below 100
+
1164 # gradually make the output lighter, whereas values above 100 make the output
+
1165 # darker. The value divided by 100 is the actual gamma applied, so 80 represents
+
1166 # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+
1167 # change the gamma.
+
1168 # Minimum value: 40, maximum value: 240, default value: 80.
+
1169 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1170 
+
1171 HTML_COLORSTYLE_GAMMA = 80
+
1172 
+
1173 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+
1174 # page will contain the date and time when the page was generated. Setting this
+
1175 # to YES can help to show when doxygen was last run and thus if the
+
1176 # documentation is up to date.
+
1177 # The default value is: NO.
+
1178 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1179 
+
1180 HTML_TIMESTAMP = NO
+
1181 
+
1182 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+
1183 # documentation will contain sections that can be hidden and shown after the
+
1184 # page has loaded.
+
1185 # The default value is: NO.
+
1186 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1187 
+
1188 HTML_DYNAMIC_SECTIONS = NO
+
1189 
+
1190 # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+
1191 # shown in the various tree structured indices initially; the user can expand
+
1192 # and collapse entries dynamically later on. Doxygen will expand the tree to
+
1193 # such a level that at most the specified number of entries are visible (unless
+
1194 # a fully collapsed tree already exceeds this amount). So setting the number of
+
1195 # entries 1 will produce a full collapsed tree by default. 0 is a special value
+
1196 # representing an infinite number of entries and will result in a full expanded
+
1197 # tree by default.
+
1198 # Minimum value: 0, maximum value: 9999, default value: 100.
+
1199 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1200 
+
1201 HTML_INDEX_NUM_ENTRIES = 100
+
1202 
+
1203 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
+
1204 # generated that can be used as input for Apple's Xcode 3 integrated development
+
1205 # environment (see: http://developer.apple.com/tools/xcode/), introduced with
+
1206 # OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
+
1207 # Makefile in the HTML output directory. Running make will produce the docset in
+
1208 # that directory and running make install will install the docset in
+
1209 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+
1210 # startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+
1211 # for more information.
+
1212 # The default value is: NO.
+
1213 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1214 
+
1215 GENERATE_DOCSET = NO
+
1216 
+
1217 # This tag determines the name of the docset feed. A documentation feed provides
+
1218 # an umbrella under which multiple documentation sets from a single provider
+
1219 # (such as a company or product suite) can be grouped.
+
1220 # The default value is: Doxygen generated docs.
+
1221 # This tag requires that the tag GENERATE_DOCSET is set to YES.
+
1222 
+
1223 DOCSET_FEEDNAME = "Doxygen generated docs"
+
1224 
+
1225 # This tag specifies a string that should uniquely identify the documentation
+
1226 # set bundle. This should be a reverse domain-name style string, e.g.
+
1227 # com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+
1228 # The default value is: org.doxygen.Project.
+
1229 # This tag requires that the tag GENERATE_DOCSET is set to YES.
+
1230 
+
1231 DOCSET_BUNDLE_ID = org.doxygen.Project
+
1232 
+
1233 # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+
1234 # the documentation publisher. This should be a reverse domain-name style
+
1235 # string, e.g. com.mycompany.MyDocSet.documentation.
+
1236 # The default value is: org.doxygen.Publisher.
+
1237 # This tag requires that the tag GENERATE_DOCSET is set to YES.
+
1238 
+
1239 DOCSET_PUBLISHER_ID = org.doxygen.Publisher
+
1240 
+
1241 # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+
1242 # The default value is: Publisher.
+
1243 # This tag requires that the tag GENERATE_DOCSET is set to YES.
+
1244 
+
1245 DOCSET_PUBLISHER_NAME = Publisher
+
1246 
+
1247 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+
1248 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+
1249 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+
1250 # (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
+
1251 # Windows.
+
1252 #
+
1253 # The HTML Help Workshop contains a compiler that can convert all HTML output
+
1254 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+
1255 # files are now used as the Windows 98 help format, and will replace the old
+
1256 # Windows help format (.hlp) on all Windows platforms in the future. Compressed
+
1257 # HTML files also contain an index, a table of contents, and you can search for
+
1258 # words in the documentation. The HTML workshop also contains a viewer for
+
1259 # compressed HTML files.
+
1260 # The default value is: NO.
+
1261 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1262 
+
1263 GENERATE_HTMLHELP = NO
+
1264 
+
1265 # The CHM_FILE tag can be used to specify the file name of the resulting .chm
+
1266 # file. You can add a path in front of the file if the result should not be
+
1267 # written to the html output directory.
+
1268 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
1269 
+
1270 CHM_FILE =
+
1271 
+
1272 # The HHC_LOCATION tag can be used to specify the location (absolute path
+
1273 # including file name) of the HTML help compiler (hhc.exe). If non-empty,
+
1274 # doxygen will try to run the HTML help compiler on the generated index.hhp.
+
1275 # The file has to be specified with full path.
+
1276 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
1277 
+
1278 HHC_LOCATION =
+
1279 
+
1280 # The GENERATE_CHI flag controls if a separate .chi index file is generated
+
1281 # (YES) or that it should be included in the master .chm file (NO).
+
1282 # The default value is: NO.
+
1283 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
1284 
+
1285 GENERATE_CHI = NO
+
1286 
+
1287 # The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+
1288 # and project file content.
+
1289 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
1290 
+
1291 CHM_INDEX_ENCODING =
+
1292 
+
1293 # The BINARY_TOC flag controls whether a binary table of contents is generated
+
1294 # (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+
1295 # enables the Previous and Next buttons.
+
1296 # The default value is: NO.
+
1297 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
1298 
+
1299 BINARY_TOC = NO
+
1300 
+
1301 # The TOC_EXPAND flag can be set to YES to add extra items for group members to
+
1302 # the table of contents of the HTML help documentation and to the tree view.
+
1303 # The default value is: NO.
+
1304 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
1305 
+
1306 TOC_EXPAND = NO
+
1307 
+
1308 # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+
1309 # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+
1310 # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+
1311 # (.qch) of the generated HTML documentation.
+
1312 # The default value is: NO.
+
1313 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1314 
+
1315 GENERATE_QHP = NO
+
1316 
+
1317 # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+
1318 # the file name of the resulting .qch file. The path specified is relative to
+
1319 # the HTML output folder.
+
1320 # This tag requires that the tag GENERATE_QHP is set to YES.
+
1321 
+
1322 QCH_FILE =
+
1323 
+
1324 # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+
1325 # Project output. For more information please see Qt Help Project / Namespace
+
1326 # (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+
1327 # The default value is: org.doxygen.Project.
+
1328 # This tag requires that the tag GENERATE_QHP is set to YES.
+
1329 
+
1330 QHP_NAMESPACE = org.doxygen.Project
+
1331 
+
1332 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+
1333 # Help Project output. For more information please see Qt Help Project / Virtual
+
1334 # Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
+
1335 # folders).
+
1336 # The default value is: doc.
+
1337 # This tag requires that the tag GENERATE_QHP is set to YES.
+
1338 
+
1339 QHP_VIRTUAL_FOLDER = doc
+
1340 
+
1341 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+
1342 # filter to add. For more information please see Qt Help Project / Custom
+
1343 # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+
1344 # filters).
+
1345 # This tag requires that the tag GENERATE_QHP is set to YES.
+
1346 
+
1347 QHP_CUST_FILTER_NAME =
+
1348 
+
1349 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+
1350 # custom filter to add. For more information please see Qt Help Project / Custom
+
1351 # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+
1352 # filters).
+
1353 # This tag requires that the tag GENERATE_QHP is set to YES.
+
1354 
+
1355 QHP_CUST_FILTER_ATTRS =
+
1356 
+
1357 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+
1358 # project's filter section matches. Qt Help Project / Filter Attributes (see:
+
1359 # http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+
1360 # This tag requires that the tag GENERATE_QHP is set to YES.
+
1361 
+
1362 QHP_SECT_FILTER_ATTRS =
+
1363 
+
1364 # The QHG_LOCATION tag can be used to specify the location of Qt's
+
1365 # qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
+
1366 # generated .qhp file.
+
1367 # This tag requires that the tag GENERATE_QHP is set to YES.
+
1368 
+
1369 QHG_LOCATION =
+
1370 
+
1371 # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+
1372 # generated, together with the HTML files, they form an Eclipse help plugin. To
+
1373 # install this plugin and make it available under the help contents menu in
+
1374 # Eclipse, the contents of the directory containing the HTML and XML files needs
+
1375 # to be copied into the plugins directory of eclipse. The name of the directory
+
1376 # within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+
1377 # After copying Eclipse needs to be restarted before the help appears.
+
1378 # The default value is: NO.
+
1379 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1380 
+
1381 GENERATE_ECLIPSEHELP = NO
+
1382 
+
1383 # A unique identifier for the Eclipse help plugin. When installing the plugin
+
1384 # the directory name containing the HTML and XML files should also have this
+
1385 # name. Each documentation set should have its own identifier.
+
1386 # The default value is: org.doxygen.Project.
+
1387 # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
1388 
+
1389 ECLIPSE_DOC_ID = org.doxygen.Project
+
1390 
+
1391 # If you want full control over the layout of the generated HTML pages it might
+
1392 # be necessary to disable the index and replace it with your own. The
+
1393 # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+
1394 # of each HTML page. A value of NO enables the index and the value YES disables
+
1395 # it. Since the tabs in the index contain the same information as the navigation
+
1396 # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+
1397 # The default value is: NO.
+
1398 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1399 
+
1400 DISABLE_INDEX = NO
+
1401 
+
1402 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+
1403 # structure should be generated to display hierarchical information. If the tag
+
1404 # value is set to YES, a side panel will be generated containing a tree-like
+
1405 # index structure (just like the one that is generated for HTML Help). For this
+
1406 # to work a browser that supports JavaScript, DHTML, CSS and frames is required
+
1407 # (i.e. any modern browser). Windows users are probably better off using the
+
1408 # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+
1409 # further fine-tune the look of the index. As an example, the default style
+
1410 # sheet generated by doxygen has an example that shows how to put an image at
+
1411 # the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+
1412 # the same information as the tab index, you could consider setting
+
1413 # DISABLE_INDEX to YES when enabling this option.
+
1414 # The default value is: NO.
+
1415 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1416 
+
1417 GENERATE_TREEVIEW = NO
+
1418 
+
1419 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+
1420 # doxygen will group on one line in the generated HTML documentation.
+
1421 #
+
1422 # Note that a value of 0 will completely suppress the enum values from appearing
+
1423 # in the overview section.
+
1424 # Minimum value: 0, maximum value: 20, default value: 4.
+
1425 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1426 
+
1427 ENUM_VALUES_PER_LINE = 4
+
1428 
+
1429 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+
1430 # to set the initial width (in pixels) of the frame in which the tree is shown.
+
1431 # Minimum value: 0, maximum value: 1500, default value: 250.
+
1432 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1433 
+
1434 TREEVIEW_WIDTH = 250
+
1435 
+
1436 # If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+
1437 # external symbols imported via tag files in a separate window.
+
1438 # The default value is: NO.
+
1439 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1440 
+
1441 EXT_LINKS_IN_WINDOW = NO
+
1442 
+
1443 # Use this tag to change the font size of LaTeX formulas included as images in
+
1444 # the HTML documentation. When you change the font size after a successful
+
1445 # doxygen run you need to manually remove any form_*.png images from the HTML
+
1446 # output directory to force them to be regenerated.
+
1447 # Minimum value: 8, maximum value: 50, default value: 10.
+
1448 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1449 
+
1450 FORMULA_FONTSIZE = 10
+
1451 
+
1452 # Use the FORMULA_TRANPARENT tag to determine whether or not the images
+
1453 # generated for formulas are transparent PNGs. Transparent PNGs are not
+
1454 # supported properly for IE 6.0, but are supported on all modern browsers.
+
1455 #
+
1456 # Note that when changing this option you need to delete any form_*.png files in
+
1457 # the HTML output directory before the changes have effect.
+
1458 # The default value is: YES.
+
1459 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1460 
+
1461 FORMULA_TRANSPARENT = YES
+
1462 
+
1463 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+
1464 # http://www.mathjax.org) which uses client side Javascript for the rendering
+
1465 # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+
1466 # installed or if you want to formulas look prettier in the HTML output. When
+
1467 # enabled you may also need to install MathJax separately and configure the path
+
1468 # to it using the MATHJAX_RELPATH option.
+
1469 # The default value is: NO.
+
1470 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1471 
+
1472 USE_MATHJAX = NO
+
1473 
+
1474 # When MathJax is enabled you can set the default output format to be used for
+
1475 # the MathJax output. See the MathJax site (see:
+
1476 # http://docs.mathjax.org/en/latest/output.html) for more details.
+
1477 # Possible values are: HTML-CSS (which is slower, but has the best
+
1478 # compatibility), NativeMML (i.e. MathML) and SVG.
+
1479 # The default value is: HTML-CSS.
+
1480 # This tag requires that the tag USE_MATHJAX is set to YES.
+
1481 
+
1482 MATHJAX_FORMAT = HTML-CSS
+
1483 
+
1484 # When MathJax is enabled you need to specify the location relative to the HTML
+
1485 # output directory using the MATHJAX_RELPATH option. The destination directory
+
1486 # should contain the MathJax.js script. For instance, if the mathjax directory
+
1487 # is located at the same level as the HTML output directory, then
+
1488 # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+
1489 # Content Delivery Network so you can quickly see the result without installing
+
1490 # MathJax. However, it is strongly recommended to install a local copy of
+
1491 # MathJax from http://www.mathjax.org before deployment.
+
1492 # The default value is: http://cdn.mathjax.org/mathjax/latest.
+
1493 # This tag requires that the tag USE_MATHJAX is set to YES.
+
1494 
+
1495 MATHJAX_RELPATH = http://www.mathjax.org/mathjax
+
1496 
+
1497 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+
1498 # extension names that should be enabled during MathJax rendering. For example
+
1499 # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+
1500 # This tag requires that the tag USE_MATHJAX is set to YES.
+
1501 
+
1502 MATHJAX_EXTENSIONS =
+
1503 
+
1504 # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+
1505 # of code that will be used on startup of the MathJax code. See the MathJax site
+
1506 # (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+
1507 # example see the documentation.
+
1508 # This tag requires that the tag USE_MATHJAX is set to YES.
+
1509 
+
1510 MATHJAX_CODEFILE =
+
1511 
+
1512 # When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+
1513 # the HTML output. The underlying search engine uses javascript and DHTML and
+
1514 # should work on any modern browser. Note that when using HTML help
+
1515 # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+
1516 # there is already a search function so this one should typically be disabled.
+
1517 # For large projects the javascript based search engine can be slow, then
+
1518 # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+
1519 # search using the keyboard; to jump to the search box use <access key> + S
+
1520 # (what the <access key> is depends on the OS and browser, but it is typically
+
1521 # <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+
1522 # key> to jump into the search results window, the results can be navigated
+
1523 # using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+
1524 # the search. The filter options can be selected when the cursor is inside the
+
1525 # search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+
1526 # to select a filter and <Enter> or <escape> to activate or cancel the filter
+
1527 # option.
+
1528 # The default value is: YES.
+
1529 # This tag requires that the tag GENERATE_HTML is set to YES.
+
1530 
+
1531 SEARCHENGINE = YES
+
1532 
+
1533 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+
1534 # implemented using a web server instead of a web client using Javascript. There
+
1535 # are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+
1536 # setting. When disabled, doxygen will generate a PHP script for searching and
+
1537 # an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+
1538 # and searching needs to be provided by external tools. See the section
+
1539 # "External Indexing and Searching" for details.
+
1540 # The default value is: NO.
+
1541 # This tag requires that the tag SEARCHENGINE is set to YES.
+
1542 
+
1543 SERVER_BASED_SEARCH = NO
+
1544 
+
1545 # When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+
1546 # script for searching. Instead the search results are written to an XML file
+
1547 # which needs to be processed by an external indexer. Doxygen will invoke an
+
1548 # external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+
1549 # search results.
+
1550 #
+
1551 # Doxygen ships with an example indexer (doxyindexer) and search engine
+
1552 # (doxysearch.cgi) which are based on the open source search engine library
+
1553 # Xapian (see: http://xapian.org/).
+
1554 #
+
1555 # See the section "External Indexing and Searching" for details.
+
1556 # The default value is: NO.
+
1557 # This tag requires that the tag SEARCHENGINE is set to YES.
+
1558 
+
1559 EXTERNAL_SEARCH = NO
+
1560 
+
1561 # The SEARCHENGINE_URL should point to a search engine hosted by a web server
+
1562 # which will return the search results when EXTERNAL_SEARCH is enabled.
+
1563 #
+
1564 # Doxygen ships with an example indexer (doxyindexer) and search engine
+
1565 # (doxysearch.cgi) which are based on the open source search engine library
+
1566 # Xapian (see: http://xapian.org/). See the section "External Indexing and
+
1567 # Searching" for details.
+
1568 # This tag requires that the tag SEARCHENGINE is set to YES.
+
1569 
+
1570 SEARCHENGINE_URL =
+
1571 
+
1572 # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+
1573 # search data is written to a file for indexing by an external tool. With the
+
1574 # SEARCHDATA_FILE tag the name of this file can be specified.
+
1575 # The default file is: searchdata.xml.
+
1576 # This tag requires that the tag SEARCHENGINE is set to YES.
+
1577 
+
1578 SEARCHDATA_FILE = searchdata.xml
+
1579 
+
1580 # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+
1581 # EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+
1582 # useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+
1583 # projects and redirect the results back to the right project.
+
1584 # This tag requires that the tag SEARCHENGINE is set to YES.
+
1585 
+
1586 EXTERNAL_SEARCH_ID =
+
1587 
+
1588 # The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+
1589 # projects other than the one defined by this configuration file, but that are
+
1590 # all added to the same external search index. Each project needs to have a
+
1591 # unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+
1592 # to a relative location where the documentation can be found. The format is:
+
1593 # EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+
1594 # This tag requires that the tag SEARCHENGINE is set to YES.
+
1595 
+
1596 EXTRA_SEARCH_MAPPINGS =
+
1597 
+
1598 #---------------------------------------------------------------------------
+
1599 # Configuration options related to the LaTeX output
+
1600 #---------------------------------------------------------------------------
+
1601 
+
1602 # If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+
1603 # The default value is: YES.
+
1604 
+
1605 GENERATE_LATEX = NO
+
1606 
+
1607 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+
1608 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+
1609 # it.
+
1610 # The default directory is: latex.
+
1611 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1612 
+
1613 LATEX_OUTPUT = latex
+
1614 
+
1615 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+
1616 # invoked.
+
1617 #
+
1618 # Note that when enabling USE_PDFLATEX this option is only used for generating
+
1619 # bitmaps for formulas in the HTML output, but not in the Makefile that is
+
1620 # written to the output directory.
+
1621 # The default file is: latex.
+
1622 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1623 
+
1624 LATEX_CMD_NAME = latex
+
1625 
+
1626 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+
1627 # index for LaTeX.
+
1628 # The default file is: makeindex.
+
1629 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1630 
+
1631 MAKEINDEX_CMD_NAME = makeindex
+
1632 
+
1633 # If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+
1634 # documents. This may be useful for small projects and may help to save some
+
1635 # trees in general.
+
1636 # The default value is: NO.
+
1637 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1638 
+
1639 COMPACT_LATEX = NO
+
1640 
+
1641 # The PAPER_TYPE tag can be used to set the paper type that is used by the
+
1642 # printer.
+
1643 # Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+
1644 # 14 inches) and executive (7.25 x 10.5 inches).
+
1645 # The default value is: a4.
+
1646 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1647 
+
1648 PAPER_TYPE = a4wide
+
1649 
+
1650 # The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+
1651 # that should be included in the LaTeX output. The package can be specified just
+
1652 # by its name or with the correct syntax as to be used with the LaTeX
+
1653 # \usepackage command. To get the times font for instance you can specify :
+
1654 # EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+
1655 # To use the option intlimits with the amsmath package you can specify:
+
1656 # EXTRA_PACKAGES=[intlimits]{amsmath}
+
1657 # If left blank no extra packages will be included.
+
1658 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1659 
+
1660 EXTRA_PACKAGES =
+
1661 
+
1662 # The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+
1663 # generated LaTeX document. The header should contain everything until the first
+
1664 # chapter. If it is left blank doxygen will generate a standard header. See
+
1665 # section "Doxygen usage" for information on how to let doxygen write the
+
1666 # default header to a separate file.
+
1667 #
+
1668 # Note: Only use a user-defined header if you know what you are doing! The
+
1669 # following commands have a special meaning inside the header: $title,
+
1670 # $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+
1671 # $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+
1672 # string, for the replacement values of the other commands the user is referred
+
1673 # to HTML_HEADER.
+
1674 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1675 
+
1676 LATEX_HEADER =
+
1677 
+
1678 # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+
1679 # generated LaTeX document. The footer should contain everything after the last
+
1680 # chapter. If it is left blank doxygen will generate a standard footer. See
+
1681 # LATEX_HEADER for more information on how to generate a default footer and what
+
1682 # special commands can be used inside the footer.
+
1683 #
+
1684 # Note: Only use a user-defined footer if you know what you are doing!
+
1685 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1686 
+
1687 LATEX_FOOTER =
+
1688 
+
1689 # The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+
1690 # LaTeX style sheets that are included after the standard style sheets created
+
1691 # by doxygen. Using this option one can overrule certain style aspects. Doxygen
+
1692 # will copy the style sheet files to the output directory.
+
1693 # Note: The order of the extra style sheet files is of importance (e.g. the last
+
1694 # style sheet in the list overrules the setting of the previous ones in the
+
1695 # list).
+
1696 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1697 
+
1698 LATEX_EXTRA_STYLESHEET =
+
1699 
+
1700 # The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+
1701 # other source files which should be copied to the LATEX_OUTPUT output
+
1702 # directory. Note that the files will be copied as-is; there are no commands or
+
1703 # markers available.
+
1704 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1705 
+
1706 LATEX_EXTRA_FILES =
+
1707 
+
1708 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+
1709 # prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+
1710 # contain links (just like the HTML output) instead of page references. This
+
1711 # makes the output suitable for online browsing using a PDF viewer.
+
1712 # The default value is: YES.
+
1713 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1714 
+
1715 PDF_HYPERLINKS = NO
+
1716 
+
1717 # If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+
1718 # the PDF file directly from the LaTeX files. Set this option to YES, to get a
+
1719 # higher quality PDF documentation.
+
1720 # The default value is: YES.
+
1721 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1722 
+
1723 USE_PDFLATEX = YES
+
1724 
+
1725 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+
1726 # command to the generated LaTeX files. This will instruct LaTeX to keep running
+
1727 # if errors occur, instead of asking the user for help. This option is also used
+
1728 # when generating formulas in HTML.
+
1729 # The default value is: NO.
+
1730 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1731 
+
1732 LATEX_BATCHMODE = NO
+
1733 
+
1734 # If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+
1735 # index chapters (such as File Index, Compound Index, etc.) in the output.
+
1736 # The default value is: NO.
+
1737 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1738 
+
1739 LATEX_HIDE_INDICES = NO
+
1740 
+
1741 # If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+
1742 # code with syntax highlighting in the LaTeX output.
+
1743 #
+
1744 # Note that which sources are shown also depends on other settings such as
+
1745 # SOURCE_BROWSER.
+
1746 # The default value is: NO.
+
1747 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1748 
+
1749 LATEX_SOURCE_CODE = NO
+
1750 
+
1751 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+
1752 # bibliography, e.g. plainnat, or ieeetr. See
+
1753 # http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+
1754 # The default value is: plain.
+
1755 # This tag requires that the tag GENERATE_LATEX is set to YES.
+
1756 
+
1757 LATEX_BIB_STYLE = plain
+
1758 
+
1759 #---------------------------------------------------------------------------
+
1760 # Configuration options related to the RTF output
+
1761 #---------------------------------------------------------------------------
+
1762 
+
1763 # If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+
1764 # RTF output is optimized for Word 97 and may not look too pretty with other RTF
+
1765 # readers/editors.
+
1766 # The default value is: NO.
+
1767 
+
1768 GENERATE_RTF = NO
+
1769 
+
1770 # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+
1771 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+
1772 # it.
+
1773 # The default directory is: rtf.
+
1774 # This tag requires that the tag GENERATE_RTF is set to YES.
+
1775 
+
1776 RTF_OUTPUT = glm.rtf
+
1777 
+
1778 # If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+
1779 # documents. This may be useful for small projects and may help to save some
+
1780 # trees in general.
+
1781 # The default value is: NO.
+
1782 # This tag requires that the tag GENERATE_RTF is set to YES.
+
1783 
+
1784 COMPACT_RTF = NO
+
1785 
+
1786 # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+
1787 # contain hyperlink fields. The RTF file will contain links (just like the HTML
+
1788 # output) instead of page references. This makes the output suitable for online
+
1789 # browsing using Word or some other Word compatible readers that support those
+
1790 # fields.
+
1791 #
+
1792 # Note: WordPad (write) and others do not support links.
+
1793 # The default value is: NO.
+
1794 # This tag requires that the tag GENERATE_RTF is set to YES.
+
1795 
+
1796 RTF_HYPERLINKS = YES
+
1797 
+
1798 # Load stylesheet definitions from file. Syntax is similar to doxygen's config
+
1799 # file, i.e. a series of assignments. You only have to provide replacements,
+
1800 # missing definitions are set to their default value.
+
1801 #
+
1802 # See also section "Doxygen usage" for information on how to generate the
+
1803 # default style sheet that doxygen normally uses.
+
1804 # This tag requires that the tag GENERATE_RTF is set to YES.
+
1805 
+
1806 RTF_STYLESHEET_FILE =
+
1807 
+
1808 # Set optional variables used in the generation of an RTF document. Syntax is
+
1809 # similar to doxygen's config file. A template extensions file can be generated
+
1810 # using doxygen -e rtf extensionFile.
+
1811 # This tag requires that the tag GENERATE_RTF is set to YES.
+
1812 
+
1813 RTF_EXTENSIONS_FILE =
+
1814 
+
1815 # If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+
1816 # with syntax highlighting in the RTF output.
+
1817 #
+
1818 # Note that which sources are shown also depends on other settings such as
+
1819 # SOURCE_BROWSER.
+
1820 # The default value is: NO.
+
1821 # This tag requires that the tag GENERATE_RTF is set to YES.
+
1822 
+
1823 RTF_SOURCE_CODE = NO
+
1824 
+
1825 #---------------------------------------------------------------------------
+
1826 # Configuration options related to the man page output
+
1827 #---------------------------------------------------------------------------
+
1828 
+
1829 # If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+
1830 # classes and files.
+
1831 # The default value is: NO.
+
1832 
+
1833 GENERATE_MAN = NO
+
1834 
+
1835 # The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+
1836 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+
1837 # it. A directory man3 will be created inside the directory specified by
+
1838 # MAN_OUTPUT.
+
1839 # The default directory is: man.
+
1840 # This tag requires that the tag GENERATE_MAN is set to YES.
+
1841 
+
1842 MAN_OUTPUT = man
+
1843 
+
1844 # The MAN_EXTENSION tag determines the extension that is added to the generated
+
1845 # man pages. In case the manual section does not start with a number, the number
+
1846 # 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+
1847 # optional.
+
1848 # The default value is: .3.
+
1849 # This tag requires that the tag GENERATE_MAN is set to YES.
+
1850 
+
1851 MAN_EXTENSION = .3
+
1852 
+
1853 # The MAN_SUBDIR tag determines the name of the directory created within
+
1854 # MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+
1855 # MAN_EXTENSION with the initial . removed.
+
1856 # This tag requires that the tag GENERATE_MAN is set to YES.
+
1857 
+
1858 MAN_SUBDIR =
+
1859 
+
1860 # If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+
1861 # will generate one additional man file for each entity documented in the real
+
1862 # man page(s). These additional files only source the real man page, but without
+
1863 # them the man command would be unable to find the correct page.
+
1864 # The default value is: NO.
+
1865 # This tag requires that the tag GENERATE_MAN is set to YES.
+
1866 
+
1867 MAN_LINKS = NO
+
1868 
+
1869 #---------------------------------------------------------------------------
+
1870 # Configuration options related to the XML output
+
1871 #---------------------------------------------------------------------------
+
1872 
+
1873 # If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+
1874 # captures the structure of the code including all documentation.
+
1875 # The default value is: NO.
+
1876 
+
1877 GENERATE_XML = NO
+
1878 
+
1879 # The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+
1880 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+
1881 # it.
+
1882 # The default directory is: xml.
+
1883 # This tag requires that the tag GENERATE_XML is set to YES.
+
1884 
+
1885 XML_OUTPUT = xml
+
1886 
+
1887 # If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+
1888 # listings (including syntax highlighting and cross-referencing information) to
+
1889 # the XML output. Note that enabling this will significantly increase the size
+
1890 # of the XML output.
+
1891 # The default value is: YES.
+
1892 # This tag requires that the tag GENERATE_XML is set to YES.
+
1893 
+
1894 XML_PROGRAMLISTING = YES
+
1895 
+
1896 #---------------------------------------------------------------------------
+
1897 # Configuration options related to the DOCBOOK output
+
1898 #---------------------------------------------------------------------------
+
1899 
+
1900 # If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+
1901 # that can be used to generate PDF.
+
1902 # The default value is: NO.
+
1903 
+
1904 GENERATE_DOCBOOK = NO
+
1905 
+
1906 # The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+
1907 # If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+
1908 # front of it.
+
1909 # The default directory is: docbook.
+
1910 # This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
1911 
+
1912 DOCBOOK_OUTPUT = docbook
+
1913 
+
1914 # If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
+
1915 # program listings (including syntax highlighting and cross-referencing
+
1916 # information) to the DOCBOOK output. Note that enabling this will significantly
+
1917 # increase the size of the DOCBOOK output.
+
1918 # The default value is: NO.
+
1919 # This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
1920 
+
1921 DOCBOOK_PROGRAMLISTING = NO
+
1922 
+
1923 #---------------------------------------------------------------------------
+
1924 # Configuration options for the AutoGen Definitions output
+
1925 #---------------------------------------------------------------------------
+
1926 
+
1927 # If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+
1928 # AutoGen Definitions (see http://autogen.sf.net) file that captures the
+
1929 # structure of the code including all documentation. Note that this feature is
+
1930 # still experimental and incomplete at the moment.
+
1931 # The default value is: NO.
+
1932 
+
1933 GENERATE_AUTOGEN_DEF = NO
+
1934 
+
1935 #---------------------------------------------------------------------------
+
1936 # Configuration options related to the Perl module output
+
1937 #---------------------------------------------------------------------------
+
1938 
+
1939 # If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+
1940 # file that captures the structure of the code including all documentation.
+
1941 #
+
1942 # Note that this feature is still experimental and incomplete at the moment.
+
1943 # The default value is: NO.
+
1944 
+
1945 GENERATE_PERLMOD = NO
+
1946 
+
1947 # If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+
1948 # Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+
1949 # output from the Perl module output.
+
1950 # The default value is: NO.
+
1951 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
1952 
+
1953 PERLMOD_LATEX = NO
+
1954 
+
1955 # If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+
1956 # formatted so it can be parsed by a human reader. This is useful if you want to
+
1957 # understand what is going on. On the other hand, if this tag is set to NO, the
+
1958 # size of the Perl module output will be much smaller and Perl will parse it
+
1959 # just the same.
+
1960 # The default value is: YES.
+
1961 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
1962 
+
1963 PERLMOD_PRETTY = YES
+
1964 
+
1965 # The names of the make variables in the generated doxyrules.make file are
+
1966 # prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+
1967 # so different doxyrules.make files included by the same Makefile don't
+
1968 # overwrite each other's variables.
+
1969 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
1970 
+
1971 PERLMOD_MAKEVAR_PREFIX =
+
1972 
+
1973 #---------------------------------------------------------------------------
+
1974 # Configuration options related to the preprocessor
+
1975 #---------------------------------------------------------------------------
+
1976 
+
1977 # If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+
1978 # C-preprocessor directives found in the sources and include files.
+
1979 # The default value is: YES.
+
1980 
+
1981 ENABLE_PREPROCESSING = YES
+
1982 
+
1983 # If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+
1984 # in the source code. If set to NO, only conditional compilation will be
+
1985 # performed. Macro expansion can be done in a controlled way by setting
+
1986 # EXPAND_ONLY_PREDEF to YES.
+
1987 # The default value is: NO.
+
1988 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
1989 
+
1990 MACRO_EXPANSION = NO
+
1991 
+
1992 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+
1993 # the macro expansion is limited to the macros specified with the PREDEFINED and
+
1994 # EXPAND_AS_DEFINED tags.
+
1995 # The default value is: NO.
+
1996 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
1997 
+
1998 EXPAND_ONLY_PREDEF = NO
+
1999 
+
2000 # If the SEARCH_INCLUDES tag is set to YES, the include files in the
+
2001 # INCLUDE_PATH will be searched if a #include is found.
+
2002 # The default value is: YES.
+
2003 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
2004 
+
2005 SEARCH_INCLUDES = YES
+
2006 
+
2007 # The INCLUDE_PATH tag can be used to specify one or more directories that
+
2008 # contain include files that are not input files but should be processed by the
+
2009 # preprocessor.
+
2010 # This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
2011 
+
2012 INCLUDE_PATH =
+
2013 
+
2014 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+
2015 # patterns (like *.h and *.hpp) to filter out the header-files in the
+
2016 # directories. If left blank, the patterns specified with FILE_PATTERNS will be
+
2017 # used.
+
2018 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
2019 
+
2020 INCLUDE_FILE_PATTERNS =
+
2021 
+
2022 # The PREDEFINED tag can be used to specify one or more macro names that are
+
2023 # defined before the preprocessor is started (similar to the -D option of e.g.
+
2024 # gcc). The argument of the tag is a list of macros of the form: name or
+
2025 # name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+
2026 # is assumed. To prevent a macro definition from being undefined via #undef or
+
2027 # recursively expanded use the := operator instead of the = operator.
+
2028 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
2029 
+
2030 PREDEFINED =
+
2031 
+
2032 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+
2033 # tag can be used to specify a list of macro names that should be expanded. The
+
2034 # macro definition that is found in the sources will be used. Use the PREDEFINED
+
2035 # tag if you want to use a different macro definition that overrules the
+
2036 # definition found in the source code.
+
2037 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
2038 
+
2039 EXPAND_AS_DEFINED =
+
2040 
+
2041 # If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+
2042 # remove all references to function-like macros that are alone on a line, have
+
2043 # an all uppercase name, and do not end with a semicolon. Such function macros
+
2044 # are typically used for boiler-plate code, and will confuse the parser if not
+
2045 # removed.
+
2046 # The default value is: YES.
+
2047 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
2048 
+
2049 SKIP_FUNCTION_MACROS = YES
+
2050 
+
2051 #---------------------------------------------------------------------------
+
2052 # Configuration options related to external references
+
2053 #---------------------------------------------------------------------------
+
2054 
+
2055 # The TAGFILES tag can be used to specify one or more tag files. For each tag
+
2056 # file the location of the external documentation should be added. The format of
+
2057 # a tag file without this location is as follows:
+
2058 # TAGFILES = file1 file2 ...
+
2059 # Adding location for the tag files is done as follows:
+
2060 # TAGFILES = file1=loc1 "file2 = loc2" ...
+
2061 # where loc1 and loc2 can be relative or absolute paths or URLs. See the
+
2062 # section "Linking to external documentation" for more information about the use
+
2063 # of tag files.
+
2064 # Note: Each tag file must have a unique name (where the name does NOT include
+
2065 # the path). If a tag file is not located in the directory in which doxygen is
+
2066 # run, you must also specify the path to the tagfile here.
+
2067 
+
2068 TAGFILES =
+
2069 
+
2070 # When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+
2071 # tag file that is based on the input files it reads. See section "Linking to
+
2072 # external documentation" for more information about the usage of tag files.
+
2073 
+
2074 GENERATE_TAGFILE =
+
2075 
+
2076 # If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+
2077 # the class index. If set to NO, only the inherited external classes will be
+
2078 # listed.
+
2079 # The default value is: NO.
+
2080 
+
2081 ALLEXTERNALS = NO
+
2082 
+
2083 # If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+
2084 # in the modules index. If set to NO, only the current project's groups will be
+
2085 # listed.
+
2086 # The default value is: YES.
+
2087 
+
2088 EXTERNAL_GROUPS = YES
+
2089 
+
2090 # If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+
2091 # the related pages index. If set to NO, only the current project's pages will
+
2092 # be listed.
+
2093 # The default value is: YES.
+
2094 
+
2095 EXTERNAL_PAGES = YES
+
2096 
+
2097 # The PERL_PATH should be the absolute path and name of the perl script
+
2098 # interpreter (i.e. the result of 'which perl').
+
2099 # The default file (with absolute path) is: /usr/bin/perl.
+
2100 
+
2101 PERL_PATH = /usr/bin/perl
+
2102 
+
2103 #---------------------------------------------------------------------------
+
2104 # Configuration options related to the dot tool
+
2105 #---------------------------------------------------------------------------
+
2106 
+
2107 # If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+
2108 # (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+
2109 # NO turns the diagrams off. Note that this option also works with HAVE_DOT
+
2110 # disabled, but it is recommended to install and use dot, since it yields more
+
2111 # powerful graphs.
+
2112 # The default value is: YES.
+
2113 
+
2114 CLASS_DIAGRAMS = YES
+
2115 
+
2116 # You can define message sequence charts within doxygen comments using the \msc
+
2117 # command. Doxygen will then run the mscgen tool (see:
+
2118 # http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+
2119 # documentation. The MSCGEN_PATH tag allows you to specify the directory where
+
2120 # the mscgen tool resides. If left empty the tool is assumed to be found in the
+
2121 # default search path.
+
2122 
+
2123 MSCGEN_PATH =
+
2124 
+
2125 # You can include diagrams made with dia in doxygen documentation. Doxygen will
+
2126 # then run dia to produce the diagram and insert it in the documentation. The
+
2127 # DIA_PATH tag allows you to specify the directory where the dia binary resides.
+
2128 # If left empty dia is assumed to be found in the default search path.
+
2129 
+
2130 DIA_PATH =
+
2131 
+
2132 # If set to YES the inheritance and collaboration graphs will hide inheritance
+
2133 # and usage relations if the target is undocumented or is not a class.
+
2134 # The default value is: YES.
+
2135 
+
2136 HIDE_UNDOC_RELATIONS = YES
+
2137 
+
2138 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+
2139 # available from the path. This tool is part of Graphviz (see:
+
2140 # http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+
2141 # Bell Labs. The other options in this section have no effect if this option is
+
2142 # set to NO
+
2143 # The default value is: NO.
+
2144 
+
2145 HAVE_DOT = NO
+
2146 
+
2147 # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+
2148 # to run in parallel. When set to 0 doxygen will base this on the number of
+
2149 # processors available in the system. You can set it explicitly to a value
+
2150 # larger than 0 to get control over the balance between CPU load and processing
+
2151 # speed.
+
2152 # Minimum value: 0, maximum value: 32, default value: 0.
+
2153 # This tag requires that the tag HAVE_DOT is set to YES.
+
2154 
+
2155 DOT_NUM_THREADS = 0
+
2156 
+
2157 # When you want a differently looking font in the dot files that doxygen
+
2158 # generates you can specify the font name using DOT_FONTNAME. You need to make
+
2159 # sure dot is able to find the font, which can be done by putting it in a
+
2160 # standard location or by setting the DOTFONTPATH environment variable or by
+
2161 # setting DOT_FONTPATH to the directory containing the font.
+
2162 # The default value is: Helvetica.
+
2163 # This tag requires that the tag HAVE_DOT is set to YES.
+
2164 
+
2165 DOT_FONTNAME = Helvetica
+
2166 
+
2167 # The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+
2168 # dot graphs.
+
2169 # Minimum value: 4, maximum value: 24, default value: 10.
+
2170 # This tag requires that the tag HAVE_DOT is set to YES.
+
2171 
+
2172 DOT_FONTSIZE = 10
+
2173 
+
2174 # By default doxygen will tell dot to use the default font as specified with
+
2175 # DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+
2176 # the path where dot can find it using this tag.
+
2177 # This tag requires that the tag HAVE_DOT is set to YES.
+
2178 
+
2179 DOT_FONTPATH =
+
2180 
+
2181 # If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+
2182 # each documented class showing the direct and indirect inheritance relations.
+
2183 # Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+
2184 # The default value is: YES.
+
2185 # This tag requires that the tag HAVE_DOT is set to YES.
+
2186 
+
2187 CLASS_GRAPH = YES
+
2188 
+
2189 # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+
2190 # graph for each documented class showing the direct and indirect implementation
+
2191 # dependencies (inheritance, containment, and class references variables) of the
+
2192 # class with other documented classes.
+
2193 # The default value is: YES.
+
2194 # This tag requires that the tag HAVE_DOT is set to YES.
+
2195 
+
2196 COLLABORATION_GRAPH = YES
+
2197 
+
2198 # If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+
2199 # groups, showing the direct groups dependencies.
+
2200 # The default value is: YES.
+
2201 # This tag requires that the tag HAVE_DOT is set to YES.
+
2202 
+
2203 GROUP_GRAPHS = YES
+
2204 
+
2205 # If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+
2206 # collaboration diagrams in a style similar to the OMG's Unified Modeling
+
2207 # Language.
+
2208 # The default value is: NO.
+
2209 # This tag requires that the tag HAVE_DOT is set to YES.
+
2210 
+
2211 UML_LOOK = NO
+
2212 
+
2213 # If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+
2214 # class node. If there are many fields or methods and many nodes the graph may
+
2215 # become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+
2216 # number of items for each type to make the size more manageable. Set this to 0
+
2217 # for no limit. Note that the threshold may be exceeded by 50% before the limit
+
2218 # is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+
2219 # but if the number exceeds 15, the total amount of fields shown is limited to
+
2220 # 10.
+
2221 # Minimum value: 0, maximum value: 100, default value: 10.
+
2222 # This tag requires that the tag HAVE_DOT is set to YES.
+
2223 
+
2224 UML_LIMIT_NUM_FIELDS = 10
+
2225 
+
2226 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+
2227 # collaboration graphs will show the relations between templates and their
+
2228 # instances.
+
2229 # The default value is: NO.
+
2230 # This tag requires that the tag HAVE_DOT is set to YES.
+
2231 
+
2232 TEMPLATE_RELATIONS = NO
+
2233 
+
2234 # If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+
2235 # YES then doxygen will generate a graph for each documented file showing the
+
2236 # direct and indirect include dependencies of the file with other documented
+
2237 # files.
+
2238 # The default value is: YES.
+
2239 # This tag requires that the tag HAVE_DOT is set to YES.
+
2240 
+
2241 INCLUDE_GRAPH = YES
+
2242 
+
2243 # If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+
2244 # set to YES then doxygen will generate a graph for each documented file showing
+
2245 # the direct and indirect include dependencies of the file with other documented
+
2246 # files.
+
2247 # The default value is: YES.
+
2248 # This tag requires that the tag HAVE_DOT is set to YES.
+
2249 
+
2250 INCLUDED_BY_GRAPH = YES
+
2251 
+
2252 # If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+
2253 # dependency graph for every global function or class method.
+
2254 #
+
2255 # Note that enabling this option will significantly increase the time of a run.
+
2256 # So in most cases it will be better to enable call graphs for selected
+
2257 # functions only using the \callgraph command. Disabling a call graph can be
+
2258 # accomplished by means of the command \hidecallgraph.
+
2259 # The default value is: NO.
+
2260 # This tag requires that the tag HAVE_DOT is set to YES.
+
2261 
+
2262 CALL_GRAPH = YES
+
2263 
+
2264 # If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+
2265 # dependency graph for every global function or class method.
+
2266 #
+
2267 # Note that enabling this option will significantly increase the time of a run.
+
2268 # So in most cases it will be better to enable caller graphs for selected
+
2269 # functions only using the \callergraph command. Disabling a caller graph can be
+
2270 # accomplished by means of the command \hidecallergraph.
+
2271 # The default value is: NO.
+
2272 # This tag requires that the tag HAVE_DOT is set to YES.
+
2273 
+
2274 CALLER_GRAPH = YES
+
2275 
+
2276 # If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+
2277 # hierarchy of all classes instead of a textual one.
+
2278 # The default value is: YES.
+
2279 # This tag requires that the tag HAVE_DOT is set to YES.
+
2280 
+
2281 GRAPHICAL_HIERARCHY = YES
+
2282 
+
2283 # If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+
2284 # dependencies a directory has on other directories in a graphical way. The
+
2285 # dependency relations are determined by the #include relations between the
+
2286 # files in the directories.
+
2287 # The default value is: YES.
+
2288 # This tag requires that the tag HAVE_DOT is set to YES.
+
2289 
+
2290 DIRECTORY_GRAPH = YES
+
2291 
+
2292 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+
2293 # generated by dot. For an explanation of the image formats see the section
+
2294 # output formats in the documentation of the dot tool (Graphviz (see:
+
2295 # http://www.graphviz.org/)).
+
2296 # Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+
2297 # to make the SVG files visible in IE 9+ (other browsers do not have this
+
2298 # requirement).
+
2299 # Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
+
2300 # png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+
2301 # png:gdiplus:gdiplus.
+
2302 # The default value is: png.
+
2303 # This tag requires that the tag HAVE_DOT is set to YES.
+
2304 
+
2305 DOT_IMAGE_FORMAT = png
+
2306 
+
2307 # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+
2308 # enable generation of interactive SVG images that allow zooming and panning.
+
2309 #
+
2310 # Note that this requires a modern browser other than Internet Explorer. Tested
+
2311 # and working are Firefox, Chrome, Safari, and Opera.
+
2312 # Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+
2313 # the SVG files visible. Older versions of IE do not have SVG support.
+
2314 # The default value is: NO.
+
2315 # This tag requires that the tag HAVE_DOT is set to YES.
+
2316 
+
2317 INTERACTIVE_SVG = NO
+
2318 
+
2319 # The DOT_PATH tag can be used to specify the path where the dot tool can be
+
2320 # found. If left blank, it is assumed the dot tool can be found in the path.
+
2321 # This tag requires that the tag HAVE_DOT is set to YES.
+
2322 
+
2323 DOT_PATH =
+
2324 
+
2325 # The DOTFILE_DIRS tag can be used to specify one or more directories that
+
2326 # contain dot files that are included in the documentation (see the \dotfile
+
2327 # command).
+
2328 # This tag requires that the tag HAVE_DOT is set to YES.
+
2329 
+
2330 DOTFILE_DIRS =
+
2331 
+
2332 # The MSCFILE_DIRS tag can be used to specify one or more directories that
+
2333 # contain msc files that are included in the documentation (see the \mscfile
+
2334 # command).
+
2335 
+
2336 MSCFILE_DIRS =
+
2337 
+
2338 # The DIAFILE_DIRS tag can be used to specify one or more directories that
+
2339 # contain dia files that are included in the documentation (see the \diafile
+
2340 # command).
+
2341 
+
2342 DIAFILE_DIRS =
+
2343 
+
2344 # When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+
2345 # path where java can find the plantuml.jar file. If left blank, it is assumed
+
2346 # PlantUML is not used or called during a preprocessing step. Doxygen will
+
2347 # generate a warning when it encounters a \startuml command in this case and
+
2348 # will not generate output for the diagram.
+
2349 
+
2350 PLANTUML_JAR_PATH =
+
2351 
+
2352 # When using plantuml, the specified paths are searched for files specified by
+
2353 # the !include statement in a plantuml block.
+
2354 
+
2355 PLANTUML_INCLUDE_PATH =
+
2356 
+
2357 # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+
2358 # that will be shown in the graph. If the number of nodes in a graph becomes
+
2359 # larger than this value, doxygen will truncate the graph, which is visualized
+
2360 # by representing a node as a red box. Note that doxygen if the number of direct
+
2361 # children of the root node in a graph is already larger than
+
2362 # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+
2363 # the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
2364 # Minimum value: 0, maximum value: 10000, default value: 50.
+
2365 # This tag requires that the tag HAVE_DOT is set to YES.
+
2366 
+
2367 DOT_GRAPH_MAX_NODES = 50
+
2368 
+
2369 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+
2370 # generated by dot. A depth value of 3 means that only nodes reachable from the
+
2371 # root by following a path via at most 3 edges will be shown. Nodes that lay
+
2372 # further from the root node will be omitted. Note that setting this option to 1
+
2373 # or 2 may greatly reduce the computation time needed for large code bases. Also
+
2374 # note that the size of a graph can be further restricted by
+
2375 # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
2376 # Minimum value: 0, maximum value: 1000, default value: 0.
+
2377 # This tag requires that the tag HAVE_DOT is set to YES.
+
2378 
+
2379 MAX_DOT_GRAPH_DEPTH = 1000
+
2380 
+
2381 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+
2382 # background. This is disabled by default, because dot on Windows does not seem
+
2383 # to support this out of the box.
+
2384 #
+
2385 # Warning: Depending on the platform used, enabling this option may lead to
+
2386 # badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+
2387 # read).
+
2388 # The default value is: NO.
+
2389 # This tag requires that the tag HAVE_DOT is set to YES.
+
2390 
+
2391 DOT_TRANSPARENT = NO
+
2392 
+
2393 # Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+
2394 # files in one run (i.e. multiple -o and -T options on the command line). This
+
2395 # makes dot run faster, but since only newer versions of dot (>1.8.10) support
+
2396 # this, this feature is disabled by default.
+
2397 # The default value is: NO.
+
2398 # This tag requires that the tag HAVE_DOT is set to YES.
+
2399 
+
2400 DOT_MULTI_TARGETS = NO
+
2401 
+
2402 # If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+
2403 # explaining the meaning of the various boxes and arrows in the dot generated
+
2404 # graphs.
+
2405 # The default value is: YES.
+
2406 # This tag requires that the tag HAVE_DOT is set to YES.
+
2407 
+
2408 GENERATE_LEGEND = YES
+
2409 
+
2410 # If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+
2411 # files that are used to generate the various graphs.
+
2412 # The default value is: YES.
+
2413 # This tag requires that the tag HAVE_DOT is set to YES.
+
2414 
+
2415 DOT_CLEANUP = YES
+
Definition: common.hpp:20
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00048.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00048.html new file mode 100644 index 0000000000000000000000000000000000000000..f1e6b7087338c38b2ec38445c4a429c252e84b5a --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00048.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: mat2x2.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat2x2.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features

+ +

Definition in file mat2x2.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00048_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00048_source.html new file mode 100644 index 0000000000000000000000000000000000000000..29c2a5219f90c0563b86eac701c00aabeaf4f388 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00048_source.html @@ -0,0 +1,110 @@ + + + + + + +0.9.9 API documentation: mat2x2.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat2x2.hpp
+
+ + + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00049.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00049.html new file mode 100644 index 0000000000000000000000000000000000000000..02371af4af5696e939c802ad49e498a669beb909 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00049.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: mat2x3.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat2x3.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features

+ +

Definition in file mat2x3.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00049_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00049_source.html new file mode 100644 index 0000000000000000000000000000000000000000..9b32dcebba3d5a696127f17ce0f4a800baba5106 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00049_source.html @@ -0,0 +1,110 @@ + + + + + + +0.9.9 API documentation: mat2x3.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat2x3.hpp
+
+ + + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00050.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00050.html new file mode 100644 index 0000000000000000000000000000000000000000..edc8e0d3a6820808b57f7590655ba781fa67cdbc --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00050.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: mat2x4.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat2x4.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features

+ +

Definition in file mat2x4.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00050_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00050_source.html new file mode 100644 index 0000000000000000000000000000000000000000..ef9de3a5d66ef529ce5f4daa9a62f57f9e97227c --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00050_source.html @@ -0,0 +1,110 @@ + + + + + + +0.9.9 API documentation: mat2x4.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat2x4.hpp
+
+ + + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00051.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00051.html new file mode 100644 index 0000000000000000000000000000000000000000..fe42f0de1f1659177f4804d6248dcd695ad4ea0a --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00051.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: mat3x2.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat3x2.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features

+ +

Definition in file mat3x2.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00051_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00051_source.html new file mode 100644 index 0000000000000000000000000000000000000000..7ff21cc9ebb6cc262f092f81c1a4f01ec86c8fff --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00051_source.html @@ -0,0 +1,110 @@ + + + + + + +0.9.9 API documentation: mat3x2.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat3x2.hpp
+
+ + + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00052.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00052.html new file mode 100644 index 0000000000000000000000000000000000000000..e54365b581cfe7a9d4e237320ba1df37fa1e739a --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00052.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: mat3x3.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat3x3.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features

+ +

Definition in file mat3x3.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00052_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00052_source.html new file mode 100644 index 0000000000000000000000000000000000000000..d05398ccfe4738e5d0ce996818e471efc1559f51 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00052_source.html @@ -0,0 +1,109 @@ + + + + + + +0.9.9 API documentation: mat3x3.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat3x3.hpp
+
+ + + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00053.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00053.html new file mode 100644 index 0000000000000000000000000000000000000000..595a4ebdba3a8d0b67aa6e4416a735297eda9736 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00053.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: mat3x4.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat3x4.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features

+ +

Definition in file mat3x4.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00053_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00053_source.html new file mode 100644 index 0000000000000000000000000000000000000000..ceaa6234bf801daaa98e4688ad7babbaca1cface --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00053_source.html @@ -0,0 +1,109 @@ + + + + + + +0.9.9 API documentation: mat3x4.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat3x4.hpp
+
+ + + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00054.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00054.html new file mode 100644 index 0000000000000000000000000000000000000000..8a0645635c9b65c849d782a7ff0bb40e6a80a71e --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00054.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: mat4x2.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat4x2.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features

+ +

Definition in file mat4x2.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00054_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00054_source.html new file mode 100644 index 0000000000000000000000000000000000000000..5e8fe2dc4de660acafd7df1fd5156677de3b4d66 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00054_source.html @@ -0,0 +1,109 @@ + + + + + + +0.9.9 API documentation: mat4x2.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat4x2.hpp
+
+
+Go to the documentation of this file.
1 
+
4 #pragma once
+ + + +
8 #include "./ext/matrix_float4x2_precision.hpp"
+
9 
+ +
Core features
+
Core features
+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00055.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00055.html new file mode 100644 index 0000000000000000000000000000000000000000..3905618f13bcc917f1813434045629ce81a3c056 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00055.html @@ -0,0 +1,108 @@ + + + + + + +0.9.9 API documentation: mat4x3.hpp File Reference + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat4x3.hpp File Reference
+
+
+ +

Core features +More...

+ +

Go to the source code of this file.

+

Detailed Description

+

Core features

+ +

Definition in file mat4x3.hpp.

+
+ + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00055_source.html b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00055_source.html new file mode 100644 index 0000000000000000000000000000000000000000..85f4e8fea5ef94f6cd6dd09bba8e99b5f43ed717 --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/api/a00055_source.html @@ -0,0 +1,109 @@ + + + + + + +0.9.9 API documentation: mat4x3.hpp Source File + + + + + + + + + + +
+
+ + + + + + + +
+
0.9.9 API documentation +
+
+
+ + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mat4x3.hpp
+
+ + + + + diff --git a/submodules/diff-gaussian-rasterization/third_party/glm/doc/man.doxy b/submodules/diff-gaussian-rasterization/third_party/glm/doc/man.doxy new file mode 100644 index 0000000000000000000000000000000000000000..8eab2f641776daa6068ee575d8f5473244fd49ec --- /dev/null +++ b/submodules/diff-gaussian-rasterization/third_party/glm/doc/man.doxy @@ -0,0 +1,2415 @@ +# Doxyfile 1.8.10 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all text +# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv +# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv +# for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "0.9.9 API documentation" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = + +# With the PROJECT_LOGO tag one can specify a logo or an icon that is included +# in the documentation. The maximum height of the logo should not exceed 55 +# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy +# the logo to the output directory. + +PROJECT_LOGO = theme/logo-mini.png + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = . + +# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII +# characters to appear in the names of generated files. If set to NO, non-ASCII +# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode +# U+3044. +# The default value is: NO. + +ALLOW_UNICODE_NAMES = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, +# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), +# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, +# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, +# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, +# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, +# Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = "The $name class " \ + "The $name widget " \ + "The $name file " \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = NO + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = "C:/Documents and Settings/Groove/ " + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = YES + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = YES + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new +# page for each member. If set to NO, the documentation of a member will be part +# of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 8 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines. + +ALIASES = + +# This tag can be used to specify a number of word-keyword mappings (TCL only). +# A mapping has the form "name=value". For example adding "class=itcl::class" +# will allow you to use the command class in the itcl::class meaning. + +TCL_SUBST = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, Javascript, +# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran: +# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: +# Fortran. In the later case the parser tries to guess whether the code is fixed +# or free formatted code, this is the default for Fortran type files), VHDL. For +# instance to make doxygen treat .inc files as Fortran files (default is PHP), +# and .f files as C (default is Fortran), use: inc=Fortran f=C. +# +# Note: For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See http://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by putting a % sign in front of the word or +# globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# If one adds a struct or class to a group and this option is enabled, then also +# any nested class or struct is added to the same group. By default this option +# is disabled and one has to add nested compounds explicitly via \ingroup. +# The default value is: NO. + +GROUP_NESTED_COMPOUNDS = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = NO + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = NO + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO, +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = NO + +# This flag is only useful for Objective-C code. If set to YES, local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO, only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = YES + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO, these classes will be included in the various overviews. This option +# has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = YES + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# (class|struct|union) declarations. If set to NO, these declarations will be +# included in the documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = YES + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO, these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = YES + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES, upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES, the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = YES + +# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will +# append additional text to a page's title, such as Class Reference. If set to +# YES the compound reference will be hidden. +# The default value is: NO. + +HIDE_COMPOUND_REFERENCE= NO + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = NO + +# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each +# grouped member an include statement to the documentation, telling the reader +# which file to include in order to use the member. +# The default value is: NO. + +SHOW_GROUPED_MEMB_INC = NO + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = NO + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. Note that +# this will also influence the order of the classes in the class list. +# The default value is: NO. + +SORT_BRIEF_DOCS = YES + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = YES + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo +# list. This list is created by putting \todo commands in the documentation. +# The default value is: YES. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test +# list. This list is created by putting \test commands in the documentation. +# The default value is: YES. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if ... \endif and \cond +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES, the +# list will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = NO + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. See also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = YES + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO, doxygen will only warn about wrong or incomplete +# parameter documentation, but not about the absence of documentation. +# The default value is: NO. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING +# Note: If this tag is empty the current directory is searched. + +INPUT = ../glm \ + . + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: http://www.gnu.org/software/libiconv) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# read by doxygen. +# +# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp, +# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, +# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, +# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, +# *.vhdl, *.ucf, *.qsf, *.as and *.js. + +FILE_PATTERNS = *.hpp \ + *.doxy + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = * + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# +# +# where is the value of the INPUT_FILTER tag, and is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# function all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = YES + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = YES + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see http://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the config file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = YES + +# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the +# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the +# cost of reduced performance. This can be particularly helpful with template +# rich C++ code for which doxygen's built-in parser lacks the necessary type +# information. +# Note: The availability of this option depends on whether or not doxygen was +# compiled with the --with-libclang option. +# The default value is: NO. + +CLANG_ASSISTED_PARSING = NO + +# If clang assisted parsing is enabled you can provide the compiler with command +# line options that you would normally use when invoking the compiler. Note that +# the include paths will already be set by doxygen for the files and directories +# specified with INPUT and INCLUDE_PATH. +# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES. + +CLANG_OPTIONS = + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = NO + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined +# cascading style sheets that are included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefore more robust against future updates. +# Doxygen will copy the style sheet files to the output directory. +# Note: The order of the extra style sheet files is of importance (e.g. the last +# style sheet in the list overrules the setting of the previous ones in the +# list). For an example see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the style sheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# http://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to YES can help to show when doxygen was last run and thus if the +# documentation is up to date. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = NO + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = NO + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: http://developer.apple.com/tools/xcode/), introduced with +# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html +# for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = NO + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler (hhc.exe). If non-empty, +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = + +# The GENERATE_CHI flag controls if a separate .chi index file is generated +# (YES) or that it should be included in the master .chm file (NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = NO + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated +# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it +# enables the Previous and Next buttons. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = NO + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = NO + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 4 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# http://www.mathjax.org) which uses client side Javascript for the rendering +# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from http://www.mathjax.org before deployment. +# The default value is: http://cdn.mathjax.org/mathjax/latest. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = http://www.mathjax.org/mathjax + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use + S +# (what the is depends on the OS and browser, but it is typically +# , /