├── .gitignore ├── COPYING ├── LICENSE ├── assets ├── example.png ├── impulse_large_512.png ├── impulse_small_512.png ├── uvcheckermap_01.dds └── uvcheckermap_01.png ├── main.cpp ├── readme.md ├── third-party ├── glew │ ├── eglew.h │ ├── glew.h │ ├── glxew.h │ ├── lib │ │ ├── Win32 │ │ │ ├── glew32.lib │ │ │ └── glew32s.lib │ │ └── x64 │ │ │ ├── glew32.lib │ │ │ └── glew32s.lib │ └── wglew.h ├── glfw-3.1.2 │ ├── ALTERATIONS.txt │ ├── COPYING.txt │ ├── deps │ │ └── GL │ │ │ ├── glext.h │ │ │ └── wglext.h │ ├── glfw3.vcxproj │ ├── glfw3.vcxproj.filters │ ├── include │ │ └── GLFW │ │ │ ├── glfw3.h │ │ │ └── glfw3native.h │ └── src │ │ ├── context.c │ │ ├── glfw_config.h │ │ ├── init.c │ │ ├── input.c │ │ ├── internal.h │ │ ├── monitor.c │ │ ├── wgl_context.c │ │ ├── wgl_context.h │ │ ├── win32_init.c │ │ ├── win32_monitor.c │ │ ├── win32_platform.h │ │ ├── win32_time.c │ │ ├── win32_tls.c │ │ ├── win32_tls.h │ │ ├── win32_window.c │ │ ├── window.c │ │ ├── winmm_joystick.c │ │ └── winmm_joystick.h ├── gli │ ├── CMakeLists.txt │ ├── clear.hpp │ ├── comparison.hpp │ ├── convert.hpp │ ├── copy.hpp │ ├── core │ │ ├── bc.hpp │ │ ├── bc.inl │ │ ├── clear.hpp │ │ ├── clear.inl │ │ ├── comparison.inl │ │ ├── convert.inl │ │ ├── convert_func.hpp │ │ ├── coord.hpp │ │ ├── copy.inl │ │ ├── dummy.cpp │ │ ├── duplicate.inl │ │ ├── dx.inl │ │ ├── file.hpp │ │ ├── file.inl │ │ ├── filter.hpp │ │ ├── filter.inl │ │ ├── filter_compute.hpp │ │ ├── flip.hpp │ │ ├── flip.inl │ │ ├── format.inl │ │ ├── generate_mipmaps.inl │ │ ├── gl.inl │ │ ├── image.inl │ │ ├── levels.inl │ │ ├── load.inl │ │ ├── load_dds.inl │ │ ├── load_kmg.inl │ │ ├── load_ktx.inl │ │ ├── make_texture.inl │ │ ├── mipmaps_compute.hpp │ │ ├── reduce.inl │ │ ├── s3tc.hpp │ │ ├── s3tc.inl │ │ ├── sampler.inl │ │ ├── sampler1d.inl │ │ ├── sampler1d_array.inl │ │ ├── sampler2d.inl │ │ ├── sampler2d_array.inl │ │ ├── sampler3d.inl │ │ ├── sampler_cube.inl │ │ ├── sampler_cube_array.inl │ │ ├── save.inl │ │ ├── save_dds.inl │ │ ├── save_kmg.inl │ │ ├── save_ktx.inl │ │ ├── storage.hpp │ │ ├── storage.inl │ │ ├── storage_linear.hpp │ │ ├── storage_linear.inl │ │ ├── texture.inl │ │ ├── texture1d.inl │ │ ├── texture1d_array.inl │ │ ├── texture2d.inl │ │ ├── texture2d_array.inl │ │ ├── texture3d.inl │ │ ├── texture_cube.inl │ │ ├── texture_cube_array.inl │ │ ├── transform.inl │ │ ├── view.inl │ │ └── workaround.hpp │ ├── duplicate.hpp │ ├── dx.hpp │ ├── format.hpp │ ├── generate_mipmaps.hpp │ ├── gl.hpp │ ├── gli.hpp │ ├── image.hpp │ ├── levels.hpp │ ├── load.hpp │ ├── load_dds.hpp │ ├── load_kmg.hpp │ ├── load_ktx.hpp │ ├── make_texture.hpp │ ├── reduce.hpp │ ├── sampler.hpp │ ├── sampler1d.hpp │ ├── sampler1d_array.hpp │ ├── sampler2d.hpp │ ├── sampler2d_array.hpp │ ├── sampler3d.hpp │ ├── sampler_cube.hpp │ ├── sampler_cube_array.hpp │ ├── save.hpp │ ├── save_dds.hpp │ ├── save_kmg.hpp │ ├── save_ktx.hpp │ ├── target.hpp │ ├── texture.hpp │ ├── texture1d.hpp │ ├── texture1d_array.hpp │ ├── texture2d.hpp │ ├── texture2d_array.hpp │ ├── texture3d.hpp │ ├── texture_cube.hpp │ ├── texture_cube_array.hpp │ ├── transform.hpp │ ├── type.hpp │ └── view.hpp ├── glm │ ├── CMakeLists.txt │ ├── common.hpp │ ├── detail │ │ ├── _features.hpp │ │ ├── _fixes.hpp │ │ ├── _noise.hpp │ │ ├── _swizzle.hpp │ │ ├── _swizzle_func.hpp │ │ ├── _vectorize.hpp │ │ ├── dummy.cpp │ │ ├── func_common.hpp │ │ ├── func_common.inl │ │ ├── func_common_simd.inl │ │ ├── func_exponential.hpp │ │ ├── func_exponential.inl │ │ ├── func_exponential_simd.inl │ │ ├── func_geometric.hpp │ │ ├── func_geometric.inl │ │ ├── func_geometric_simd.inl │ │ ├── func_integer.hpp │ │ ├── func_integer.inl │ │ ├── func_integer_simd.inl │ │ ├── func_matrix.hpp │ │ ├── func_matrix.inl │ │ ├── func_matrix_simd.inl │ │ ├── func_packing.hpp │ │ ├── func_packing.inl │ │ ├── func_packing_simd.inl │ │ ├── func_trigonometric.hpp │ │ ├── func_trigonometric.inl │ │ ├── func_trigonometric_simd.inl │ │ ├── func_vector_relational.hpp │ │ ├── func_vector_relational.inl │ │ ├── func_vector_relational_simd.inl │ │ ├── glm.cpp │ │ ├── precision.hpp │ │ ├── setup.hpp │ │ ├── type_float.hpp │ │ ├── type_gentype.hpp │ │ ├── type_gentype.inl │ │ ├── type_half.hpp │ │ ├── type_half.inl │ │ ├── type_int.hpp │ │ ├── type_mat.hpp │ │ ├── type_mat.inl │ │ ├── type_mat2x2.hpp │ │ ├── type_mat2x2.inl │ │ ├── type_mat2x3.hpp │ │ ├── type_mat2x3.inl │ │ ├── type_mat2x4.hpp │ │ ├── type_mat2x4.inl │ │ ├── type_mat3x2.hpp │ │ ├── type_mat3x2.inl │ │ ├── type_mat3x3.hpp │ │ ├── type_mat3x3.inl │ │ ├── type_mat3x4.hpp │ │ ├── type_mat3x4.inl │ │ ├── type_mat4x2.hpp │ │ ├── type_mat4x2.inl │ │ ├── type_mat4x3.hpp │ │ ├── type_mat4x3.inl │ │ ├── type_mat4x4.hpp │ │ ├── type_mat4x4.inl │ │ ├── type_mat4x4_simd.inl │ │ ├── type_vec.hpp │ │ ├── type_vec.inl │ │ ├── type_vec1.hpp │ │ ├── type_vec1.inl │ │ ├── type_vec2.hpp │ │ ├── type_vec2.inl │ │ ├── type_vec3.hpp │ │ ├── type_vec3.inl │ │ ├── type_vec4.hpp │ │ ├── type_vec4.inl │ │ └── type_vec4_simd.inl │ ├── exponential.hpp │ ├── ext.hpp │ ├── fwd.hpp │ ├── geometric.hpp │ ├── glm.hpp │ ├── gtc │ │ ├── bitfield.hpp │ │ ├── bitfield.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── constants.hpp │ │ ├── constants.inl │ │ ├── epsilon.hpp │ │ ├── epsilon.inl │ │ ├── functions.hpp │ │ ├── functions.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── matrix_access.hpp │ │ ├── matrix_access.inl │ │ ├── matrix_integer.hpp │ │ ├── matrix_inverse.hpp │ │ ├── matrix_inverse.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── noise.hpp │ │ ├── noise.inl │ │ ├── packing.hpp │ │ ├── packing.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── quaternion_simd.inl │ │ ├── random.hpp │ │ ├── random.inl │ │ ├── reciprocal.hpp │ │ ├── reciprocal.inl │ │ ├── round.hpp │ │ ├── round.inl │ │ ├── type_aligned.hpp │ │ ├── type_precision.hpp │ │ ├── type_precision.inl │ │ ├── type_ptr.hpp │ │ ├── type_ptr.inl │ │ ├── ulp.hpp │ │ ├── ulp.inl │ │ ├── vec1.hpp │ │ └── vec1.inl │ ├── gtx │ │ ├── associated_min_max.hpp │ │ ├── associated_min_max.inl │ │ ├── bit.hpp │ │ ├── bit.inl │ │ ├── closest_point.hpp │ │ ├── closest_point.inl │ │ ├── color_encoding.hpp │ │ ├── color_encoding.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── color_space_YCoCg.hpp │ │ ├── color_space_YCoCg.inl │ │ ├── common.hpp │ │ ├── common.inl │ │ ├── compatibility.hpp │ │ ├── compatibility.inl │ │ ├── component_wise.hpp │ │ ├── component_wise.inl │ │ ├── dual_quaternion.hpp │ │ ├── dual_quaternion.inl │ │ ├── euler_angles.hpp │ │ ├── euler_angles.inl │ │ ├── extend.hpp │ │ ├── extend.inl │ │ ├── extended_min_max.hpp │ │ ├── extended_min_max.inl │ │ ├── fast_exponential.hpp │ │ ├── fast_exponential.inl │ │ ├── fast_square_root.hpp │ │ ├── fast_square_root.inl │ │ ├── fast_trigonometry.hpp │ │ ├── fast_trigonometry.inl │ │ ├── float_notmalize.inl │ │ ├── gradient_paint.hpp │ │ ├── gradient_paint.inl │ │ ├── handed_coordinate_space.hpp │ │ ├── handed_coordinate_space.inl │ │ ├── hash.hpp │ │ ├── hash.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── intersect.hpp │ │ ├── intersect.inl │ │ ├── io.hpp │ │ ├── io.inl │ │ ├── log_base.hpp │ │ ├── log_base.inl │ │ ├── matrix_cross_product.hpp │ │ ├── matrix_cross_product.inl │ │ ├── matrix_decompose.hpp │ │ ├── matrix_decompose.inl │ │ ├── matrix_interpolation.hpp │ │ ├── matrix_interpolation.inl │ │ ├── matrix_major_storage.hpp │ │ ├── matrix_major_storage.inl │ │ ├── matrix_operation.hpp │ │ ├── matrix_operation.inl │ │ ├── matrix_query.hpp │ │ ├── matrix_query.inl │ │ ├── matrix_transform_2d.hpp │ │ ├── matrix_transform_2d.inl │ │ ├── mixed_product.hpp │ │ ├── mixed_product.inl │ │ ├── norm.hpp │ │ ├── norm.inl │ │ ├── normal.hpp │ │ ├── normal.inl │ │ ├── normalize_dot.hpp │ │ ├── normalize_dot.inl │ │ ├── number_precision.hpp │ │ ├── number_precision.inl │ │ ├── optimum_pow.hpp │ │ ├── optimum_pow.inl │ │ ├── orthonormalize.hpp │ │ ├── orthonormalize.inl │ │ ├── perpendicular.hpp │ │ ├── perpendicular.inl │ │ ├── polar_coordinates.hpp │ │ ├── polar_coordinates.inl │ │ ├── projection.hpp │ │ ├── projection.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── range.hpp │ │ ├── raw_data.hpp │ │ ├── raw_data.inl │ │ ├── rotate_normalized_axis.hpp │ │ ├── rotate_normalized_axis.inl │ │ ├── rotate_vector.hpp │ │ ├── rotate_vector.inl │ │ ├── scalar_multiplication.hpp │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── spline.hpp │ │ ├── spline.inl │ │ ├── std_based_type.hpp │ │ ├── std_based_type.inl │ │ ├── string_cast.hpp │ │ ├── string_cast.inl │ │ ├── transform.hpp │ │ ├── transform.inl │ │ ├── transform2.hpp │ │ ├── transform2.inl │ │ ├── type_aligned.hpp │ │ ├── type_aligned.inl │ │ ├── type_trait.hpp │ │ ├── type_trait.inl │ │ ├── vec_swizzle.hpp │ │ ├── vector_angle.hpp │ │ ├── vector_angle.inl │ │ ├── vector_query.hpp │ │ ├── vector_query.inl │ │ ├── wrap.hpp │ │ └── wrap.inl │ ├── integer.hpp │ ├── mat2x2.hpp │ ├── mat2x3.hpp │ ├── mat2x4.hpp │ ├── mat3x2.hpp │ ├── mat3x3.hpp │ ├── mat3x4.hpp │ ├── mat4x2.hpp │ ├── mat4x3.hpp │ ├── mat4x4.hpp │ ├── matrix.hpp │ ├── packing.hpp │ ├── simd │ │ ├── common.h │ │ ├── exponential.h │ │ ├── geometric.h │ │ ├── integer.h │ │ ├── matrix.h │ │ ├── packing.h │ │ ├── platform.h │ │ ├── trigonometric.h │ │ └── vector_relational.h │ ├── trigonometric.hpp │ ├── vec2.hpp │ ├── vec3.hpp │ ├── vec4.hpp │ └── vector_relational.hpp ├── kissfft │ ├── _kiss_fft_guts.hpp │ ├── kiss_fft.hpp │ ├── kiss_fftr.hpp │ ├── kissfft.hpp │ └── src │ │ ├── kiss_fft.cpp │ │ └── kiss_fftr.cpp ├── linalg.h ├── linalg_util.hpp └── stb │ ├── stb_easy_font.h │ ├── stb_image.h │ ├── stb_image_resize.h │ └── stb_image_write.h ├── util.hpp ├── visualizer.sln ├── visualizer.vcxproj └── visualizer.vcxproj.filters /.gitignore: -------------------------------------------------------------------------------- 1 | # User-specific files 2 | *.suo 3 | *.user 4 | 5 | # Build results 6 | [Dd]ebug/ 7 | [Rr]elease/ 8 | [Oo]bj/ 9 | 10 | *.ilk 11 | *.obj 12 | *.pch 13 | *.pdb 14 | *.log 15 | 16 | # Visual C++ cache files 17 | ipch/ 18 | *.opensdf 19 | *.sdf 20 | *.VC.* 21 | 22 | # Visual Studio profiler 23 | *.psess 24 | *.vsp 25 | *.vspx 26 | 27 | intermediate/ 28 | build/ -------------------------------------------------------------------------------- /COPYING: -------------------------------------------------------------------------------- 1 | https://github.com/nothings/stb (Public Domain) 2 | Authored by Sean T. Barrett, 1998+ 3 | 4 | https://github.com/sgorsten/linalg (Public Domain) 5 | Authored by Sterling G. Orsten, 2014 6 | 7 | http://www.glfw.org/ (zlib/libpng) 8 | Copyright (C) Camilla Berglund, 2006-2011 9 | 10 | https://github.com/g-truc/gli (MIT) 11 | Copyright (C) G-Truc Creation, 2010+ 12 | 13 | https://github.com/g-truc/glm (MIT) 14 | Copyright (C) G-Truc Creation, 2005+ 15 | 16 | https://github.com/itdaniher/kissfft (BSD 3-clause) 17 | Copyright (C) Mark Borgerding, 2003-2010 18 | 19 | https://github.com/nigels-com/glew (BSD 3-clause) 20 | Copyright (C) The GLEW Authors, 2002+ 21 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2017, Dimitri Diakopoulos 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, 8 | this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright 10 | notice, this list of conditions and the following disclaimer in the 11 | documentation and/or other materials provided with the distribution. 12 | 13 | THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY 14 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 15 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 16 | DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY 17 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 18 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 19 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 20 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 | OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 23 | DAMAGE. -------------------------------------------------------------------------------- /assets/example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/assets/example.png -------------------------------------------------------------------------------- /assets/impulse_large_512.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/assets/impulse_large_512.png -------------------------------------------------------------------------------- /assets/impulse_small_512.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/assets/impulse_small_512.png -------------------------------------------------------------------------------- /assets/uvcheckermap_01.dds: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/assets/uvcheckermap_01.dds -------------------------------------------------------------------------------- /assets/uvcheckermap_01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/assets/uvcheckermap_01.png -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # 2d fft visualizer 2 | 3 | This project is a quick utility to visualize the 2D FFT for power-of-two png files. 4 | 5 | ![example](https://raw.githubusercontent.com/ddiakopoulos/2d_texture_fft_visualizer/master/assets/example.png "Example") 6 | 7 | # License 8 | 9 | This project is released under the simplified BSD 2-clause license. All dependencies are under similar permissive licenses. Further details are located in the `LICENSE` and `COPYING` files. -------------------------------------------------------------------------------- /third-party/glew/lib/Win32/glew32.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/third-party/glew/lib/Win32/glew32.lib -------------------------------------------------------------------------------- /third-party/glew/lib/Win32/glew32s.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/third-party/glew/lib/Win32/glew32s.lib -------------------------------------------------------------------------------- /third-party/glew/lib/x64/glew32.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/third-party/glew/lib/x64/glew32.lib -------------------------------------------------------------------------------- /third-party/glew/lib/x64/glew32s.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/third-party/glew/lib/x64/glew32s.lib -------------------------------------------------------------------------------- /third-party/glfw-3.1.2/ALTERATIONS.txt: -------------------------------------------------------------------------------- 1 | In compliance with requirement 2 of the GLFW license, this file 2 | describes alterations that have been made to this distribution of 3 | GLFW. 4 | 5 | This folder uses a subset of the sources provided in the GLFW 3.1.2 6 | distribution from www.glfw.org. A Visual Studio 2013 project has 7 | been generated that is mostly equivalent to the output of the 8 | official CMake scripts, except that it supports both the Win32 and 9 | x64 platforms. 10 | 11 | For the official, up-to-date sources, please visit www.glfw.org. 12 | -------------------------------------------------------------------------------- /third-party/glfw-3.1.2/COPYING.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2002-2006 Marcus Geelnard 2 | Copyright (c) 2006-2010 Camilla Berglund 3 | 4 | This software is provided 'as-is', without any express or implied 5 | warranty. In no event will the authors be held liable for any damages 6 | arising from the use of this software. 7 | 8 | Permission is granted to anyone to use this software for any purpose, 9 | including commercial applications, and to alter it and redistribute it 10 | freely, subject to the following restrictions: 11 | 12 | 1. The origin of this software must not be misrepresented; you must not 13 | claim that you wrote the original software. If you use this software 14 | in a product, an acknowledgment in the product documentation would 15 | be appreciated but is not required. 16 | 17 | 2. Altered source versions must be plainly marked as such, and must not 18 | be misrepresented as being the original software. 19 | 20 | 3. This notice may not be removed or altered from any source 21 | distribution. 22 | 23 | -------------------------------------------------------------------------------- /third-party/glfw-3.1.2/glfw3.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {df280eb1-0c53-480f-a114-c5c038736967} 6 | 7 | 8 | {5bcb7d5b-3542-440e-8600-6323cd69173a} 9 | 10 | 11 | 12 | 13 | src 14 | 15 | 16 | src 17 | 18 | 19 | src 20 | 21 | 22 | src 23 | 24 | 25 | src 26 | 27 | 28 | src 29 | 30 | 31 | src 32 | 33 | 34 | src 35 | 36 | 37 | src 38 | 39 | 40 | src 41 | 42 | 43 | src 44 | 45 | 46 | src 47 | 48 | 49 | 50 | 51 | src 52 | 53 | 54 | src 55 | 56 | 57 | src 58 | 59 | 60 | src 61 | 62 | 63 | src 64 | 65 | 66 | include 67 | 68 | 69 | include 70 | 71 | 72 | -------------------------------------------------------------------------------- /third-party/glfw-3.1.2/src/win32_tls.c: -------------------------------------------------------------------------------- 1 | //======================================================================== 2 | // GLFW 3.1 Win32 - www.glfw.org 3 | //------------------------------------------------------------------------ 4 | // Copyright (c) 2002-2006 Marcus Geelnard 5 | // Copyright (c) 2006-2010 Camilla Berglund 6 | // 7 | // This software is provided 'as-is', without any express or implied 8 | // warranty. In no event will the authors be held liable for any damages 9 | // arising from the use of this software. 10 | // 11 | // Permission is granted to anyone to use this software for any purpose, 12 | // including commercial applications, and to alter it and redistribute it 13 | // freely, subject to the following restrictions: 14 | // 15 | // 1. The origin of this software must not be misrepresented; you must not 16 | // claim that you wrote the original software. If you use this software 17 | // in a product, an acknowledgment in the product documentation would 18 | // be appreciated but is not required. 19 | // 20 | // 2. Altered source versions must be plainly marked as such, and must not 21 | // be misrepresented as being the original software. 22 | // 23 | // 3. This notice may not be removed or altered from any source 24 | // distribution. 25 | // 26 | //======================================================================== 27 | 28 | #include "internal.h" 29 | 30 | 31 | ////////////////////////////////////////////////////////////////////////// 32 | ////// GLFW internal API ////// 33 | ////////////////////////////////////////////////////////////////////////// 34 | 35 | int _glfwCreateContextTLS(void) 36 | { 37 | _glfw.win32_tls.context = TlsAlloc(); 38 | if (_glfw.win32_tls.context == TLS_OUT_OF_INDEXES) 39 | { 40 | _glfwInputError(GLFW_PLATFORM_ERROR, 41 | "Win32: Failed to allocate TLS index"); 42 | return GL_FALSE; 43 | } 44 | 45 | _glfw.win32_tls.allocated = GL_TRUE; 46 | return GL_TRUE; 47 | } 48 | 49 | void _glfwDestroyContextTLS(void) 50 | { 51 | if (_glfw.win32_tls.allocated) 52 | TlsFree(_glfw.win32_tls.context); 53 | } 54 | 55 | void _glfwSetContextTLS(_GLFWwindow* context) 56 | { 57 | TlsSetValue(_glfw.win32_tls.context, context); 58 | } 59 | 60 | 61 | ////////////////////////////////////////////////////////////////////////// 62 | ////// GLFW platform API ////// 63 | ////////////////////////////////////////////////////////////////////////// 64 | 65 | _GLFWwindow* _glfwPlatformGetCurrentContext(void) 66 | { 67 | return TlsGetValue(_glfw.win32_tls.context); 68 | } 69 | 70 | -------------------------------------------------------------------------------- /third-party/glfw-3.1.2/src/win32_tls.h: -------------------------------------------------------------------------------- 1 | //======================================================================== 2 | // GLFW 3.1 Win32 - www.glfw.org 3 | //------------------------------------------------------------------------ 4 | // Copyright (c) 2002-2006 Marcus Geelnard 5 | // Copyright (c) 2006-2010 Camilla Berglund 6 | // 7 | // This software is provided 'as-is', without any express or implied 8 | // warranty. In no event will the authors be held liable for any damages 9 | // arising from the use of this software. 10 | // 11 | // Permission is granted to anyone to use this software for any purpose, 12 | // including commercial applications, and to alter it and redistribute it 13 | // freely, subject to the following restrictions: 14 | // 15 | // 1. The origin of this software must not be misrepresented; you must not 16 | // claim that you wrote the original software. If you use this software 17 | // in a product, an acknowledgment in the product documentation would 18 | // be appreciated but is not required. 19 | // 20 | // 2. Altered source versions must be plainly marked as such, and must not 21 | // be misrepresented as being the original software. 22 | // 23 | // 3. This notice may not be removed or altered from any source 24 | // distribution. 25 | // 26 | //======================================================================== 27 | 28 | #ifndef _glfw3_win32_tls_h_ 29 | #define _glfw3_win32_tls_h_ 30 | 31 | #define _GLFW_PLATFORM_LIBRARY_TLS_STATE _GLFWtlsWin32 win32_tls 32 | 33 | 34 | // Win32-specific global TLS data 35 | // 36 | typedef struct _GLFWtlsWin32 37 | { 38 | GLboolean allocated; 39 | DWORD context; 40 | 41 | } _GLFWtlsWin32; 42 | 43 | 44 | int _glfwCreateContextTLS(void); 45 | void _glfwDestroyContextTLS(void); 46 | void _glfwSetContextTLS(_GLFWwindow* context); 47 | 48 | #endif // _glfw3_win32_tls_h_ 49 | -------------------------------------------------------------------------------- /third-party/glfw-3.1.2/src/winmm_joystick.h: -------------------------------------------------------------------------------- 1 | //======================================================================== 2 | // GLFW 3.1 WinMM - www.glfw.org 3 | //------------------------------------------------------------------------ 4 | // Copyright (c) 2006-2014 Camilla Berglund 5 | // 6 | // This software is provided 'as-is', without any express or implied 7 | // warranty. In no event will the authors be held liable for any damages 8 | // arising from the use of this software. 9 | // 10 | // Permission is granted to anyone to use this software for any purpose, 11 | // including commercial applications, and to alter it and redistribute it 12 | // freely, subject to the following restrictions: 13 | // 14 | // 1. The origin of this software must not be misrepresented; you must not 15 | // claim that you wrote the original software. If you use this software 16 | // in a product, an acknowledgment in the product documentation would 17 | // be appreciated but is not required. 18 | // 19 | // 2. Altered source versions must be plainly marked as such, and must not 20 | // be misrepresented as being the original software. 21 | // 22 | // 3. This notice may not be removed or altered from any source 23 | // distribution. 24 | // 25 | //======================================================================== 26 | 27 | #ifndef _glfw3_winmm_joystick_h_ 28 | #define _glfw3_winmm_joystick_h_ 29 | 30 | #define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE \ 31 | _GLFWjoystickWinMM winmm_js[GLFW_JOYSTICK_LAST + 1] 32 | 33 | 34 | // WinMM-specific per-joystick data 35 | // 36 | typedef struct _GLFWjoystickWinMM 37 | { 38 | float axes[6]; 39 | unsigned char buttons[36]; // 32 buttons plus one hat 40 | char* name; 41 | } _GLFWjoystickWinMM; 42 | 43 | 44 | void _glfwInitJoysticks(void); 45 | void _glfwTerminateJoysticks(void); 46 | 47 | #endif // _glfw3_winmm_joystick_h_ 48 | -------------------------------------------------------------------------------- /third-party/gli/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(NAME gli_dummy) 2 | 3 | file(GLOB ROOT_SOURCE *.cpp) 4 | file(GLOB ROOT_INLINE *.inl) 5 | file(GLOB ROOT_HEADER *.hpp) 6 | file(GLOB ROOT_TEXT ../*.txt) 7 | file(GLOB ROOT_MD ../*.md) 8 | file(GLOB ROOT_KMG ../doc/spec/*.html) 9 | 10 | file(GLOB_RECURSE CORE_SOURCE ./core/*.cpp) 11 | file(GLOB_RECURSE CORE_INLINE ./core/*.inl) 12 | file(GLOB_RECURSE CORE_HEADER ./core/*.hpp) 13 | 14 | file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp) 15 | file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl) 16 | file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp) 17 | 18 | source_group("KMG Spec" FILES ${ROOT_KMG}) 19 | source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD}) 20 | source_group("Core Files" FILES ${CORE_SOURCE}) 21 | source_group("Core Files" FILES ${CORE_INLINE}) 22 | source_group("Core Files" FILES ${CORE_HEADER}) 23 | source_group("GTX Files" FILES ${GTX_SOURCE}) 24 | source_group("GTX Files" FILES ${GTX_INLINE}) 25 | source_group("GTX Files" FILES ${GTX_HEADER}) 26 | 27 | include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..) 28 | 29 | add_executable(${NAME} ${ROOT_TEXT} ${ROOT_MD} ${ROOT_KMG} 30 | ${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER} 31 | ${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER} 32 | ${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER}) 33 | -------------------------------------------------------------------------------- /third-party/gli/clear.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to copy textures or a subset of either textures. These operations are performed without memory allocations. 2 | /// @file gli/clear.hpp 3 | 4 | #pragma once 5 | 6 | namespace gli 7 | { 8 | /// Clear a complete texture 9 | template 10 | void clear(texture_type& Texture); 11 | 12 | /// Clear a complete texture 13 | template 14 | void clear(texture_type& Texture, gen_type const& BlockData); 15 | 16 | /// Clear a specific image of a texture 17 | template 18 | void clear(texture_type& Texture, size_t Layer, size_t Face, size_t Level, gen_type const& BlockData); 19 | 20 | // Clear an entire level of a texture 21 | template 22 | void clear_level(texture_type& Texture, size_t BaseLevel, gen_type const& BlockData); 23 | 24 | // Clear multiple levels of a texture 25 | template 26 | void clear_level(texture_type& Texture, size_t BaseLevel, size_t LevelCount, gen_type const& BlockData); 27 | 28 | // Clear an entire face of a texture 29 | template 30 | void clear_face(texture_type& Texture, size_t BaseFace, gen_type const& BlockData); 31 | 32 | // Clear multiple faces of a texture 33 | template 34 | void clear_face(texture_type& Texture, size_t BaseFace, size_t FaceCount, gen_type const& BlockData); 35 | 36 | // Clear an entire layer of a texture 37 | template 38 | void clear_layer(texture_type& Texture, size_t BaseLayer, gen_type const& BlockData); 39 | 40 | // Clear multiple layers of a texture 41 | template 42 | void clear_layer(texture_type& Texture, size_t BaseLayer, size_t LayerCount, gen_type const& BlockData); 43 | }//namespace gli 44 | 45 | #include "./core/clear.inl" 46 | 47 | -------------------------------------------------------------------------------- /third-party/gli/comparison.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use operators to compare whether two textures or images are equal 2 | /// @file gli/comparison.hpp 3 | 4 | #pragma once 5 | 6 | #include "image.hpp" 7 | #include "texture1d.hpp" 8 | #include "texture1d_array.hpp" 9 | #include "texture2d.hpp" 10 | #include "texture2d_array.hpp" 11 | #include "texture3d.hpp" 12 | #include "texture_cube.hpp" 13 | #include "texture_cube_array.hpp" 14 | 15 | namespace gli 16 | { 17 | /// Compare two images. Two images are equal when the date is the same. 18 | bool operator==(image const& ImageA, image const& ImageB); 19 | 20 | /// Compare two images. Two images are equal when the date is the same. 21 | bool operator!=(image const& ImageA, image const& ImageB); 22 | 23 | /// Compare two textures. Two textures are the same when the data, the format and the targets are the same. 24 | bool operator==(texture const& A, texture const& B); 25 | 26 | /// Compare two textures. Two textures are the same when the data, the format and the targets are the same. 27 | bool operator!=(texture const& A, texture const& B); 28 | }//namespace gli 29 | 30 | #include "./core/comparison.inl" 31 | -------------------------------------------------------------------------------- /third-party/gli/convert.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to copy textures, images or a subset of either textures or an images. These operations will cause memory allocations. 2 | /// @file gli/convert.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture1d.hpp" 7 | #include "texture1d_array.hpp" 8 | #include "texture2d.hpp" 9 | #include "texture2d_array.hpp" 10 | #include "texture3d.hpp" 11 | #include "texture_cube.hpp" 12 | #include "texture_cube_array.hpp" 13 | 14 | namespace gli 15 | { 16 | /// Convert texture data to a new format 17 | /// 18 | /// @param Texture Source texture, the format must be uncompressed. 19 | /// @param Format Destination Texture format, it must be uncompressed. 20 | template 21 | texture_type convert(texture_type const& Texture, format Format); 22 | }//namespace gli 23 | 24 | #include "./core/convert.inl" 25 | -------------------------------------------------------------------------------- /third-party/gli/copy.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to copy textures or a subset of either textures. These operations are performed without memory allocations. 2 | /// @file gli/copy.hpp 3 | 4 | #pragma once 5 | 6 | #include "type.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Copy a specific image of a texture 11 | template 12 | void copy( 13 | texture_src_type const& TextureSrc, size_t LayerSrc, size_t FaceSrc, size_t LevelSrc, 14 | texture_dst_type& TextureDst, size_t LayerDst, size_t FaceDst, size_t LevelDst); 15 | 16 | /// Copy a texture 17 | template 18 | void copy( 19 | texture_src_type const& TextureSrc, 20 | texture_dst_type& TextureDst); 21 | 22 | // Copy an entire level of a texture 23 | template 24 | void copy_level( 25 | texture_src_type const& TextureSrc, size_t BaseLevelSrc, 26 | texture_dst_type& TextureDst, size_t BaseLevelDst); 27 | 28 | // Copy multiple levels of a texture 29 | template 30 | void copy_level( 31 | texture_src_type const& TextureSrc, size_t BaseLevelSrc, 32 | texture_dst_type& TextureDst, size_t BaseLevelDst, 33 | size_t LevelCount); 34 | 35 | // Copy an entire face of a texture 36 | template 37 | void copy_face( 38 | texture_src_type const& TextureSrc, size_t BaseFaceSrc, 39 | texture_dst_type& TextureDst, size_t BaseFaceDst); 40 | 41 | // Copy multiple faces of a texture 42 | template 43 | void copy_face( 44 | texture_src_type const& TextureSrc, size_t BaseFaceSrc, 45 | texture_dst_type& TextureDst, size_t BaseFaceDst, 46 | size_t FaceCount); 47 | 48 | // Copy an entire layer of a texture 49 | template 50 | void copy_layer( 51 | texture_src_type const& TextureSrc, size_t BaseLayerSrc, 52 | texture_dst_type& TextureDst, size_t BaseLayerDst); 53 | 54 | // Copy multiple layers of a texture 55 | template 56 | void copy_layer( 57 | texture_src_type const& TextureSrc, size_t BaseLayerSrc, 58 | texture_dst_type& TextureDst, size_t BaseLayerDst, 59 | size_t LayerCount); 60 | }//namespace gli 61 | 62 | #include "./core/copy.inl" 63 | -------------------------------------------------------------------------------- /third-party/gli/core/bc.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to compress and decompress the BC compression scheme 2 | /// @file gli/bc.hpp 3 | 4 | #pragma once 5 | 6 | #include "./s3tc.hpp" 7 | 8 | namespace gli 9 | { 10 | namespace detail 11 | { 12 | typedef dxt1_block bc1_block; 13 | typedef dxt3_block bc2_block; 14 | typedef dxt5_block bc3_block; 15 | 16 | struct bc4_block { 17 | uint8_t Red0; 18 | uint8_t Red1; 19 | uint8_t Bitmap[6]; 20 | }; 21 | 22 | struct bc5_block { 23 | uint8_t Red0; 24 | uint8_t Red1; 25 | uint8_t RedBitmap[6]; 26 | uint8_t Green0; 27 | uint8_t Green1; 28 | uint8_t GreenBitmap[6]; 29 | }; 30 | 31 | glm::vec4 decompress_bc1(const bc1_block &Block, const extent2d &BlockTexelCoord); 32 | texel_block4x4 decompress_dxt1_block(const dxt1_block &Block); 33 | 34 | glm::vec4 decompress_bc2(const bc2_block &Block, const extent2d &BlockTexelCoord); 35 | texel_block4x4 decompress_dxt3_block(const bc2_block &Block); 36 | 37 | glm::vec4 decompress_bc3(const bc3_block &Block, const extent2d &BlockTexelCoord); 38 | texel_block4x4 decompress_bc3_block(const dxt5_block &Block); 39 | 40 | glm::vec4 decompress_bc4unorm(const bc4_block &Block, const extent2d &BlockTexelCoord); 41 | glm::vec4 decompress_bc4snorm(const bc4_block &Block, const extent2d &BlockTexelCoord); 42 | texel_block4x4 decompress_bc4unorm_block(const bc4_block &Block); 43 | texel_block4x4 decompress_bc4snorm_block(const bc4_block &Block); 44 | 45 | glm::vec4 decompress_bc5unorm(const bc5_block &Block, const extent2d &BlockTexelCoord); 46 | glm::vec4 decompress_bc5snorm(const bc5_block &Block, const extent2d &BlockTexelCoord); 47 | texel_block4x4 decompress_bc5unorm_block(const bc5_block &Block); 48 | texel_block4x4 decompress_bc5snorm_block(const bc5_block &Block); 49 | }//namespace detail 50 | }//namespace gli 51 | 52 | #include "./bc.inl" 53 | -------------------------------------------------------------------------------- /third-party/gli/core/clear.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "convert_func.hpp" 4 | 5 | namespace gli{ 6 | namespace detail 7 | { 8 | template 9 | struct clear 10 | { 11 | static void call(textureType & Texture, typename convert::writeFunc Write, vec<4, T, P> const& Color) 12 | { 13 | GLI_ASSERT(Write); 14 | 15 | texture const ConvertTexel(Texture.target(), Texture.format(), texture::extent_type(1), 1, 1, 1); 16 | textureType Texel(ConvertTexel); 17 | Write(Texel, typename textureType::extent_type(0), 0, 0, 0, Color); 18 | 19 | size_t const BlockSize(block_size(Texture.format())); 20 | for(size_t BlockIndex = 0, BlockCount = Texture.size() / BlockSize; BlockIndex < BlockCount; ++BlockIndex) 21 | memcpy(static_cast(Texture.data()) + BlockSize * BlockIndex, Texel.data(), BlockSize); 22 | } 23 | }; 24 | }//namespace detail 25 | }//namespace gli 26 | -------------------------------------------------------------------------------- /third-party/gli/core/convert.inl: -------------------------------------------------------------------------------- 1 | #include "../core/convert_func.hpp" 2 | 3 | namespace gli 4 | { 5 | template 6 | inline texture_type convert(texture_type const& Texture, format Format) 7 | { 8 | typedef float T; 9 | typedef typename texture::extent_type extent_type; 10 | typedef typename texture_type::size_type size_type; 11 | typedef typename extent_type::value_type component_type; 12 | typedef typename detail::convert::fetchFunc fetch_type; 13 | typedef typename detail::convert::writeFunc write_type; 14 | 15 | GLI_ASSERT(!Texture.empty()); 16 | GLI_ASSERT(!is_compressed(Texture.format()) && !is_compressed(Format)); 17 | 18 | fetch_type Fetch = detail::convert::call(Texture.format()).Fetch; 19 | write_type Write = detail::convert::call(Format).Write; 20 | 21 | texture Storage(Texture.target(), Format, Texture.texture::extent(), Texture.layers(), Texture.faces(), Texture.levels(), Texture.swizzles()); 22 | texture_type Copy(Storage); 23 | 24 | for(size_type Layer = 0; Layer < Texture.layers(); ++Layer) 25 | for(size_type Face = 0; Face < Texture.faces(); ++Face) 26 | for(size_type Level = 0; Level < Texture.levels(); ++Level) 27 | { 28 | extent_type const& Dimensions = Texture.texture::extent(Level); 29 | 30 | for(component_type k = 0; k < Dimensions.z; ++k) 31 | for(component_type j = 0; j < Dimensions.y; ++j) 32 | for(component_type i = 0; i < Dimensions.x; ++i) 33 | { 34 | typename texture_type::extent_type const Texelcoord(extent_type(i, j, k)); 35 | Write( 36 | Copy, Texelcoord, Layer, Face, Level, 37 | Fetch(Texture, Texelcoord, Layer, Face, Level)); 38 | } 39 | } 40 | 41 | return texture_type(Copy); 42 | } 43 | 44 | }//namespace gli 45 | 46 | -------------------------------------------------------------------------------- /third-party/gli/core/dummy.cpp: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | 4 | } 5 | -------------------------------------------------------------------------------- /third-party/gli/core/file.hpp: -------------------------------------------------------------------------------- 1 | /// @brief File helper functions 2 | /// @file gli/core/file.hpp 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | namespace gli{ 9 | namespace detail 10 | { 11 | FILE* open_file(const char *Filename, const char *mode); 12 | }//namespace detail 13 | }//namespace gli 14 | 15 | #include "./file.inl" 16 | -------------------------------------------------------------------------------- /third-party/gli/core/file.inl: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace gli{ 6 | namespace detail 7 | { 8 | inline FILE* open_file(const char *Filename, const char *Mode) 9 | { 10 | # if GLM_COMPILER & GLM_COMPILER_VC 11 | FILE *File = nullptr; 12 | fopen_s(&File, Filename, Mode); 13 | return File; 14 | # else 15 | return std::fopen(Filename, Mode); 16 | # endif 17 | } 18 | }//namespace detail 19 | }//namespace gli 20 | -------------------------------------------------------------------------------- /third-party/gli/core/filter.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use filter enum, to select filtering methods. 2 | /// @file gli/core/filter.hpp 3 | 4 | #pragma once 5 | 6 | namespace gli 7 | { 8 | /// Texture filtring modes 9 | enum filter 10 | { 11 | FILTER_NONE = 0, 12 | FILTER_NEAREST, FILTER_FIRST = FILTER_NEAREST, 13 | FILTER_LINEAR, FILTER_LAST = FILTER_LINEAR 14 | }; 15 | 16 | enum 17 | { 18 | FILTER_COUNT = FILTER_LAST - FILTER_FIRST + 1, 19 | FILTER_INVALID = -1 20 | }; 21 | }//namespace gli 22 | 23 | #include "filter.inl" 24 | -------------------------------------------------------------------------------- /third-party/gli/core/filter.inl: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace gli{ 4 | namespace detail 5 | { 6 | 7 | }//namespace detail 8 | }//namespace gli 9 | -------------------------------------------------------------------------------- /third-party/gli/core/flip.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "../texture2d.hpp" 6 | #include "../texture2d_array.hpp" 7 | #include "../texture_cube.hpp" 8 | #include "../texture_cube_array.hpp" 9 | 10 | namespace gli 11 | { 12 | template 13 | texture flip(texture const & Texture); 14 | 15 | }//namespace gli 16 | 17 | #include "flip.inl" 18 | -------------------------------------------------------------------------------- /third-party/gli/core/levels.inl: -------------------------------------------------------------------------------- 1 | #include 2 | #define GLM_ENABLE_EXPERIMENTAL 3 | #include 4 | 5 | namespace gli 6 | { 7 | template class vecType> 8 | inline T levels(vecType const& Extent) 9 | { 10 | return glm::log2(compMax(Extent)) + static_cast(1); 11 | } 12 | 13 | template 14 | inline T levels(T Extent) 15 | { 16 | return static_cast(glm::log2(Extent) + static_cast(1)); 17 | } 18 | /* 19 | inline int levels(int Extent) 20 | { 21 | return glm::log2(Extent) + static_cast(1); 22 | } 23 | */ 24 | }//namespace gli 25 | -------------------------------------------------------------------------------- /third-party/gli/core/load.inl: -------------------------------------------------------------------------------- 1 | #include "../load_dds.hpp" 2 | #include "../load_kmg.hpp" 3 | #include "../load_ktx.hpp" 4 | #include "file.hpp" 5 | 6 | namespace gli 7 | { 8 | /// Load a texture (DDS, KTX or KMG) from memory 9 | inline texture load(char const * Data, std::size_t Size) 10 | { 11 | { 12 | texture Texture = load_dds(Data, Size); 13 | if(!Texture.empty()) 14 | return Texture; 15 | } 16 | { 17 | texture Texture = load_kmg(Data, Size); 18 | if(!Texture.empty()) 19 | return Texture; 20 | } 21 | { 22 | texture Texture = load_ktx(Data, Size); 23 | if(!Texture.empty()) 24 | return Texture; 25 | } 26 | 27 | return texture(); 28 | } 29 | 30 | /// Load a texture (DDS, KTX or KMG) from file 31 | inline texture load(char const * Filename) 32 | { 33 | FILE* File = detail::open_file(Filename, "rb"); 34 | if(!File) 35 | return texture(); 36 | 37 | long Beg = std::ftell(File); 38 | std::fseek(File, 0, SEEK_END); 39 | long End = std::ftell(File); 40 | std::fseek(File, 0, SEEK_SET); 41 | 42 | std::vector Data(static_cast(End - Beg)); 43 | 44 | std::fread(&Data[0], 1, Data.size(), File); 45 | std::fclose(File); 46 | 47 | return load(&Data[0], Data.size()); 48 | } 49 | 50 | /// Load a texture (DDS, KTX or KMG) from file 51 | inline texture load(std::string const & Filename) 52 | { 53 | return load(Filename.c_str()); 54 | } 55 | }//namespace gli 56 | -------------------------------------------------------------------------------- /third-party/gli/core/s3tc.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to compress and decompress s3tc blocks 2 | /// @file gli/s3tc.hpp 3 | 4 | #pragma once 5 | 6 | namespace gli 7 | { 8 | namespace detail 9 | { 10 | struct dxt1_block { 11 | uint16_t Color0; 12 | uint16_t Color1; 13 | uint8_t Row[4]; 14 | }; 15 | 16 | struct dxt3_block { 17 | uint16_t AlphaRow[4]; 18 | uint16_t Color0; 19 | uint16_t Color1; 20 | uint8_t Row[4]; 21 | }; 22 | 23 | struct dxt5_block { 24 | uint8_t Alpha[2]; 25 | uint8_t AlphaBitmap[6]; 26 | uint16_t Color0; 27 | uint16_t Color1; 28 | uint8_t Row[4]; 29 | }; 30 | 31 | struct texel_block4x4 { 32 | // row x col 33 | glm::vec4 Texel[4][4]; 34 | }; 35 | 36 | glm::vec4 decompress_dxt1(const dxt1_block &Block, const extent2d &BlockTexelCoord); 37 | texel_block4x4 decompress_dxt1_block(const dxt1_block &Block); 38 | 39 | glm::vec4 decompress_dxt3(const dxt3_block &Block, const extent2d &BlockTexelCoord); 40 | texel_block4x4 decompress_dxt3_block(const dxt3_block &Block); 41 | 42 | glm::vec4 decompress_dxt5(const dxt5_block &Block, const extent2d &BlockTexelCoord); 43 | texel_block4x4 decompress_dxt5_block(const dxt5_block &Block); 44 | 45 | }//namespace detail 46 | }//namespace gli 47 | 48 | #include "./s3tc.inl" 49 | -------------------------------------------------------------------------------- /third-party/gli/core/sampler.inl: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | namespace gli{ 5 | namespace detail 6 | { 7 | template 8 | inline T passThrought(T const & SampleCoord) 9 | { 10 | return SampleCoord; 11 | } 12 | }//namespace detail 13 | 14 | inline sampler::sampler(wrap Wrap, filter Mip, filter Min) 15 | : Wrap(get_func(Wrap)) 16 | , Mip(Mip) 17 | , Min(Min) 18 | {} 19 | 20 | inline sampler::wrap_type sampler::get_func(wrap WrapMode) const 21 | { 22 | static wrap_type Table[] = 23 | { 24 | glm::clamp, 25 | detail::passThrought, 26 | glm::repeat, 27 | glm::mirrorRepeat, 28 | glm::mirrorClamp, 29 | glm::mirrorClamp 30 | }; 31 | static_assert(sizeof(Table) / sizeof(Table[0]) == WRAP_COUNT, "Table needs to be updated"); 32 | 33 | return Table[WrapMode]; 34 | } 35 | }//namespace gli 36 | -------------------------------------------------------------------------------- /third-party/gli/core/save.inl: -------------------------------------------------------------------------------- 1 | #include "../save_dds.hpp" 2 | #include "../save_kmg.hpp" 3 | #include "../save_ktx.hpp" 4 | 5 | namespace gli 6 | { 7 | inline bool save(texture const & Texture, char const * Path) 8 | { 9 | return save(Texture, std::string(Path)); 10 | } 11 | 12 | inline bool save(texture const & Texture, std::string const & Path) 13 | { 14 | if(Path.rfind(".dds") != std::string::npos) 15 | return save_dds(Texture, Path); 16 | if(Path.rfind(".kmg") != std::string::npos) 17 | return save_kmg(Texture, Path); 18 | if(Path.rfind(".ktx") != std::string::npos) 19 | return save_ktx(Texture, Path); 20 | return false; 21 | } 22 | }//namespace gli 23 | -------------------------------------------------------------------------------- /third-party/gli/core/storage.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // STD 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #include "../type.hpp" 13 | #include "../format.hpp" 14 | 15 | // GLM 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | 23 | static_assert(GLM_VERSION >= 97, "GLI requires at least GLM 0.9.7"); 24 | 25 | namespace gli 26 | { 27 | class storage_linear 28 | { 29 | public: 30 | typedef extent3d extent_type; 31 | typedef size_t size_type; 32 | typedef gli::format format_type; 33 | typedef glm::byte data_type; 34 | 35 | public: 36 | storage_linear(); 37 | 38 | storage_linear( 39 | format_type Format, 40 | extent_type const & Extent, 41 | size_type Layers, 42 | size_type Faces, 43 | size_type Levels); 44 | 45 | bool empty() const; 46 | size_type size() const; // Express is bytes 47 | size_type layers() const; 48 | size_type levels() const; 49 | size_type faces() const; 50 | 51 | size_type block_size() const; 52 | extent_type block_extent() const; 53 | extent_type block_count(size_type Level) const; 54 | extent_type extent(size_type Level) const; 55 | 56 | data_type* data(); 57 | data_type const* const data() const; 58 | 59 | /// Compute the relative memory offset to access the data for a specific layer, face and level 60 | size_type base_offset( 61 | size_type Layer, 62 | size_type Face, 63 | size_type Level) const; 64 | 65 | /// Copy a subset of a specific image of a texture 66 | void copy( 67 | storage_linear const& StorageSrc, 68 | size_t LayerSrc, size_t FaceSrc, size_t LevelSrc, extent_type const& BlockIndexSrc, 69 | size_t LayerDst, size_t FaceDst, size_t LevelDst, extent_type const& BlockIndexDst, 70 | extent_type const& BlockCount); 71 | 72 | size_type level_size( 73 | size_type Level) const; 74 | size_type face_size( 75 | size_type BaseLevel, size_type MaxLevel) const; 76 | size_type layer_size( 77 | size_type BaseFace, size_type MaxFace, 78 | size_type BaseLevel, size_type MaxLevel) const; 79 | 80 | private: 81 | size_type const Layers; 82 | size_type const Faces; 83 | size_type const Levels; 84 | size_type const BlockSize; 85 | extent_type const BlockCount; 86 | extent_type const BlockExtent; 87 | extent_type const Extent; 88 | std::vector Data; 89 | }; 90 | }//namespace gli 91 | 92 | #include "storage_linear.inl" 93 | -------------------------------------------------------------------------------- /third-party/gli/core/texture1d.inl: -------------------------------------------------------------------------------- 1 | #include "../levels.hpp" 2 | 3 | namespace gli 4 | { 5 | inline texture1d::texture1d() 6 | {} 7 | 8 | inline texture1d::texture1d(format_type Format, extent_type const& Extent, swizzles_type const& Swizzles) 9 | : texture(TARGET_1D, Format, texture::extent_type(Extent.x, 1, 1), 1, 1, gli::levels(Extent), Swizzles) 10 | {} 11 | 12 | inline texture1d::texture1d(format_type Format, extent_type const& Extent, size_type Levels, swizzles_type const& Swizzles) 13 | : texture(TARGET_1D, Format, texture::extent_type(Extent.x, 1, 1), 1, 1, Levels, Swizzles) 14 | {} 15 | 16 | inline texture1d::texture1d(texture const& Texture) 17 | : texture(Texture, TARGET_1D, Texture.format()) 18 | {} 19 | 20 | inline texture1d::texture1d 21 | ( 22 | texture const& Texture, 23 | format_type Format, 24 | size_type BaseLayer, size_type MaxLayer, 25 | size_type BaseFace, size_type MaxFace, 26 | size_type BaseLevel, size_type MaxLevel, 27 | swizzles_type const& Swizzles 28 | ) 29 | : texture( 30 | Texture, TARGET_1D, 31 | Format, 32 | BaseLayer, MaxLayer, 33 | BaseFace, MaxFace, 34 | BaseLevel, MaxLevel, 35 | Swizzles) 36 | {} 37 | 38 | inline texture1d::texture1d 39 | ( 40 | texture1d const& Texture, 41 | size_type BaseLevel, size_type MaxLevel 42 | ) 43 | : texture( 44 | Texture, TARGET_1D, 45 | Texture.format(), 46 | Texture.base_layer(), Texture.max_layer(), 47 | Texture.base_face(), Texture.max_face(), 48 | Texture.base_level() + BaseLevel, Texture.base_level() + MaxLevel) 49 | {} 50 | 51 | inline image texture1d::operator[](texture1d::size_type Level) const 52 | { 53 | GLI_ASSERT(Level < this->levels()); 54 | 55 | return image( 56 | this->Storage, 57 | this->format(), 58 | this->base_layer(), 59 | this->base_face(), 60 | this->base_level() + Level); 61 | } 62 | 63 | inline texture1d::extent_type texture1d::extent(size_type Level) const 64 | { 65 | return extent_type(this->texture::extent(Level)); 66 | } 67 | 68 | template 69 | inline gen_type texture1d::load(extent_type const& TexelCoord, size_type Level) const 70 | { 71 | return this->texture::load(texture::extent_type(TexelCoord.x, 0, 0), 0, 0, Level); 72 | } 73 | 74 | template 75 | inline void texture1d::store(extent_type const& TexelCoord, size_type Level, gen_type const& Texel) 76 | { 77 | this->texture::store(texture::extent_type(TexelCoord.x, 0, 0), 0, 0, Level, Texel); 78 | } 79 | }//namespace gli 80 | -------------------------------------------------------------------------------- /third-party/gli/core/texture2d.inl: -------------------------------------------------------------------------------- 1 | #include "../levels.hpp" 2 | 3 | namespace gli 4 | { 5 | inline texture2d::texture2d() 6 | {} 7 | 8 | inline texture2d::texture2d(format_type Format, extent_type const& Extent, swizzles_type const& Swizzles) 9 | : texture(TARGET_2D, Format, texture::extent_type(Extent, 1), 1, 1, gli::levels(Extent), Swizzles) 10 | {} 11 | 12 | inline texture2d::texture2d(format_type Format, extent_type const& Extent, size_type Levels, swizzles_type const& Swizzles) 13 | : texture(TARGET_2D, Format, texture::extent_type(Extent, 1), 1, 1, Levels, Swizzles) 14 | {} 15 | 16 | inline texture2d::texture2d(texture const& Texture) 17 | : texture(Texture, TARGET_2D, Texture.format()) 18 | {} 19 | 20 | inline texture2d::texture2d 21 | ( 22 | texture const& Texture, 23 | format_type Format, 24 | size_type BaseLayer, size_type MaxLayer, 25 | size_type BaseFace, size_type MaxFace, 26 | size_type BaseLevel, size_type MaxLevel, 27 | swizzles_type const& Swizzles 28 | ) 29 | : texture( 30 | Texture, TARGET_2D, Format, 31 | BaseLayer, MaxLayer, 32 | BaseFace, MaxFace, 33 | BaseLevel, MaxLevel, 34 | Swizzles) 35 | {} 36 | 37 | inline texture2d::texture2d 38 | ( 39 | texture2d const& Texture, 40 | size_type BaseLevel, size_type MaxLevel 41 | ) 42 | : texture( 43 | Texture, TARGET_2D, Texture.format(), 44 | Texture.base_layer(), Texture.max_layer(), 45 | Texture.base_face(), Texture.max_face(), 46 | Texture.base_level() + BaseLevel, Texture.base_level() + MaxLevel) 47 | {} 48 | 49 | inline image texture2d::operator[](size_type Level) const 50 | { 51 | GLI_ASSERT(Level < this->levels()); 52 | 53 | return image( 54 | this->Storage, 55 | this->format(), 56 | this->base_layer(), 57 | this->base_face(), 58 | this->base_level() + Level); 59 | } 60 | 61 | inline texture2d::extent_type texture2d::extent(size_type Level) const 62 | { 63 | return extent_type(this->texture::extent(Level)); 64 | } 65 | 66 | template 67 | inline gen_type texture2d::load(extent_type const& TexelCoord, size_type Level) const 68 | { 69 | return this->texture::load(texture::extent_type(TexelCoord, 0), 0, 0, Level); 70 | } 71 | 72 | template 73 | inline void texture2d::store(extent_type const& TexelCoord, size_type Level, gen_type const& Texel) 74 | { 75 | this->texture::store(texture::extent_type(TexelCoord, 0), 0, 0, Level, Texel); 76 | } 77 | }//namespace gli 78 | -------------------------------------------------------------------------------- /third-party/gli/core/texture3d.inl: -------------------------------------------------------------------------------- 1 | #include "../levels.hpp" 2 | 3 | namespace gli 4 | { 5 | inline texture3d::texture3d() 6 | {} 7 | 8 | inline texture3d::texture3d(format_type Format, extent_type const& Extent, swizzles_type const& Swizzles) 9 | : texture(TARGET_3D, Format, Extent, 1, 1, gli::levels(Extent), Swizzles) 10 | {} 11 | 12 | inline texture3d::texture3d(format_type Format, extent_type const& Extent, size_type Levels, swizzles_type const& Swizzles) 13 | : texture(TARGET_3D, Format, Extent, 1, 1, Levels, Swizzles) 14 | {} 15 | 16 | inline texture3d::texture3d(texture const& Texture) 17 | : texture(Texture, TARGET_3D, Texture.format()) 18 | {} 19 | 20 | inline texture3d::texture3d 21 | ( 22 | texture const& Texture, 23 | format_type Format, 24 | size_type BaseLayer, size_type MaxLayer, 25 | size_type BaseFace, size_type MaxFace, 26 | size_type BaseLevel, size_type MaxLevel, 27 | swizzles_type const& Swizzles 28 | ) 29 | : texture( 30 | Texture, TARGET_3D, Format, 31 | BaseLayer, MaxLayer, 32 | BaseFace, MaxFace, 33 | BaseLevel, MaxLevel, 34 | Swizzles) 35 | {} 36 | 37 | inline texture3d::texture3d 38 | ( 39 | texture3d const& Texture, 40 | size_type BaseLevel, size_type MaxLevel 41 | ) 42 | : texture( 43 | Texture, TARGET_3D, Texture.format(), 44 | Texture.base_layer(), Texture.max_layer(), 45 | Texture.base_face(), Texture.max_face(), 46 | Texture.base_level() + BaseLevel, Texture.base_level() + MaxLevel) 47 | {} 48 | 49 | inline image texture3d::operator[](size_type Level) const 50 | { 51 | GLI_ASSERT(Level < this->levels()); 52 | 53 | return image( 54 | this->Storage, 55 | this->format(), 56 | this->base_layer(), 57 | this->base_face(), 58 | this->base_level() + Level); 59 | } 60 | 61 | inline texture3d::extent_type texture3d::extent(size_type Level) const 62 | { 63 | return extent_type(this->texture::extent(Level)); 64 | } 65 | 66 | template 67 | inline gen_type texture3d::load(extent_type const& TexelCoord, size_type Level) const 68 | { 69 | return this->texture::load(texture::extent_type(TexelCoord), 0, 0, Level); 70 | } 71 | 72 | template 73 | inline void texture3d::store(extent_type const& TexelCoord, size_type Level, gen_type const& Texel) 74 | { 75 | this->texture::store(texture::extent_type(TexelCoord), 0, 0, Level, Texel); 76 | } 77 | }//namespace gli 78 | -------------------------------------------------------------------------------- /third-party/gli/core/texture_cube.inl: -------------------------------------------------------------------------------- 1 | namespace gli 2 | { 3 | inline texture_cube::texture_cube() 4 | {} 5 | 6 | inline texture_cube::texture_cube(format_type Format, extent_type const& Extent, swizzles_type const& Swizzles) 7 | : texture(TARGET_CUBE, Format, texture::extent_type(Extent, 1), 1, 6, gli::levels(Extent), Swizzles) 8 | {} 9 | 10 | inline texture_cube::texture_cube(format_type Format, extent_type const& Extent, size_type Levels, swizzles_type const& Swizzles) 11 | : texture(TARGET_CUBE, Format, texture::extent_type(Extent, 1), 1, 6, Levels, Swizzles) 12 | {} 13 | 14 | inline texture_cube::texture_cube(texture const& Texture) 15 | : texture(Texture, TARGET_CUBE, Texture.format()) 16 | {} 17 | 18 | inline texture_cube::texture_cube 19 | ( 20 | texture const& Texture, 21 | format_type Format, 22 | size_type BaseLayer, size_type MaxLayer, 23 | size_type BaseFace, size_type MaxFace, 24 | size_type BaseLevel, size_type MaxLevel, 25 | swizzles_type const& Swizzles 26 | ) 27 | : texture( 28 | Texture, TARGET_CUBE, Format, 29 | BaseLayer, MaxLayer, 30 | BaseFace, MaxFace, 31 | BaseLevel, MaxLevel, 32 | Swizzles) 33 | {} 34 | 35 | inline texture_cube::texture_cube 36 | ( 37 | texture_cube const& Texture, 38 | size_type BaseFace, size_type MaxFace, 39 | size_type BaseLevel, size_type MaxLevel 40 | ) 41 | : texture( 42 | Texture, TARGET_CUBE, Texture.format(), 43 | Texture.base_layer(), Texture.max_layer(), 44 | Texture.base_face() + BaseFace, Texture.base_face() + MaxFace, 45 | Texture.base_level() + BaseLevel, Texture.base_level() + MaxLevel) 46 | {} 47 | 48 | inline texture2d texture_cube::operator[](size_type Face) const 49 | { 50 | GLI_ASSERT(Face < this->faces()); 51 | 52 | return texture2d( 53 | *this, this->format(), 54 | this->base_layer(), this->max_layer(), 55 | this->base_face() + Face, this->base_face() + Face, 56 | this->base_level(), this->max_level()); 57 | } 58 | 59 | inline texture_cube::extent_type texture_cube::extent(size_type Level) const 60 | { 61 | return extent_type(this->texture::extent(Level)); 62 | } 63 | 64 | template 65 | inline gen_type texture_cube::load(extent_type const& TexelCoord, size_type Face, size_type Level) const 66 | { 67 | return this->texture::load(texture::extent_type(TexelCoord, 0), 0, Face, Level); 68 | } 69 | 70 | template 71 | inline void texture_cube::store(extent_type const& TexelCoord, size_type Face, size_type Level, gen_type const& Texel) 72 | { 73 | this->texture::store(texture::extent_type(TexelCoord, 0), 0, Face, Level, Texel); 74 | } 75 | }//namespace gli 76 | -------------------------------------------------------------------------------- /third-party/gli/levels.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to compute the number of mipmaps levels necessary to create a mipmap complete texture. 2 | /// @file gli/levels.hpp 3 | 4 | #pragma once 5 | 6 | #include "type.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Compute the number of mipmaps levels necessary to create a mipmap complete texture 11 | /// 12 | /// @param Extent Extent of the texture base level mipmap 13 | /// @tparam vecType Vector type used to express the dimensions of a texture of any kind. 14 | /// @code 15 | /// #include 16 | /// #include 17 | /// ... 18 | /// gli::texture2d::extent_type Extent(32, 10); 19 | /// gli::texture2d Texture(gli::levels(Extent)); 20 | /// @endcode 21 | template class vecType> 22 | T levels(vecType const& Extent); 23 | /* 24 | /// Compute the number of mipmaps levels necessary to create a mipmap complete texture 25 | /// 26 | /// @param Extent Extent of the texture base level mipmap 27 | /// @code 28 | /// #include 29 | /// #include 30 | /// ... 31 | /// gli::texture2d Texture(32); 32 | /// @endcode 33 | size_t levels(size_t Extent); 34 | 35 | /// Compute the number of mipmaps levels necessary to create a mipmap complete texture 36 | /// 37 | /// @param Extent Extent of the texture base level mipmap 38 | /// @code 39 | /// #include 40 | /// #include 41 | /// ... 42 | /// gli::texture2d Texture(32); 43 | /// @endcode 44 | int levels(int Extent); 45 | */ 46 | }//namespace gli 47 | 48 | #include "./core/levels.inl" 49 | -------------------------------------------------------------------------------- /third-party/gli/load.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to load DDS, KTX or KMG textures from files or memory. 2 | /// @file gli/load.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Loads a texture storage_linear from file. Returns an empty storage_linear in case of failure. 11 | /// 12 | /// @param Path Path of the file to open including filaname and filename extension 13 | texture load(char const* Path); 14 | 15 | /// Loads a texture storage_linear from file. Returns an empty storage_linear in case of failure. 16 | /// 17 | /// @param Path Path of the file to open including filaname and filename extension 18 | texture load(std::string const& Path); 19 | 20 | /// Loads a texture storage_linear from memory. Returns an empty storage_linear in case of failure. 21 | /// 22 | /// @param Data Data of a texture 23 | /// @param Size Size of the data 24 | texture load(char const* Data, std::size_t Size); 25 | }//namespace gli 26 | 27 | #include "./core/load.inl" 28 | -------------------------------------------------------------------------------- /third-party/gli/load_dds.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to load DDS textures from files or memory. 2 | /// @file gli/load_dds.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Loads a texture storage_linear from DDS file. Returns an empty storage_linear in case of failure. 11 | /// 12 | /// @param Path Path of the file to open including filaname and filename extension 13 | texture load_dds(char const* Path); 14 | 15 | /// Loads a texture storage_linear from DDS file. Returns an empty storage_linear in case of failure. 16 | /// 17 | /// @param Path Path of the file to open including filaname and filename extension 18 | texture load_dds(std::string const& Path); 19 | 20 | /// Loads a texture storage_linear from DDS memory. Returns an empty storage_linear in case of failure. 21 | /// 22 | /// @param Data Pointer to the beginning of the texture container data to read 23 | /// @param Size Size of texture container Data to read 24 | texture load_dds(char const* Data, std::size_t Size); 25 | }//namespace gli 26 | 27 | #include "./core/load_dds.inl" 28 | -------------------------------------------------------------------------------- /third-party/gli/load_kmg.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to load KMG textures from files or memory. 2 | /// @file gli/load_kmg.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Loads a texture storage_linear from KMG (Khronos Image) file. Returns an empty storage_linear in case of failure. 11 | /// 12 | /// @param Path Path of the file to open including filaname and filename extension 13 | texture load_kmg(char const* Path); 14 | 15 | /// Loads a texture storage_linear from KMG (Khronos Image) file. Returns an empty storage_linear in case of failure. 16 | /// 17 | /// @param Path Path of the file to open including filaname and filename extension 18 | texture load_kmg(std::string const& Path); 19 | 20 | /// Loads a texture storage_linear from KMG (Khronos Image) memory. Returns an empty storage_linear in case of failure. 21 | /// 22 | /// @param Data Pointer to the beginning of the texture container data to read 23 | /// @param Size Size of texture container Data to read 24 | texture load_kmg(char const* Data, std::size_t Size); 25 | }//namespace gli 26 | 27 | #include "./core/load_kmg.inl" 28 | -------------------------------------------------------------------------------- /third-party/gli/load_ktx.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to load KTX textures from files or memory. 2 | /// @file gli/load_ktx.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Loads a texture storage_linear from KTX file. Returns an empty storage_linear in case of failure. 11 | /// 12 | /// @param Path Path of the file to open including filaname and filename extension 13 | texture load_ktx(char const* Path); 14 | 15 | /// Loads a texture storage_linear from KTX file. Returns an empty storage_linear in case of failure. 16 | /// 17 | /// @param Path Path of the file to open including filaname and filename extension 18 | texture load_ktx(std::string const& Path); 19 | 20 | /// Loads a texture storage_linear from KTX memory. Returns an empty storage_linear in case of failure. 21 | /// 22 | /// @param Data Pointer to the beginning of the texture container data to read 23 | /// @param Size Size of texture container Data to read 24 | texture load_ktx(char const* Data, std::size_t Size); 25 | }//namespace gli 26 | 27 | #include "./core/load_ktx.inl" 28 | -------------------------------------------------------------------------------- /third-party/gli/make_texture.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Helper functions to create generic texture 2 | /// @file gli/make_texture.hpp 3 | 4 | #pragma once 5 | 6 | namespace gli 7 | { 8 | // Helper function to create a 1d texture with a specific number of levels 9 | gli::texture make_texture1d(format Format, extent1d const& Extent, size_t Levels); 10 | 11 | // Helper function to create a 1d texture with a complete mipmap chain 12 | gli::texture make_texture1d(format Format, extent1d const& Extent); 13 | 14 | // Helper function to create a 1d array texture with a specific number of levels 15 | gli::texture make_texture1d_array(format Format, extent1d const& Extent, size_t Layers, size_t Levels); 16 | 17 | // Helper function to create a 1d array texture with a complete mipmap chain 18 | gli::texture make_texture1d_array(format Format, extent1d const& Extent, size_t Layers); 19 | 20 | // Helper function to create a 2d texture with a specific number of levels 21 | gli::texture make_texture2d(format Format, extent2d const& Extent, size_t Levels); 22 | 23 | // Helper function to create a 2d texture with a complete mipmap chain 24 | gli::texture make_texture2d(format Format, extent2d const& Extent); 25 | 26 | // Helper function to create a 2d array texture with a specific number of levels 27 | gli::texture make_texture2d_array(format Format, extent2d const& Extent, size_t Layer, size_t Levels); 28 | 29 | // Helper function to create a 2d array texture with a complete mipmap chain 30 | gli::texture make_texture2d_array(format Format, extent2d const& Extent, size_t Layer); 31 | 32 | // Helper function to create a 3d texture with a specific number of levels 33 | gli::texture make_texture3d(format Format, extent3d const& Extent, size_t Levels); 34 | 35 | // Helper function to create a 3d texture with a complete mipmap chain 36 | gli::texture make_texture3d(format Format, extent3d const& Extent); 37 | 38 | // Helper function to create a cube texture with a specific number of levels 39 | gli::texture make_texture_cube(format Format, extent2d const& Extent, size_t Levels); 40 | 41 | // Helper function to create a cube texture with a complete mipmap chain 42 | gli::texture make_texture_cube(format Format, extent2d const& Extent); 43 | 44 | // Helper function to create a cube array texture with a specific number of levels 45 | gli::texture make_texture_cube_array(format Format, extent2d const& Extent, size_t Layer, size_t Levels); 46 | 47 | // Helper function to create a cube array texture with a complete mipmap chain 48 | gli::texture make_texture_cube_array(format Format, extent2d const& Extent, size_t Layer); 49 | }//namespace gli 50 | 51 | #include "./core/make_texture.inl" 52 | -------------------------------------------------------------------------------- /third-party/gli/sampler.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use wrap modes and the sampler base class. 2 | /// @file gli/sampler.hpp 3 | 4 | #pragma once 5 | 6 | #include "core/filter.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Texture coordinate wrapping mode 11 | enum wrap 12 | { 13 | WRAP_CLAMP_TO_EDGE, WRAP_FIRST = WRAP_CLAMP_TO_EDGE, 14 | WRAP_CLAMP_TO_BORDER, 15 | WRAP_REPEAT, 16 | WRAP_MIRROR_REPEAT, 17 | WRAP_MIRROR_CLAMP_TO_EDGE, 18 | WRAP_MIRROR_CLAMP_TO_BORDER, WRAP_LAST = WRAP_MIRROR_CLAMP_TO_BORDER 19 | }; 20 | 21 | enum 22 | { 23 | WRAP_COUNT = WRAP_LAST - WRAP_FIRST + 1 24 | }; 25 | 26 | /// Evaluate whether the texture coordinate wrapping mode relies on border color 27 | inline bool is_border(wrap Wrap) 28 | { 29 | return Wrap == WRAP_CLAMP_TO_BORDER || Wrap == WRAP_MIRROR_CLAMP_TO_BORDER; 30 | } 31 | 32 | /// Genetic sampler class. 33 | class sampler 34 | { 35 | public: 36 | sampler(wrap Wrap, filter Mip, filter Min); 37 | virtual ~sampler() = default; 38 | 39 | protected: 40 | typedef float(*wrap_type)(float const & SamplerCoord); 41 | 42 | wrap_type get_func(wrap WrapMode) const; 43 | 44 | wrap_type Wrap; 45 | filter Mip; 46 | filter Min; 47 | }; 48 | }//namespace gli 49 | 50 | #include "./core/sampler.inl" 51 | -------------------------------------------------------------------------------- /third-party/gli/save.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to save DDS, KTX or KMG textures to files or memory. 2 | /// @file gli/save.hpp 3 | 4 | #pragma once 5 | 6 | #include "save_dds.hpp" 7 | #include "save_ktx.hpp" 8 | 9 | namespace gli 10 | { 11 | /// Save a texture storage_linear to file. 12 | /// 13 | /// @param Texture Source texture to save 14 | /// @param Path Path for where to save the file. It must include the filaname and filename extension. 15 | /// The function use the filename extension included in the path to figure out the file container to use. 16 | /// @return Returns false if the function fails to save the file. 17 | bool save(texture const & Texture, char const * Path); 18 | 19 | /// Save a texture storage_linear to file. 20 | /// 21 | /// @param Texture Source texture to save 22 | /// @param Path Path for where to save the file. It must include the filaname and filename extension. 23 | /// The function use the filename extension included in the path to figure out the file container to use. 24 | /// @return Returns false if the function fails to save the file. 25 | bool save(texture const & Texture, std::string const & Path); 26 | }//namespace gli 27 | 28 | #include "./core/save.inl" 29 | -------------------------------------------------------------------------------- /third-party/gli/save_dds.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to save DDS textures to files or memory. 2 | /// @file gli/save_dds.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Save a texture storage_linear to a DDS file. 11 | /// 12 | /// @param Texture Source texture to save 13 | /// @param Path Path for where to save the file. It must include the filaname and filename extension. 14 | /// This function ignores the filename extension in the path and save to DDS anyway but keep the requested filename extension. 15 | /// @return Returns false if the function fails to save the file. 16 | bool save_dds(texture const & Texture, char const* Path); 17 | 18 | /// Save a texture storage_linear to a DDS file. 19 | /// 20 | /// @param Texture Source texture to save 21 | /// @param Path Path for where to save the file. It must include the filaname and filename extension. 22 | /// This function ignores the filename extension in the path and save to DDS anyway but keep the requested filename extension. 23 | /// @return Returns false if the function fails to save the file. 24 | bool save_dds(texture const & Texture, std::string const & Path); 25 | 26 | /// Save a texture storage_linear to a DDS file. 27 | /// 28 | /// @param Texture Source texture to save 29 | /// @param Memory Storage for the DDS container. The function resizes the containers to fit the necessary storage_linear. 30 | /// @return Returns false if the function fails to save the file. 31 | bool save_dds(texture const & Texture, std::vector & Memory); 32 | }//namespace gli 33 | 34 | #include "./core/save_dds.inl" 35 | -------------------------------------------------------------------------------- /third-party/gli/save_kmg.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to save KMG textures to files or memory. 2 | /// @file gli/save_kmg.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Save a texture storage_linear to a KMG (Khronos Image) file. 11 | /// 12 | /// @param Texture Source texture to save 13 | /// @param Path Path for where to save the file. It must include the filaname and filename extension. 14 | /// This function ignores the filename extension in the path and save to KMG anyway but keep the requested filename extension. 15 | /// @return Returns false if the function fails to save the file. 16 | bool save_kmg(texture const & Texture, char const * Path); 17 | 18 | /// Save a texture storage_linear to a KMG (Khronos Image) file. 19 | /// 20 | /// @param Texture Source texture to save 21 | /// @param Path Path for where to save the file. It must include the filaname and filename extension. 22 | /// This function ignores the filename extension in the path and save to KMG anyway but keep the requested filename extension. 23 | /// @return Returns false if the function fails to save the file. 24 | bool save_kmg(texture const & Texture, std::string const & Path); 25 | 26 | /// Save a texture storage_linear to a KMG (Khronos Image) file. 27 | /// 28 | /// @param Texture Source texture to save 29 | /// @param Memory Storage for the KMG container. The function resizes the containers to fit the necessary storage_linear. 30 | /// @return Returns false if the function fails to save the file. 31 | bool save_kmg(texture const & Texture, std::vector & Memory); 32 | }//namespace gli 33 | 34 | #include "./core/save_kmg.inl" 35 | -------------------------------------------------------------------------------- /third-party/gli/save_ktx.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to save KTX textures to files or memory. 2 | /// @file gli/save_ktx.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Save a texture storage_linear to a KTX file. 11 | /// 12 | /// @param Texture Source texture to save 13 | /// @param Path Path for where to save the file. It must include the filaname and filename extension. 14 | /// This function ignores the filename extension in the path and save to KTX anyway but keep the requested filename extension. 15 | /// @return Returns false if the function fails to save the file. 16 | bool save_ktx(texture const & Texture, char const * Path); 17 | 18 | /// Save a texture storage_linear to a KTX file. 19 | /// 20 | /// @param Texture Source texture to save 21 | /// @param Path Path for where to save the file. It must include the filaname and filename extension. 22 | /// This function ignores the filename extension in the path and save to KTX anyway but keep the requested filename extension. 23 | /// @return Returns false if the function fails to save the file. 24 | bool save_ktx(texture const & Texture, std::string const & Path); 25 | 26 | /// Save a texture storage_linear to a KTX file. 27 | /// 28 | /// @param Texture Source texture to save 29 | /// @param Memory Storage for the KTX container. The function resizes the containers to fit the necessary storage_linear. 30 | /// @return Returns false if the function fails to save the file. 31 | bool save_ktx(texture const & Texture, std::vector & Memory); 32 | }//namespace gli 33 | 34 | #include "./core/save_ktx.inl" 35 | -------------------------------------------------------------------------------- /third-party/gli/target.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use the target enum and query properties of targets. 2 | /// @file gli/target.hpp 3 | 4 | #pragma once 5 | 6 | namespace gli 7 | { 8 | /// Texture target: type/shape of the texture storage_linear 9 | enum target 10 | { 11 | TARGET_1D = 0, TARGET_FIRST = TARGET_1D, 12 | TARGET_1D_ARRAY, 13 | TARGET_2D, 14 | TARGET_2D_ARRAY, 15 | TARGET_3D, 16 | TARGET_RECT, 17 | TARGET_RECT_ARRAY, 18 | TARGET_CUBE, 19 | TARGET_CUBE_ARRAY, TARGET_LAST = TARGET_CUBE_ARRAY 20 | }; 21 | 22 | enum 23 | { 24 | TARGET_COUNT = TARGET_LAST - TARGET_FIRST + 1, 25 | TARGET_INVALID = -1 26 | }; 27 | 28 | /// Check whether a target is a 1D target 29 | inline bool is_target_1d(target Target) 30 | { 31 | return Target == TARGET_1D || Target == TARGET_1D_ARRAY; 32 | } 33 | 34 | /// Check whether a target is an array target 35 | inline bool is_target_array(target Target) 36 | { 37 | return Target == TARGET_1D_ARRAY || Target == TARGET_2D_ARRAY || Target == TARGET_CUBE_ARRAY; 38 | } 39 | 40 | /// Check whether a target is a cube map target 41 | inline bool is_target_cube(target Target) 42 | { 43 | return Target == TARGET_CUBE || Target == TARGET_CUBE_ARRAY; 44 | } 45 | 46 | /// Check whether a target is a rectangle target 47 | inline bool is_target_rect(target Target) 48 | { 49 | return Target == TARGET_RECT || Target == TARGET_RECT_ARRAY; 50 | } 51 | }//namespace gli 52 | -------------------------------------------------------------------------------- /third-party/gli/texture1d.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use 1d textures. 2 | /// @file gli/texture1d.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | #include "image.hpp" 8 | 9 | namespace gli 10 | { 11 | /// 1d texture 12 | class texture1d : public texture 13 | { 14 | public: 15 | typedef extent1d extent_type; 16 | 17 | /// Create an empty texture 1D 18 | texture1d(); 19 | 20 | /// Create a texture1d and allocate a new storage_linear 21 | texture1d( 22 | format_type Format, 23 | extent_type const& Extent, 24 | size_type Levels, 25 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 26 | 27 | /// Create a texture1d and allocate a new storage_linear with a complete mipmap chain 28 | texture1d( 29 | format_type Format, 30 | extent_type const& Extent, 31 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 32 | 33 | /// Create a texture1d view with an existing storage_linear 34 | explicit texture1d( 35 | texture const& Texture); 36 | 37 | /// Create a texture1d view with an existing storage_linear 38 | texture1d( 39 | texture const& Texture, 40 | format_type Format, 41 | size_type BaseLayer, size_type MaxLayer, 42 | size_type BaseFace, size_type MaxFace, 43 | size_type BaseLevel, size_type MaxLevel, 44 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 45 | 46 | /// Create a texture1d view, reference a subset of an existing texture1d instance 47 | texture1d( 48 | texture1d const& Texture, 49 | size_type BaseLevel, size_type MaxLevel); 50 | 51 | /// Create a view of the image identified by Level in the mipmap chain of the texture 52 | image operator[](size_type Level) const; 53 | 54 | /// Return the width of a texture instance 55 | extent_type extent(size_type Level = 0) const; 56 | 57 | /// Fetch a texel from a texture. The texture format must be uncompressed. 58 | template 59 | gen_type load(extent_type const& TexelCoord, size_type Level) const; 60 | 61 | /// Write a texel to a texture. The texture format must be uncompressed. 62 | template 63 | void store(extent_type const& TexelCoord, size_type Level, gen_type const& Texel); 64 | }; 65 | }//namespace gli 66 | 67 | #include "./core/texture1d.inl" 68 | -------------------------------------------------------------------------------- /third-party/gli/texture1d_array.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use 1d array textures. 2 | /// @file gli/texture1d_array.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture1d.hpp" 7 | 8 | namespace gli 9 | { 10 | /// 1d array texture 11 | class texture1d_array : public texture 12 | { 13 | public: 14 | typedef extent1d extent_type; 15 | 16 | public: 17 | /// Create an empty texture 1D array 18 | texture1d_array(); 19 | 20 | /// Create a texture1d_array and allocate a new storage_linear 21 | texture1d_array( 22 | format_type Format, 23 | extent_type const& Extent, 24 | size_type Layers, 25 | size_type Levels, 26 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 27 | 28 | /// Create a texture1d_array and allocate a new storage_linear with a complete mipmap chain 29 | texture1d_array( 30 | format_type Format, 31 | extent_type const& Extent, 32 | size_type Layers, 33 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 34 | 35 | /// Create a texture1d_array view with an existing storage_linear 36 | explicit texture1d_array( 37 | texture const& Texture); 38 | 39 | /// Create a texture1d_array view with an existing storage_linear 40 | texture1d_array( 41 | texture const& Texture, 42 | format_type Format, 43 | size_type BaseLayer, size_type MaxLayer, 44 | size_type BaseFace, size_type MaxFace, 45 | size_type BaseLevel, size_type MaxLevel, 46 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 47 | 48 | /// Create a texture view, reference a subset of an exiting storage_linear 49 | texture1d_array( 50 | texture1d_array const& Texture, 51 | size_type BaseLayer, size_type MaxLayer, 52 | size_type BaseLevel, size_type MaxLevel); 53 | 54 | /// Create a view of the texture identified by Layer in the texture array 55 | texture1d operator[](size_type Layer) const; 56 | 57 | /// Return the width of a texture instance 58 | extent_type extent(size_type Level = 0) const; 59 | 60 | /// Fetch a texel from a texture. The texture format must be uncompressed. 61 | template 62 | gen_type load(extent_type const& TexelCoord, size_type Layer, size_type Level) const; 63 | 64 | /// Write a texel to a texture. The texture format must be uncompressed. 65 | template 66 | void store(extent_type const& TexelCoord, size_type Layer, size_type Level, gen_type const& Texel); 67 | }; 68 | }//namespace gli 69 | 70 | #include "./core/texture1d_array.inl" 71 | -------------------------------------------------------------------------------- /third-party/gli/texture2d.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use 2d textures. 2 | /// @file gli/texture2d.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | #include "image.hpp" 8 | 9 | namespace gli 10 | { 11 | /// 2d texture 12 | class texture2d : public texture 13 | { 14 | public: 15 | typedef extent2d extent_type; 16 | 17 | /// Create an empty texture 2D. 18 | texture2d(); 19 | 20 | /// Create a texture2d and allocate a new storage_linear. 21 | texture2d( 22 | format_type Format, 23 | extent_type const& Extent, 24 | size_type Levels, 25 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 26 | 27 | /// Create a texture2d and allocate a new storage_linear with a complete mipmap chain. 28 | texture2d( 29 | format_type Format, 30 | extent_type const& Extent, 31 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 32 | 33 | /// Create a texture2d view with an existing storage_linear. 34 | explicit texture2d( 35 | texture const& Texture); 36 | 37 | /// Create a texture2d view with an existing storage_linear. 38 | texture2d( 39 | texture const& Texture, 40 | format_type Format, 41 | size_type BaseLayer, size_type MaxLayer, 42 | size_type BaseFace, size_type MaxFace, 43 | size_type BaseLevel, size_type MaxLevel, 44 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 45 | 46 | /// Create a texture2d view, reference a subset of an existing texture2d instance. 47 | texture2d( 48 | texture2d const& Texture, 49 | size_type BaseLevel, size_type MaxLevel); 50 | 51 | /// Create a view of the image identified by Level in the mipmap chain of the texture. 52 | image operator[](size_type Level) const; 53 | 54 | /// Return the dimensions of a texture instance: width and height. 55 | extent_type extent(size_type Level = 0) const; 56 | 57 | /// Fetch a texel from a texture. The texture format must be uncompressed. 58 | template 59 | gen_type load(extent_type const& TexelCoord, size_type Level) const; 60 | 61 | /// Write a texel to a texture. The texture format must be uncompressed. 62 | template 63 | void store(extent_type const& TexelCoord, size_type Level, gen_type const& Texel); 64 | }; 65 | }//namespace gli 66 | 67 | #include "./core/texture2d.inl" 68 | -------------------------------------------------------------------------------- /third-party/gli/texture2d_array.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use 2d array textures. 2 | /// @file gli/texture2d_array.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture2d.hpp" 7 | 8 | namespace gli 9 | { 10 | /// 2d array texture 11 | class texture2d_array : public texture 12 | { 13 | public: 14 | typedef extent2d extent_type; 15 | 16 | public: 17 | /// Create an empty texture 2D array 18 | texture2d_array(); 19 | 20 | /// Create a texture2d_array and allocate a new storage_linear 21 | texture2d_array( 22 | format_type Format, 23 | extent_type const& Extent, 24 | size_type Layers, 25 | size_type Levels, 26 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 27 | 28 | /// Create a texture2d_array and allocate a new storage_linear with a complete mipmap chain 29 | texture2d_array( 30 | format_type Format, 31 | extent_type const& Extent, 32 | size_type Layers, 33 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 34 | 35 | /// Create a texture2d_array view with an existing storage_linear 36 | explicit texture2d_array( 37 | texture const& Texture); 38 | 39 | /// Create a texture2d_array view with an existing storage_linear 40 | texture2d_array( 41 | texture const& Texture, 42 | format_type Format, 43 | size_type BaseLayer, size_type MaxLayer, 44 | size_type BaseFace, size_type MaxFace, 45 | size_type BaseLevel, size_type MaxLevel, 46 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 47 | 48 | /// Create a texture view, reference a subset of an exiting texture2d_array instance 49 | texture2d_array( 50 | texture2d_array const& Texture, 51 | size_type BaseLayer, size_type MaxLayer, 52 | size_type BaseLevel, size_type MaxLevel); 53 | 54 | /// Create a view of the texture identified by Layer in the texture array 55 | texture2d operator[](size_type Layer) const; 56 | 57 | /// Return the dimensions of a texture instance: width and height 58 | extent_type extent(size_type Level = 0) const; 59 | 60 | /// Fetch a texel from a texture. The texture format must be uncompressed. 61 | template 62 | gen_type load(extent_type const& TexelCoord, size_type Layer, size_type Level) const; 63 | 64 | /// Write a texel to a texture. The texture format must be uncompressed. 65 | template 66 | void store(extent_type const& TexelCoord, size_type Layer, size_type Level, gen_type const& Texel); 67 | }; 68 | }//namespace gli 69 | 70 | #include "./core/texture2d_array.inl" 71 | -------------------------------------------------------------------------------- /third-party/gli/texture3d.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use 3d textures. 2 | /// @file gli/texture3d.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture.hpp" 7 | #include "image.hpp" 8 | 9 | namespace gli 10 | { 11 | /// 3d texture 12 | class texture3d : public texture 13 | { 14 | public: 15 | typedef extent3d extent_type; 16 | 17 | public: 18 | /// Create an empty texture 3D 19 | texture3d(); 20 | 21 | /// Create a texture3d and allocate a new storage_linear 22 | texture3d( 23 | format_type Format, 24 | extent_type const& Extent, 25 | size_type Levels, 26 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 27 | 28 | /// Create a texture3d and allocate a new storage_linear with a complete mipmap chain 29 | texture3d( 30 | format_type Format, 31 | extent_type const& Extent, 32 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 33 | 34 | /// Create a texture3d view with an existing storage_linear 35 | explicit texture3d( 36 | texture const & Texture); 37 | 38 | /// Create a texture3d view with an existing storage_linear 39 | texture3d( 40 | texture const& Texture, 41 | format_type Format, 42 | size_type BaseLayer, size_type MaxLayer, 43 | size_type BaseFace, size_type MaxFace, 44 | size_type BaseLevel, size_type MaxLevel, 45 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 46 | 47 | /// Create a texture3d view, reference a subset of an existing texture3d instance 48 | texture3d( 49 | texture3d const & Texture, 50 | size_type BaseLevel, size_type MaxLevel); 51 | 52 | /// Create a view of the image identified by Level in the mipmap chain of the texture 53 | image operator[](size_type Level) const; 54 | 55 | /// Return the dimensions of a texture instance: width, height and depth 56 | extent_type extent(size_type Level = 0) const; 57 | 58 | /// Fetch a texel from a texture. The texture format must be uncompressed. 59 | template 60 | gen_type load(extent_type const& TexelCoord, size_type Level) const; 61 | 62 | /// Write a texel to a texture. The texture format must be uncompressed. 63 | template 64 | void store(extent_type const& TexelCoord, size_type Level, gen_type const& Texel); 65 | }; 66 | }//namespace gli 67 | 68 | #include "./core/texture3d.inl" 69 | -------------------------------------------------------------------------------- /third-party/gli/texture_cube.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use cube map textures. 2 | /// @file gli/texture_cube.hpp 3 | 4 | #pragma once 5 | 6 | #include "texture2d.hpp" 7 | 8 | namespace gli 9 | { 10 | /// Cube map texture 11 | class texture_cube : public texture 12 | { 13 | public: 14 | typedef extent2d extent_type; 15 | 16 | public: 17 | /// Create an empty texture cube 18 | texture_cube(); 19 | 20 | /// Create a texture_cube and allocate a new storage_linear 21 | texture_cube( 22 | format_type Format, 23 | extent_type const & Extent, 24 | size_type Levels, 25 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 26 | 27 | /// Create a texture_cube and allocate a new storage_linear with a complete mipmap chain 28 | texture_cube( 29 | format_type Format, 30 | extent_type const & Extent, 31 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 32 | 33 | /// Create a texture_cube view with an existing storage_linear 34 | explicit texture_cube( 35 | texture const& Texture); 36 | 37 | /// Create a texture_cube view with an existing storage_linear 38 | texture_cube( 39 | texture const& Texture, 40 | format_type Format, 41 | size_type BaseLayer, size_type MaxLayer, 42 | size_type BaseFace, size_type MaxFace, 43 | size_type BaseLevel, size_type MaxLevel, 44 | swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA)); 45 | 46 | /// Create a texture_cube view, reference a subset of an existing texture_cube instance 47 | texture_cube( 48 | texture_cube const& Texture, 49 | size_type BaseFace, size_type MaxFace, 50 | size_type BaseLevel, size_type MaxLevel); 51 | 52 | /// Create a view of the texture identified by Face in the texture cube 53 | texture2d operator[](size_type Face) const; 54 | 55 | /// Return the dimensions of a texture instance: width and height where both should be equal. 56 | extent_type extent(size_type Level = 0) const; 57 | 58 | /// Fetch a texel from a texture. The texture format must be uncompressed. 59 | template 60 | gen_type load(extent_type const& TexelCoord, size_type Face, size_type Level) const; 61 | 62 | /// Write a texel to a texture. The texture format must be uncompressed. 63 | template 64 | void store(extent_type const& TexelCoord, size_type Face, size_type Level, gen_type const& Texel); 65 | }; 66 | }//namespace gli 67 | 68 | #include "./core/texture_cube.inl" 69 | -------------------------------------------------------------------------------- /third-party/gli/type.hpp: -------------------------------------------------------------------------------- 1 | /// @brief Include to use basic GLI types. 2 | /// @file gli/type.hpp 3 | 4 | #pragma once 5 | 6 | // STD 7 | #include 8 | 9 | // GLM 10 | #define GLM_FORCE_EXPLICIT_CTOR 11 | #include 12 | #include 13 | #define GLM_ENABLE_EXPERIMENTAL 14 | 15 | #if GLM_COMPILER & GLM_COMPILER_VC 16 | # define GLI_FORCE_INLINE __forceinline 17 | #elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM) 18 | # define GLI_FORCE_INLINE inline __attribute__((__always_inline__)) 19 | #else 20 | # define GLI_FORCE_INLINE inline 21 | #endif//GLM_COMPILER 22 | 23 | #define GLI_DISABLE_ASSERT 0 24 | 25 | #if defined(NDEBUG) || GLI_DISABLE_ASSERT 26 | # define GLI_ASSERT(test) 27 | #else 28 | # define GLI_ASSERT(test) assert((test)) 29 | #endif 30 | 31 | namespace gli 32 | { 33 | using namespace glm; 34 | 35 | using std::size_t; 36 | 37 | typedef ivec1 extent1d; 38 | typedef ivec2 extent2d; 39 | typedef ivec3 extent3d; 40 | typedef ivec4 extent4d; 41 | 42 | template 43 | inline vec<4, T, P> make_vec4(vec<1, T, P> const & v) 44 | { 45 | return vec<4, T, P>(v.x, static_cast(0), static_cast(0), static_cast(1)); 46 | } 47 | 48 | template 49 | inline vec<4, T, P> make_vec4(vec<2, T, P> const & v) 50 | { 51 | return vec<4, T, P>(v.x, v.y, static_cast(0), static_cast(1)); 52 | } 53 | 54 | template 55 | inline vec<4, T, P> make_vec4(vec<3, T, P> const & v) 56 | { 57 | return vec<4, T, P>(v.x, v.y, v.z, static_cast(1)); 58 | } 59 | 60 | template 61 | inline vec<4, T, P> make_vec4(vec<4, T, P> const & v) 62 | { 63 | return v; 64 | } 65 | }//namespace gli 66 | -------------------------------------------------------------------------------- /third-party/glm/common.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/common.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/func_common.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/detail/_fixes.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/_fixes.hpp 3 | 4 | #include 5 | 6 | //! Workaround for compatibility with other libraries 7 | #ifdef max 8 | #undef max 9 | #endif 10 | 11 | //! Workaround for compatibility with other libraries 12 | #ifdef min 13 | #undef min 14 | #endif 15 | 16 | //! Workaround for Android 17 | #ifdef isnan 18 | #undef isnan 19 | #endif 20 | 21 | //! Workaround for Android 22 | #ifdef isinf 23 | #undef isinf 24 | #endif 25 | 26 | //! Workaround for Chrone Native Client 27 | #ifdef log2 28 | #undef log2 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /third-party/glm/detail/func_exponential_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_exponential_simd.inl 3 | 4 | #include "../simd/exponential.h" 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | template 12 | struct compute_sqrt<4, float, P, true> 13 | { 14 | GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v) 15 | { 16 | vec<4, float, P> result(uninitialize); 17 | result.data = _mm_sqrt_ps(v.data); 18 | return result; 19 | } 20 | }; 21 | 22 | template<> 23 | struct compute_sqrt<4, float, aligned_lowp, true> 24 | { 25 | GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const & v) 26 | { 27 | vec<4, float, aligned_lowp> result(uninitialize); 28 | result.data = glm_vec4_sqrt_lowp(v.data); 29 | return result; 30 | } 31 | }; 32 | }//namespace detail 33 | }//namespace glm 34 | 35 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 36 | -------------------------------------------------------------------------------- /third-party/glm/detail/func_integer_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_integer_simd.inl 3 | 4 | #include "../simd/integer.h" 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | template 12 | struct compute_bitfieldReverseStep<4, uint32, P, vec, true, true> 13 | { 14 | GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & v, uint32 Mask, uint32 Shift) 15 | { 16 | __m128i const set0 = v.data; 17 | 18 | __m128i const set1 = _mm_set1_epi32(Mask); 19 | __m128i const and1 = _mm_and_si128(set0, set1); 20 | __m128i const sft1 = _mm_slli_epi32(and1, Shift); 21 | 22 | __m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1)); 23 | __m128i const and2 = _mm_and_si128(set0, set2); 24 | __m128i const sft2 = _mm_srai_epi32(and2, Shift); 25 | 26 | __m128i const or0 = _mm_or_si128(sft1, sft2); 27 | 28 | return or0; 29 | } 30 | }; 31 | 32 | template 33 | struct compute_bitfieldBitCountStep<4, uint32, P, vec, true, true> 34 | { 35 | GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & v, uint32 Mask, uint32 Shift) 36 | { 37 | __m128i const set0 = v.data; 38 | 39 | __m128i const set1 = _mm_set1_epi32(Mask); 40 | __m128i const and0 = _mm_and_si128(set0, set1); 41 | __m128i const sft0 = _mm_slli_epi32(set0, Shift); 42 | __m128i const and1 = _mm_and_si128(sft0, set1); 43 | __m128i const add0 = _mm_add_epi32(and0, and1); 44 | 45 | return add0; 46 | } 47 | }; 48 | }//namespace detail 49 | 50 | # if GLM_ARCH & GLM_ARCH_AVX_BIT 51 | template<> 52 | GLM_FUNC_QUALIFIER int bitCount(uint32 x) 53 | { 54 | return _mm_popcnt_u32(x); 55 | } 56 | 57 | # if(GLM_MODEL == GLM_MODEL_64) 58 | template<> 59 | GLM_FUNC_QUALIFIER int bitCount(uint64 x) 60 | { 61 | return static_cast(_mm_popcnt_u64(x)); 62 | } 63 | # endif//GLM_MODEL 64 | # endif//GLM_ARCH 65 | 66 | }//namespace glm 67 | 68 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 69 | -------------------------------------------------------------------------------- /third-party/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_packing_simd.inl 3 | 4 | namespace glm{ 5 | namespace detail 6 | { 7 | 8 | }//namespace detail 9 | }//namespace glm 10 | -------------------------------------------------------------------------------- /third-party/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/third-party/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /third-party/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_vector_relational_simd.inl 3 | 4 | namespace glm{ 5 | namespace detail 6 | { 7 | 8 | }//namespace detail 9 | }//namespace glm 10 | -------------------------------------------------------------------------------- /third-party/glm/detail/precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/precision.hpp 3 | 4 | #pragma once 5 | 6 | #include "setup.hpp" 7 | 8 | namespace glm 9 | { 10 | enum precision 11 | { 12 | packed_highp, 13 | packed_mediump, 14 | packed_lowp, 15 | 16 | # if GLM_HAS_ALIGNED_TYPE 17 | aligned_highp, 18 | aligned_mediump, 19 | aligned_lowp, 20 | aligned = aligned_highp, 21 | # endif 22 | 23 | highp = packed_highp, 24 | mediump = packed_mediump, 25 | lowp = packed_lowp, 26 | packed = packed_highp, 27 | 28 | # if GLM_HAS_ALIGNED_TYPE && defined(GLM_FORCE_ALIGNED) 29 | defaultp = aligned_highp 30 | # else 31 | defaultp = highp 32 | # endif 33 | }; 34 | 35 | template struct vec; 36 | template struct mat; 37 | 38 | namespace detail 39 | { 40 | template 41 | struct is_aligned 42 | { 43 | static const bool value = false; 44 | }; 45 | 46 | # if GLM_HAS_ALIGNED_TYPE 47 | template<> 48 | struct is_aligned 49 | { 50 | static const bool value = true; 51 | }; 52 | 53 | template<> 54 | struct is_aligned 55 | { 56 | static const bool value = true; 57 | }; 58 | 59 | template<> 60 | struct is_aligned 61 | { 62 | static const bool value = true; 63 | }; 64 | # endif 65 | }//namespace detail 66 | }//namespace glm 67 | -------------------------------------------------------------------------------- /third-party/glm/detail/type_half.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_half.hpp 3 | 4 | #pragma once 5 | 6 | #include "setup.hpp" 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | typedef short hdata; 12 | 13 | GLM_FUNC_DECL float toFloat32(hdata value); 14 | GLM_FUNC_DECL hdata toFloat16(float const & value); 15 | 16 | }//namespace detail 17 | }//namespace glm 18 | 19 | #include "type_half.inl" 20 | -------------------------------------------------------------------------------- /third-party/glm/detail/type_mat.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_mat.inl 3 | 4 | -------------------------------------------------------------------------------- /third-party/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_mat4x4_sse2.inl 3 | 4 | namespace glm 5 | { 6 | 7 | }//namespace glm 8 | -------------------------------------------------------------------------------- /third-party/glm/detail/type_vec.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_vec.inl 3 | -------------------------------------------------------------------------------- /third-party/glm/exponential.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/exponential.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/func_exponential.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/geometric.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/geometric.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/func_geometric.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/gtc/color_space.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_color_space 2 | /// @file glm/gtc/color_space.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_color_space (dependence) 6 | /// 7 | /// @defgroup gtc_color_space GLM_GTC_color_space 8 | /// @ingroup gtc 9 | /// 10 | /// @brief Allow to perform bit operations on integer values 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/precision.hpp" 19 | #include "../exponential.hpp" 20 | #include "../vec3.hpp" 21 | #include "../vec4.hpp" 22 | #include 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTC_color_space extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtc_color_space 31 | /// @{ 32 | 33 | /// Convert a linear color to sRGB color using a standard gamma correction. 34 | /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 35 | template class vecType> 36 | GLM_FUNC_DECL vecType convertLinearToSRGB(vecType const & ColorLinear); 37 | 38 | /// Convert a linear color to sRGB color using a custom gamma correction. 39 | /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 40 | template class vecType> 41 | GLM_FUNC_DECL vecType convertLinearToSRGB(vecType const & ColorLinear, T Gamma); 42 | 43 | /// Convert a sRGB color to linear color using a standard gamma correction. 44 | /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 45 | template class vecType> 46 | GLM_FUNC_DECL vecType convertSRGBToLinear(vecType const & ColorSRGB); 47 | 48 | /// Convert a sRGB color to linear color using a custom gamma correction. 49 | // IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 50 | template class vecType> 51 | GLM_FUNC_DECL vecType convertSRGBToLinear(vecType const & ColorSRGB, T Gamma); 52 | 53 | /// @} 54 | } //namespace glm 55 | 56 | #include "color_space.inl" 57 | -------------------------------------------------------------------------------- /third-party/glm/gtc/epsilon.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_epsilon 2 | /// @file glm/gtc/epsilon.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_quaternion (dependence) 6 | /// 7 | /// @defgroup gtc_epsilon GLM_GTC_epsilon 8 | /// @ingroup gtc 9 | /// 10 | /// @brief Comparison functions for a user defined epsilon values. 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/precision.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTC_epsilon extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtc_epsilon 27 | /// @{ 28 | 29 | /// Returns the component-wise comparison of |x - y| < epsilon. 30 | /// True if this expression is satisfied. 31 | /// 32 | /// @see gtc_epsilon 33 | template class vecType> 34 | GLM_FUNC_DECL vecType epsilonEqual( 35 | vecType const& x, 36 | vecType const& y, 37 | T const & epsilon); 38 | 39 | /// Returns the component-wise comparison of |x - y| < epsilon. 40 | /// True if this expression is satisfied. 41 | /// 42 | /// @see gtc_epsilon 43 | template 44 | GLM_FUNC_DECL bool epsilonEqual( 45 | genType const & x, 46 | genType const & y, 47 | genType const & epsilon); 48 | 49 | /// Returns the component-wise comparison of |x - y| < epsilon. 50 | /// True if this expression is not satisfied. 51 | /// 52 | /// @see gtc_epsilon 53 | template 54 | GLM_FUNC_DECL typename genType::boolType epsilonNotEqual( 55 | genType const & x, 56 | genType const & y, 57 | typename genType::value_type const & epsilon); 58 | 59 | /// Returns the component-wise comparison of |x - y| >= epsilon. 60 | /// True if this expression is not satisfied. 61 | /// 62 | /// @see gtc_epsilon 63 | template 64 | GLM_FUNC_DECL bool epsilonNotEqual( 65 | genType const & x, 66 | genType const & y, 67 | genType const & epsilon); 68 | 69 | /// @} 70 | }//namespace glm 71 | 72 | #include "epsilon.inl" 73 | -------------------------------------------------------------------------------- /third-party/glm/gtc/functions.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_functions 2 | /// @file glm/gtc/functions.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_quaternion (dependence) 6 | /// 7 | /// @defgroup gtc_functions GLM_GTC_functions 8 | /// @ingroup gtc 9 | /// 10 | /// @brief List of useful common functions. 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/precision.hpp" 19 | #include "../detail/type_vec2.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 22 | # pragma message("GLM: GLM_GTC_functions extension included") 23 | #endif 24 | 25 | namespace glm 26 | { 27 | /// @addtogroup gtc_functions 28 | /// @{ 29 | 30 | /// 1D gauss function 31 | /// 32 | /// @see gtc_epsilon 33 | template 34 | GLM_FUNC_DECL T gauss( 35 | T x, 36 | T ExpectedValue, 37 | T StandardDeviation); 38 | 39 | /// 2D gauss function 40 | /// 41 | /// @see gtc_epsilon 42 | template 43 | GLM_FUNC_DECL T gauss( 44 | vec<2, T, P> const& Coord, 45 | vec<2, T, P> const& ExpectedValue, 46 | vec<2, T, P> const& StandardDeviation); 47 | 48 | /// @} 49 | }//namespace glm 50 | 51 | #include "functions.inl" 52 | 53 | -------------------------------------------------------------------------------- /third-party/glm/gtc/functions.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_functions 2 | /// @file glm/gtc/functions.inl 3 | 4 | #include "../detail/func_exponential.hpp" 5 | 6 | namespace glm 7 | { 8 | template 9 | GLM_FUNC_QUALIFIER T gauss 10 | ( 11 | T x, 12 | T ExpectedValue, 13 | T StandardDeviation 14 | ) 15 | { 16 | return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER T gauss 21 | ( 22 | vec<2, T, P> const& Coord, 23 | vec<2, T, P> const& ExpectedValue, 24 | vec<2, T, P> const& StandardDeviation 25 | ) 26 | { 27 | vec<2, T, P> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation); 28 | return exp(-(Squared.x + Squared.y)); 29 | } 30 | }//namespace glm 31 | 32 | -------------------------------------------------------------------------------- /third-party/glm/gtc/matrix_access.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_access 2 | /// @file glm/gtc/matrix_access.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_matrix_access GLM_GTC_matrix_access 7 | /// @ingroup gtc 8 | /// 9 | /// Defines functions to access rows or columns of a matrix easily. 10 | /// need to be included to use these functionalities. 11 | 12 | #pragma once 13 | 14 | // Dependency: 15 | #include "../detail/setup.hpp" 16 | 17 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 18 | # pragma message("GLM: GLM_GTC_matrix_access extension included") 19 | #endif 20 | 21 | namespace glm 22 | { 23 | /// @addtogroup gtc_matrix_access 24 | /// @{ 25 | 26 | /// Get a specific row of a matrix. 27 | /// @see gtc_matrix_access 28 | template 29 | GLM_FUNC_DECL typename genType::row_type row( 30 | genType const & m, 31 | length_t index); 32 | 33 | /// Set a specific row to a matrix. 34 | /// @see gtc_matrix_access 35 | template 36 | GLM_FUNC_DECL genType row( 37 | genType const & m, 38 | length_t index, 39 | typename genType::row_type const & x); 40 | 41 | /// Get a specific column of a matrix. 42 | /// @see gtc_matrix_access 43 | template 44 | GLM_FUNC_DECL typename genType::col_type column( 45 | genType const & m, 46 | length_t index); 47 | 48 | /// Set a specific column to a matrix. 49 | /// @see gtc_matrix_access 50 | template 51 | GLM_FUNC_DECL genType column( 52 | genType const & m, 53 | length_t index, 54 | typename genType::col_type const & x); 55 | 56 | /// @} 57 | }//namespace glm 58 | 59 | #include "matrix_access.inl" 60 | -------------------------------------------------------------------------------- /third-party/glm/gtc/matrix_access.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_access 2 | /// @file glm/gtc/matrix_access.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType row 8 | ( 9 | genType const & m, 10 | length_t index, 11 | typename genType::row_type const & x 12 | ) 13 | { 14 | assert(index >= 0 && index < m[0].length()); 15 | 16 | genType Result = m; 17 | for(length_t i = 0; i < m.length(); ++i) 18 | Result[i][index] = x[i]; 19 | return Result; 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER typename genType::row_type row 24 | ( 25 | genType const & m, 26 | length_t index 27 | ) 28 | { 29 | assert(index >= 0 && index < m[0].length()); 30 | 31 | typename genType::row_type Result; 32 | for(length_t i = 0; i < m.length(); ++i) 33 | Result[i] = m[i][index]; 34 | return Result; 35 | } 36 | 37 | template 38 | GLM_FUNC_QUALIFIER genType column 39 | ( 40 | genType const & m, 41 | length_t index, 42 | typename genType::col_type const & x 43 | ) 44 | { 45 | assert(index >= 0 && index < m.length()); 46 | 47 | genType Result = m; 48 | Result[index] = x; 49 | return Result; 50 | } 51 | 52 | template 53 | GLM_FUNC_QUALIFIER typename genType::col_type column 54 | ( 55 | genType const & m, 56 | length_t index 57 | ) 58 | { 59 | assert(index >= 0 && index < m.length()); 60 | 61 | return m[index]; 62 | } 63 | }//namespace glm 64 | -------------------------------------------------------------------------------- /third-party/glm/gtc/matrix_inverse.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_inverse 2 | /// @file glm/gtc/matrix_inverse.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse 7 | /// @ingroup gtc 8 | /// 9 | /// Defines additional matrix inverting functions. 10 | /// need to be included to use these functionalities. 11 | 12 | #pragma once 13 | 14 | // Dependencies 15 | #include "../detail/setup.hpp" 16 | #include "../matrix.hpp" 17 | #include "../mat2x2.hpp" 18 | #include "../mat3x3.hpp" 19 | #include "../mat4x4.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 22 | # pragma message("GLM: GLM_GTC_matrix_inverse extension included") 23 | #endif 24 | 25 | namespace glm 26 | { 27 | /// @addtogroup gtc_matrix_inverse 28 | /// @{ 29 | 30 | /// Fast matrix inverse for affine matrix. 31 | /// 32 | /// @param m Input matrix to invert. 33 | /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate. 34 | /// @see gtc_matrix_inverse 35 | template 36 | GLM_FUNC_DECL genType affineInverse(genType const & m); 37 | 38 | /// Compute the inverse transpose of a matrix. 39 | /// 40 | /// @param m Input matrix to invert transpose. 41 | /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate. 42 | /// @see gtc_matrix_inverse 43 | template 44 | GLM_FUNC_DECL genType inverseTranspose(genType const & m); 45 | 46 | /// @} 47 | }//namespace glm 48 | 49 | #include "matrix_inverse.inl" 50 | -------------------------------------------------------------------------------- /third-party/glm/gtc/noise.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_noise 2 | /// @file glm/gtc/noise.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_noise GLM_GTC_noise 7 | /// @ingroup gtc 8 | /// 9 | /// Defines 2D, 3D and 4D procedural noise functions 10 | /// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 11 | /// https://github.com/ashima/webgl-noise 12 | /// Following Stefan Gustavson's paper "Simplex noise demystified": 13 | /// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf 14 | /// need to be included to use these functionalities. 15 | 16 | #pragma once 17 | 18 | // Dependencies 19 | #include "../detail/setup.hpp" 20 | #include "../detail/precision.hpp" 21 | #include "../detail/_noise.hpp" 22 | #include "../geometric.hpp" 23 | #include "../common.hpp" 24 | #include "../vector_relational.hpp" 25 | #include "../vec2.hpp" 26 | #include "../vec3.hpp" 27 | #include "../vec4.hpp" 28 | 29 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 30 | # pragma message("GLM: GLM_GTC_noise extension included") 31 | #endif 32 | 33 | namespace glm 34 | { 35 | /// @addtogroup gtc_noise 36 | /// @{ 37 | 38 | /// Classic perlin noise. 39 | /// @see gtc_noise 40 | template class vecType> 41 | GLM_FUNC_DECL T perlin( 42 | vecType const& p); 43 | 44 | /// Periodic perlin noise. 45 | /// @see gtc_noise 46 | template class vecType> 47 | GLM_FUNC_DECL T perlin( 48 | vecType const& p, 49 | vecType const& rep); 50 | 51 | /// Simplex noise. 52 | /// @see gtc_noise 53 | template class vecType> 54 | GLM_FUNC_DECL T simplex( 55 | vecType const& p); 56 | 57 | /// @} 58 | }//namespace glm 59 | 60 | #include "noise.inl" 61 | -------------------------------------------------------------------------------- /third-party/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_swizzle 2 | /// @file glm/gtc/swizzle.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /third-party/glm/gtc/ulp.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_ulp 2 | /// @file glm/gtc/ulp.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_ulp GLM_GTC_ulp 7 | /// @ingroup gtc 8 | /// 9 | /// @brief Allow the measurement of the accuracy of a function against a reference 10 | /// implementation. This extension works on floating-point data and provide results 11 | /// in ULP. 12 | /// need to be included to use these features. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/precision.hpp" 19 | #include "../detail/type_int.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 22 | # pragma message("GLM: GLM_GTC_ulp extension included") 23 | #endif 24 | 25 | namespace glm 26 | { 27 | /// @addtogroup gtc_ulp 28 | /// @{ 29 | 30 | /// Return the next ULP value(s) after the input value(s). 31 | /// @see gtc_ulp 32 | template 33 | GLM_FUNC_DECL genType next_float(genType const & x); 34 | 35 | /// Return the previous ULP value(s) before the input value(s). 36 | /// @see gtc_ulp 37 | template 38 | GLM_FUNC_DECL genType prev_float(genType const & x); 39 | 40 | /// Return the value(s) ULP distance after the input value(s). 41 | /// @see gtc_ulp 42 | template 43 | GLM_FUNC_DECL genType next_float(genType const & x, uint const & Distance); 44 | 45 | /// Return the value(s) ULP distance before the input value(s). 46 | /// @see gtc_ulp 47 | template 48 | GLM_FUNC_DECL genType prev_float(genType const & x, uint const & Distance); 49 | 50 | /// Return the distance in the number of ULP between 2 scalars. 51 | /// @see gtc_ulp 52 | template 53 | GLM_FUNC_DECL uint float_distance(T const & x, T const & y); 54 | 55 | /// Return the distance in the number of ULP between 2 vectors. 56 | /// @see gtc_ulp 57 | template class vecType> 58 | GLM_FUNC_DECL vecType<2, uint> float_distance(vecType<2, T> const & x, vecType<2, T> const & y); 59 | 60 | /// @} 61 | }// namespace glm 62 | 63 | #include "ulp.inl" 64 | -------------------------------------------------------------------------------- /third-party/glm/gtc/vec1.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_vec1 2 | /// @file glm/gtc/vec1.inl 3 | -------------------------------------------------------------------------------- /third-party/glm/gtx/closest_point.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_closest_point 2 | /// @file glm/gtx/closest_point.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_closest_point GLM_GTX_closest_point 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Find the point on a straight line which is the closet of a point. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_closest_point extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_closest_point 29 | /// @{ 30 | 31 | /// Find the point on a straight line which is the closet of a point. 32 | /// @see gtx_closest_point 33 | template 34 | GLM_FUNC_DECL vec<3, T, P> closestPointOnLine( 35 | vec<3, T, P> const & point, 36 | vec<3, T, P> const & a, 37 | vec<3, T, P> const & b); 38 | 39 | /// 2d lines work as well 40 | template 41 | GLM_FUNC_DECL vec<2, T, P> closestPointOnLine( 42 | vec<2, T, P> const & point, 43 | vec<2, T, P> const & a, 44 | vec<2, T, P> const & b); 45 | 46 | /// @} 47 | }// namespace glm 48 | 49 | #include "closest_point.inl" 50 | -------------------------------------------------------------------------------- /third-party/glm/gtx/closest_point.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_closest_point 2 | /// @file glm/gtx/closest_point.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, P> closestPointOnLine 8 | ( 9 | vec<3, T, P> const & point, 10 | vec<3, T, P> const & a, 11 | vec<3, T, P> const & b 12 | ) 13 | { 14 | T LineLength = distance(a, b); 15 | vec<3, T, P> Vector = point - a; 16 | vec<3, T, P> LineDirection = (b - a) / LineLength; 17 | 18 | // Project Vector to LineDirection to get the distance of point from a 19 | T Distance = dot(Vector, LineDirection); 20 | 21 | if(Distance <= T(0)) return a; 22 | if(Distance >= LineLength) return b; 23 | return a + LineDirection * Distance; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER vec<2, T, P> closestPointOnLine 28 | ( 29 | vec<2, T, P> const & point, 30 | vec<2, T, P> const & a, 31 | vec<2, T, P> const & b 32 | ) 33 | { 34 | T LineLength = distance(a, b); 35 | vec<2, T, P> Vector = point - a; 36 | vec<2, T, P> LineDirection = (b - a) / LineLength; 37 | 38 | // Project Vector to LineDirection to get the distance of point from a 39 | T Distance = dot(Vector, LineDirection); 40 | 41 | if(Distance <= T(0)) return a; 42 | if(Distance >= LineLength) return b; 43 | return a + LineDirection * Distance; 44 | } 45 | 46 | }//namespace glm 47 | -------------------------------------------------------------------------------- /third-party/glm/gtx/color_encoding.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_encoding 2 | /// @file glm/gtx/color_encoding.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_color_encoding (dependence) 6 | /// 7 | /// @defgroup gtx_color_encoding GLM_GTX_color_encoding 8 | /// @ingroup gtx 9 | /// 10 | /// @brief Allow to perform bit operations on integer values 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/precision.hpp" 19 | #include "../vec3.hpp" 20 | #include 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTC_color_encoding extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_encoding 29 | /// @{ 30 | 31 | /// Convert a linear sRGB color to D65 YUV. 32 | template 33 | GLM_FUNC_DECL vec<3, T, P> convertLinearSRGBToD65XYZ(vec<3, T, P> const& ColorLinearSRGB); 34 | 35 | /// Convert a linear sRGB color to D50 YUV. 36 | template 37 | GLM_FUNC_DECL vec<3, T, P> convertLinearSRGBToD50XYZ(vec<3, T, P> const& ColorLinearSRGB); 38 | 39 | /// Convert a D65 YUV color to linear sRGB. 40 | template 41 | GLM_FUNC_DECL vec<3, T, P> convertD65XYZToLinearSRGB(vec<3, T, P> const& ColorD65XYZ); 42 | 43 | /// Convert a D65 YUV color to D50 YUV. 44 | template 45 | GLM_FUNC_DECL vec<3, T, P> convertD65XYZToD50XYZ(vec<3, T, P> const& ColorD65XYZ); 46 | 47 | /// @} 48 | } //namespace glm 49 | 50 | #include "color_encoding.inl" 51 | -------------------------------------------------------------------------------- /third-party/glm/gtx/color_encoding.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_encoding 2 | /// @file glm/gtx/color_encoding.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, P> convertLinearSRGBToD65XYZ(vec<3, T, P> const& ColorLinearSRGB) 8 | { 9 | vec<3, T, P> const M(0.490f, 0.17697f, 0.2f); 10 | vec<3, T, P> const N(0.31f, 0.8124f, 0.01063f); 11 | vec<3, T, P> const O(0.490f, 0.01f, 0.99f); 12 | 13 | return (M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB) * static_cast(5.650675255693055f); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER vec<3, T, P> convertLinearSRGBToD50XYZ(vec<3, T, P> const& ColorLinearSRGB) 18 | { 19 | vec<3, T, P> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f); 20 | vec<3, T, P> const N(0.385101860087134f, 0.716942745571917f, 0.097076381494207f); 21 | vec<3, T, P> const O(0.143067806654203f, 0.060618777416563f, 0.713926257896652f); 22 | 23 | return M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER vec<3, T, P> convertD65XYZToLinearSRGB(vec<3, T, P> const& ColorD65XYZ) 28 | { 29 | vec<3, T, P> const M(0.41847f, -0.091169f, 0.0009209f); 30 | vec<3, T, P> const N(-0.15866f, 0.25243f, 0.015708f); 31 | vec<3, T, P> const O(0.0009209f, -0.0025498f, 0.1786f); 32 | 33 | return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER vec<3, T, P> convertD65XYZToD50XYZ(vec<3, T, P> const& ColorD65XYZ) 38 | { 39 | vec<3, T, P> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f); 40 | vec<3, T, P> const N(+0.022898981050086f, +0.990508028941971f, +0.015072338237051f); 41 | vec<3, T, P> const O(-0.050206647741605f, -0.017074711360960f, +0.751717835079977f); 42 | 43 | return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; 44 | } 45 | 46 | }//namespace glm 47 | -------------------------------------------------------------------------------- /third-party/glm/gtx/color_space.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_space 2 | /// @file glm/gtx/color_space.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_color_space GLM_GTX_color_space 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Related to RGB to HSV conversions and operations. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_color_space extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_space 29 | /// @{ 30 | 31 | /// Converts a color from HSV color space to its color in RGB color space. 32 | /// @see gtx_color_space 33 | template 34 | GLM_FUNC_DECL vec<3, T, P> rgbColor( 35 | vec<3, T, P> const & hsvValue); 36 | 37 | /// Converts a color from RGB color space to its color in HSV color space. 38 | /// @see gtx_color_space 39 | template 40 | GLM_FUNC_DECL vec<3, T, P> hsvColor( 41 | vec<3, T, P> const & rgbValue); 42 | 43 | /// Build a saturation matrix. 44 | /// @see gtx_color_space 45 | template 46 | GLM_FUNC_DECL mat<4, 4, T, defaultp> saturation( 47 | T const s); 48 | 49 | /// Modify the saturation of a color. 50 | /// @see gtx_color_space 51 | template 52 | GLM_FUNC_DECL vec<3, T, P> saturation( 53 | T const s, 54 | vec<3, T, P> const & color); 55 | 56 | /// Modify the saturation of a color. 57 | /// @see gtx_color_space 58 | template 59 | GLM_FUNC_DECL vec<4, T, P> saturation( 60 | T const s, 61 | vec<4, T, P> const & color); 62 | 63 | /// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals. 64 | /// @see gtx_color_space 65 | template 66 | GLM_FUNC_DECL T luminosity( 67 | vec<3, T, P> const & color); 68 | 69 | /// @} 70 | }//namespace glm 71 | 72 | #include "color_space.inl" 73 | -------------------------------------------------------------------------------- /third-party/glm/gtx/color_space_YCoCg.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_space_YCoCg 2 | /// @file glm/gtx/color_space_YCoCg.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg 7 | /// @ingroup gtx 8 | /// 9 | /// @brief RGB to YCoCg conversions and operations 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_color_space_YCoCg extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_space_YCoCg 29 | /// @{ 30 | 31 | /// Convert a color from RGB color space to YCoCg color space. 32 | /// @see gtx_color_space_YCoCg 33 | template 34 | GLM_FUNC_DECL vec<3, T, P> rgb2YCoCg( 35 | vec<3, T, P> const & rgbColor); 36 | 37 | /// Convert a color from YCoCg color space to RGB color space. 38 | /// @see gtx_color_space_YCoCg 39 | template 40 | GLM_FUNC_DECL vec<3, T, P> YCoCg2rgb( 41 | vec<3, T, P> const & YCoCgColor); 42 | 43 | /// Convert a color from RGB color space to YCoCgR color space. 44 | /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" 45 | /// @see gtx_color_space_YCoCg 46 | template 47 | GLM_FUNC_DECL vec<3, T, P> rgb2YCoCgR( 48 | vec<3, T, P> const & rgbColor); 49 | 50 | /// Convert a color from YCoCgR color space to RGB color space. 51 | /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" 52 | /// @see gtx_color_space_YCoCg 53 | template 54 | GLM_FUNC_DECL vec<3, T, P> YCoCgR2rgb( 55 | vec<3, T, P> const & YCoCgColor); 56 | 57 | /// @} 58 | }//namespace glm 59 | 60 | #include "color_space_YCoCg.inl" 61 | -------------------------------------------------------------------------------- /third-party/glm/gtx/common.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_common 2 | /// @file glm/gtx/common.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_common GLM_GTX_common 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Provide functions to increase the compatibility with Cg and HLSL languages 10 | /// 11 | /// need to be included to use these functionalities. 12 | 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 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "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." 23 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_common extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_common 32 | /// @{ 33 | 34 | /// Returns true if x is a denormalized number 35 | /// Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format. 36 | /// This format is less precise but can represent values closer to zero. 37 | /// 38 | /// @tparam genType Floating-point scalar or vector types. 39 | /// 40 | /// @see GLSL isnan man page 41 | /// @see GLSL 4.20.8 specification, section 8.3 Common Functions 42 | template 43 | GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const & x); 44 | 45 | /// Similar to 'mod' but with a different rounding and integer support. 46 | /// Returns 'x - y * trunc(x/y)' instead of 'x - y * floor(x/y)' 47 | /// 48 | /// @see GLSL mod vs HLSL fmod 49 | /// @see GLSL mod man page 50 | template class vecType> 51 | GLM_FUNC_DECL vecType fmod(vecType const & v); 52 | 53 | /// @} 54 | }//namespace glm 55 | 56 | #include "common.inl" 57 | -------------------------------------------------------------------------------- /third-party/glm/gtx/compatibility.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_compatibility 2 | /// @file glm/gtx/compatibility.inl 3 | 4 | #include 5 | 6 | namespace glm 7 | { 8 | // isfinite 9 | template 10 | GLM_FUNC_QUALIFIER bool isfinite( 11 | genType const & x) 12 | { 13 | # if GLM_HAS_CXX11_STL 14 | return std::isfinite(x) != 0; 15 | # elif GLM_COMPILER & GLM_COMPILER_VC 16 | return _finite(x); 17 | # elif GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID 18 | return _isfinite(x) != 0; 19 | # else 20 | if (std::numeric_limits::is_integer || std::denorm_absent == std::numeric_limits::has_denorm) 21 | return std::numeric_limits::min() <= x && std::numeric_limits::max() >= x; 22 | else 23 | return -std::numeric_limits::max() <= x && std::numeric_limits::max() >= x; 24 | # endif 25 | } 26 | 27 | template 28 | GLM_FUNC_QUALIFIER vec<1, bool, P> isfinite( 29 | vec<1, T, P> const & x) 30 | { 31 | return vec<1, bool, P>( 32 | isfinite(x.x)); 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER vec<2, bool, P> isfinite( 37 | vec<2, T, P> const & x) 38 | { 39 | return vec<2, bool, P>( 40 | isfinite(x.x), 41 | isfinite(x.y)); 42 | } 43 | 44 | template 45 | GLM_FUNC_QUALIFIER vec<3, bool, P> isfinite( 46 | vec<3, T, P> const & x) 47 | { 48 | return vec<3, bool, P>( 49 | isfinite(x.x), 50 | isfinite(x.y), 51 | isfinite(x.z)); 52 | } 53 | 54 | template 55 | GLM_FUNC_QUALIFIER vec<4, bool, P> isfinite( 56 | vec<4, T, P> const & x) 57 | { 58 | return vec<4, bool, P>( 59 | isfinite(x.x), 60 | isfinite(x.y), 61 | isfinite(x.z), 62 | isfinite(x.w)); 63 | } 64 | 65 | }//namespace glm 66 | -------------------------------------------------------------------------------- /third-party/glm/gtx/extend.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_extend 2 | /// @file glm/gtx/extend.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_extend GLM_GTX_extend 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Extend a position from a source to a position at a defined length. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_extend extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_extend 29 | /// @{ 30 | 31 | /// Extends of Length the Origin position using the (Source - Origin) direction. 32 | /// @see gtx_extend 33 | template 34 | GLM_FUNC_DECL genType extend( 35 | genType const & Origin, 36 | genType const & Source, 37 | typename genType::value_type const Length); 38 | 39 | /// @} 40 | }//namespace glm 41 | 42 | #include "extend.inl" 43 | -------------------------------------------------------------------------------- /third-party/glm/gtx/extend.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_extend 2 | /// @file glm/gtx/extend.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType extend 8 | ( 9 | genType const & Origin, 10 | genType const & Source, 11 | genType const & Distance 12 | ) 13 | { 14 | return Origin + (Source - Origin) * Distance; 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER vec<2, T, P> extend 19 | ( 20 | vec<2, T, P> const & Origin, 21 | vec<2, T, P> const & Source, 22 | T const & Distance 23 | ) 24 | { 25 | return Origin + (Source - Origin) * Distance; 26 | } 27 | 28 | template 29 | GLM_FUNC_QUALIFIER vec<3, T, P> extend 30 | ( 31 | vec<3, T, P> const & Origin, 32 | vec<3, T, P> const & Source, 33 | T const & Distance 34 | ) 35 | { 36 | return Origin + (Source - Origin) * Distance; 37 | } 38 | 39 | template 40 | GLM_FUNC_QUALIFIER vec<4, T, P> extend 41 | ( 42 | vec<4, T, P> const & Origin, 43 | vec<4, T, P> const & Source, 44 | T const & Distance 45 | ) 46 | { 47 | return Origin + (Source - Origin) * Distance; 48 | } 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /third-party/glm/gtx/float_notmalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_float_normalize 2 | /// @file glm/gtx/float_normalize.inl 3 | 4 | #include 5 | 6 | namespace glm 7 | { 8 | template class vecType> 9 | GLM_FUNC_QUALIFIER vecType floatNormalize(vecType const & v) 10 | { 11 | return vecType(v) / static_cast(std::numeric_limits::max()); 12 | } 13 | 14 | }//namespace glm 15 | -------------------------------------------------------------------------------- /third-party/glm/gtx/gradient_paint.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | /// @file glm/gtx/gradient_paint.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_optimum_pow (dependence) 6 | /// 7 | /// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint 8 | /// @ingroup gtx 9 | /// 10 | /// @brief Functions that return the color of procedural gradient for specific coordinates. 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtx/optimum_pow.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "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." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_gradient_paint extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_gradient_paint 30 | /// @{ 31 | 32 | /// Return a color from a radial gradient. 33 | /// @see - gtx_gradient_paint 34 | template 35 | GLM_FUNC_DECL T radialGradient( 36 | vec<2, T, P> const & Center, 37 | T const & Radius, 38 | vec<2, T, P> const & Focal, 39 | vec<2, T, P> const & Position); 40 | 41 | /// Return a color from a linear gradient. 42 | /// @see - gtx_gradient_paint 43 | template 44 | GLM_FUNC_DECL T linearGradient( 45 | vec<2, T, P> const & Point0, 46 | vec<2, T, P> const & Point1, 47 | vec<2, T, P> const & Position); 48 | 49 | /// @} 50 | }// namespace glm 51 | 52 | #include "gradient_paint.inl" 53 | -------------------------------------------------------------------------------- /third-party/glm/gtx/gradient_paint.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | /// @file glm/gtx/gradient_paint.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER T radialGradient 8 | ( 9 | vec<2, T, P> const & Center, 10 | T const & Radius, 11 | vec<2, T, P> const & Focal, 12 | vec<2, T, P> const & Position 13 | ) 14 | { 15 | vec<2, T, P> F = Focal - Center; 16 | vec<2, T, P> D = Position - Focal; 17 | T Radius2 = pow2(Radius); 18 | T Fx2 = pow2(F.x); 19 | T Fy2 = pow2(F.y); 20 | 21 | T Numerator = (D.x * F.x + D.y * F.y) + sqrt(Radius2 * (pow2(D.x) + pow2(D.y)) - pow2(D.x * F.y - D.y * F.x)); 22 | T Denominator = Radius2 - (Fx2 + Fy2); 23 | return Numerator / Denominator; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER T linearGradient 28 | ( 29 | vec<2, T, P> const & Point0, 30 | vec<2, T, P> const & Point1, 31 | vec<2, T, P> const & Position 32 | ) 33 | { 34 | vec<2, T, P> Dist = Point1 - Point0; 35 | return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist); 36 | } 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /third-party/glm/gtx/handed_coordinate_space.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | /// @file glm/gtx/handed_coordinate_space.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space 7 | /// @ingroup gtx 8 | /// 9 | /// @brief To know if a set of three basis vectors defines a right or left-handed coordinate system. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_handed_coordinate_space extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_handed_coordinate_space 29 | /// @{ 30 | 31 | //! Return if a trihedron right handed or not. 32 | //! From GLM_GTX_handed_coordinate_space extension. 33 | template 34 | GLM_FUNC_DECL bool rightHanded( 35 | vec<3, T, P> const & tangent, 36 | vec<3, T, P> const & binormal, 37 | vec<3, T, P> const & normal); 38 | 39 | //! Return if a trihedron left handed or not. 40 | //! From GLM_GTX_handed_coordinate_space extension. 41 | template 42 | GLM_FUNC_DECL bool leftHanded( 43 | vec<3, T, P> const & tangent, 44 | vec<3, T, P> const & binormal, 45 | vec<3, T, P> const & normal); 46 | 47 | /// @} 48 | }// namespace glm 49 | 50 | #include "handed_coordinate_space.inl" 51 | -------------------------------------------------------------------------------- /third-party/glm/gtx/handed_coordinate_space.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | /// @file glm/gtx/handed_coordinate_space.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER bool rightHanded 8 | ( 9 | vec<3, T, P> const & tangent, 10 | vec<3, T, P> const & binormal, 11 | vec<3, T, P> const & normal 12 | ) 13 | { 14 | return dot(cross(normal, tangent), binormal) > T(0); 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER bool leftHanded 19 | ( 20 | vec<3, T, P> const & tangent, 21 | vec<3, T, P> const & binormal, 22 | vec<3, T, P> const & normal 23 | ) 24 | { 25 | return dot(cross(normal, tangent), binormal) < T(0); 26 | } 27 | }//namespace glm 28 | -------------------------------------------------------------------------------- /third-party/glm/gtx/integer.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_integer 2 | /// @file glm/gtx/integer.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_integer GLM_GTX_integer 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Add support for integer for core functions 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtc/integer.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "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." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_integer extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_integer 30 | /// @{ 31 | 32 | //! Returns x raised to the y power. 33 | //! From GLM_GTX_integer extension. 34 | GLM_FUNC_DECL int pow(int x, int y); 35 | 36 | //! Returns the positive square root of x. 37 | //! From GLM_GTX_integer extension. 38 | GLM_FUNC_DECL int sqrt(int x); 39 | 40 | //! Returns the floor log2 of x. 41 | //! From GLM_GTX_integer extension. 42 | GLM_FUNC_DECL unsigned int floor_log2(unsigned int x); 43 | 44 | //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. 45 | //! From GLM_GTX_integer extension. 46 | GLM_FUNC_DECL int mod(int x, int y); 47 | 48 | //! Return the factorial value of a number (!12 max, integer only) 49 | //! From GLM_GTX_integer extension. 50 | template 51 | GLM_FUNC_DECL genType factorial(genType const & x); 52 | 53 | //! 32bit signed integer. 54 | //! From GLM_GTX_integer extension. 55 | typedef signed int sint; 56 | 57 | //! Returns x raised to the y power. 58 | //! From GLM_GTX_integer extension. 59 | GLM_FUNC_DECL uint pow(uint x, uint y); 60 | 61 | //! Returns the positive square root of x. 62 | //! From GLM_GTX_integer extension. 63 | GLM_FUNC_DECL uint sqrt(uint x); 64 | 65 | //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. 66 | //! From GLM_GTX_integer extension. 67 | GLM_FUNC_DECL uint mod(uint x, uint y); 68 | 69 | //! Returns the number of leading zeros. 70 | //! From GLM_GTX_integer extension. 71 | GLM_FUNC_DECL uint nlz(uint x); 72 | 73 | /// @} 74 | }//namespace glm 75 | 76 | #include "integer.inl" 77 | -------------------------------------------------------------------------------- /third-party/glm/gtx/intersect.hpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/third-party/glm/gtx/intersect.hpp -------------------------------------------------------------------------------- /third-party/glm/gtx/log_base.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | /// @file glm/gtx/log_base.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_log_base GLM_GTX_log_base 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Logarithm for any base. base can be a vector or a scalar. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_log_base extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_log_base 29 | /// @{ 30 | 31 | /// Logarithm for any base. 32 | /// From GLM_GTX_log_base. 33 | template 34 | GLM_FUNC_DECL genType log( 35 | genType const & x, 36 | genType const & base); 37 | 38 | /// Logarithm for any base. 39 | /// From GLM_GTX_log_base. 40 | template class vecType> 41 | GLM_FUNC_DECL vecType sign( 42 | vecType const& x, 43 | vecType const& base); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "log_base.inl" 49 | -------------------------------------------------------------------------------- /third-party/glm/gtx/log_base.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | /// @file glm/gtx/log_base.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType log(genType const & x, genType const & base) 8 | { 9 | assert(x != genType(0)); 10 | return glm::log(x) / glm::log(base); 11 | } 12 | 13 | template class vecType> 14 | GLM_FUNC_QUALIFIER vecType log(vecType const & x, vecType const & base) 15 | { 16 | return glm::log(x) / glm::log(base); 17 | } 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /third-party/glm/gtx/matrix_cross_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | /// @file glm/gtx/matrix_cross_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product 8 | /// @ingroup gtx 9 | /// 10 | /// @brief Build cross product matrices 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_matrix_cross_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." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_matrix_cross_product extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_matrix_cross_product 30 | /// @{ 31 | 32 | //! Build a cross product matrix. 33 | //! From GLM_GTX_matrix_cross_product extension. 34 | template 35 | GLM_FUNC_DECL mat<3, 3, T, P> matrixCross3( 36 | vec<3, T, P> const & x); 37 | 38 | //! Build a cross product matrix. 39 | //! From GLM_GTX_matrix_cross_product extension. 40 | template 41 | GLM_FUNC_DECL mat<4, 4, T, P> matrixCross4( 42 | vec<3, T, P> const & x); 43 | 44 | /// @} 45 | }//namespace glm 46 | 47 | #include "matrix_cross_product.inl" 48 | -------------------------------------------------------------------------------- /third-party/glm/gtx/matrix_cross_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | /// @file glm/gtx/matrix_cross_product.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<3, 3, T, P> matrixCross3 8 | ( 9 | vec<3, T, P> const & x 10 | ) 11 | { 12 | mat<3, 3, T, P> Result(T(0)); 13 | Result[0][1] = x.z; 14 | Result[1][0] = -x.z; 15 | Result[0][2] = -x.y; 16 | Result[2][0] = x.y; 17 | Result[1][2] = x.x; 18 | Result[2][1] = -x.x; 19 | return Result; 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER mat<4, 4, T, P> matrixCross4 24 | ( 25 | vec<3, T, P> const & x 26 | ) 27 | { 28 | mat<4, 4, T, P> Result(T(0)); 29 | Result[0][1] = x.z; 30 | Result[1][0] = -x.z; 31 | Result[0][2] = -x.y; 32 | Result[2][0] = x.y; 33 | Result[1][2] = x.x; 34 | Result[2][1] = -x.x; 35 | return Result; 36 | } 37 | 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /third-party/glm/gtx/matrix_decompose.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_decompose 2 | /// @file glm/gtx/matrix_decompose.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Decomposes a model matrix to translations, rotation and scale components 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../mat4x4.hpp" 17 | #include "../vec3.hpp" 18 | #include "../vec4.hpp" 19 | #include "../geometric.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | #include "../gtc/matrix_transform.hpp" 22 | 23 | #ifndef GLM_ENABLE_EXPERIMENTAL 24 | # error "GLM: GLM_GTX_matrix_decompose 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 | #endif 26 | 27 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTX_matrix_decompose extension included") 29 | #endif 30 | 31 | namespace glm 32 | { 33 | /// @addtogroup gtx_matrix_decompose 34 | /// @{ 35 | 36 | /// Decomposes a model matrix to translations, rotation and scale components 37 | /// @see gtx_matrix_decompose 38 | template 39 | GLM_FUNC_DECL bool decompose( 40 | mat<4, 4, T, P> const& modelMatrix, 41 | vec<3, T, P> & scale, tquat & orientation, vec<3, T, P> & translation, vec<3, T, P> & skew, vec<4, T, P> & perspective); 42 | 43 | /// @} 44 | }//namespace glm 45 | 46 | #include "matrix_decompose.inl" 47 | -------------------------------------------------------------------------------- /third-party/glm/gtx/matrix_interpolation.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_interpolation 2 | /// @file glm/gtx/matrix_interpolation.hpp 3 | /// @author Ghenadii Ursachi (the.asteroth@gmail.com) 4 | /// 5 | /// @see core (dependence) 6 | /// 7 | /// @defgroup gtx_matrix_interpolation GLM_GTX_matrix_interpolation 8 | /// @ingroup gtx 9 | /// 10 | /// @brief Allows to directly interpolate two exiciting matrices. 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_matrix_interpolation 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_matrix_interpolation extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_matrix_interpolation 30 | /// @{ 31 | 32 | /// Get the axis and angle of the rotation from a matrix. 33 | /// From GLM_GTX_matrix_interpolation extension. 34 | template 35 | GLM_FUNC_DECL void axisAngle( 36 | mat<4, 4, T, P> const& mat, 37 | vec<3, T, P> & axis, 38 | T & angle); 39 | 40 | /// Build a matrix from axis and angle. 41 | /// From GLM_GTX_matrix_interpolation extension. 42 | template 43 | GLM_FUNC_DECL mat<4, 4, T, P> axisAngleMatrix( 44 | vec<3, T, P> const & axis, 45 | T const angle); 46 | 47 | /// Extracts the rotation part of a matrix. 48 | /// From GLM_GTX_matrix_interpolation extension. 49 | template 50 | GLM_FUNC_DECL mat<4, 4, T, P> extractMatrixRotation( 51 | mat<4, 4, T, P> const& mat); 52 | 53 | /// Build a interpolation of 4 * 4 matrixes. 54 | /// From GLM_GTX_matrix_interpolation extension. 55 | /// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results. 56 | template 57 | GLM_FUNC_DECL mat<4, 4, T, P> interpolate( 58 | mat<4, 4, T, P> const& m1, 59 | mat<4, 4, T, P> const& m2, 60 | T const delta); 61 | 62 | /// @} 63 | }//namespace glm 64 | 65 | #include "matrix_interpolation.inl" 66 | -------------------------------------------------------------------------------- /third-party/glm/gtx/matrix_transform_2d.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_transform_2d 2 | /// @file glm/gtc/matrix_transform_2d.inl 3 | /// @author Miguel Ángel Pérez Martínez 4 | 5 | #include "../trigonometric.hpp" 6 | 7 | namespace glm 8 | { 9 | 10 | template 11 | GLM_FUNC_QUALIFIER mat<3, 3, T, P> translate( 12 | mat<3, 3, T, P> const& m, 13 | vec<2, T, P> const & v) 14 | { 15 | mat<3, 3, T, P> Result(m); 16 | Result[2] = m[0] * v[0] + m[1] * v[1] + m[2]; 17 | return Result; 18 | } 19 | 20 | 21 | template 22 | GLM_FUNC_QUALIFIER mat<3, 3, T, P> rotate( 23 | mat<3, 3, T, P> const& m, 24 | T angle) 25 | { 26 | T const a = angle; 27 | T const c = cos(a); 28 | T const s = sin(a); 29 | 30 | mat<3, 3, T, P> Result(uninitialize); 31 | Result[0] = m[0] * c + m[1] * s; 32 | Result[1] = m[0] * -s + m[1] * c; 33 | Result[2] = m[2]; 34 | return Result; 35 | } 36 | 37 | template 38 | GLM_FUNC_QUALIFIER mat<3, 3, T, P> scale( 39 | mat<3, 3, T, P> const& m, 40 | vec<2, T, P> const & v) 41 | { 42 | mat<3, 3, T, P> Result(uninitialize); 43 | Result[0] = m[0] * v[0]; 44 | Result[1] = m[1] * v[1]; 45 | Result[2] = m[2]; 46 | return Result; 47 | } 48 | 49 | template 50 | GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearX( 51 | mat<3, 3, T, P> const& m, 52 | T y) 53 | { 54 | mat<3, 3, T, P> Result(1); 55 | Result[0][1] = y; 56 | return m * Result; 57 | } 58 | 59 | template 60 | GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearY( 61 | mat<3, 3, T, P> const& m, 62 | T x) 63 | { 64 | mat<3, 3, T, P> Result(1); 65 | Result[1][0] = x; 66 | return m * Result; 67 | } 68 | 69 | }//namespace glm 70 | -------------------------------------------------------------------------------- /third-party/glm/gtx/mixed_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | /// @file glm/gtx/mixed_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_mixed_product GLM_GTX_mixed_producte 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Mixed product of 3 vectors. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_mixed_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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_mixed_product extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_mixed_product 29 | /// @{ 30 | 31 | /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) 32 | template 33 | GLM_FUNC_DECL T mixedProduct( 34 | vec<3, T, P> const & v1, 35 | vec<3, T, P> const & v2, 36 | vec<3, T, P> const & v3); 37 | 38 | /// @} 39 | }// namespace glm 40 | 41 | #include "mixed_product.inl" 42 | -------------------------------------------------------------------------------- /third-party/glm/gtx/mixed_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | /// @file glm/gtx/mixed_product.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER T mixedProduct 8 | ( 9 | vec<3, T, P> const & v1, 10 | vec<3, T, P> const & v2, 11 | vec<3, T, P> const & v3 12 | ) 13 | { 14 | return dot(cross(v1, v2), v3); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /third-party/glm/gtx/normal.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | /// @file glm/gtx/normal.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_normal GLM_GTX_normal 8 | /// @ingroup gtx 9 | /// 10 | /// @brief Compute the normal of a triangle. 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_normal 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_normal extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normal 30 | /// @{ 31 | 32 | //! Computes triangle normal from triangle points. 33 | //! From GLM_GTX_normal extension. 34 | template 35 | GLM_FUNC_DECL vec<3, T, P> triangleNormal( 36 | vec<3, T, P> const & p1, 37 | vec<3, T, P> const & p2, 38 | vec<3, T, P> const & p3); 39 | 40 | /// @} 41 | }//namespace glm 42 | 43 | #include "normal.inl" 44 | -------------------------------------------------------------------------------- /third-party/glm/gtx/normal.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | /// @file glm/gtx/normal.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, P> triangleNormal 8 | ( 9 | vec<3, T, P> const & p1, 10 | vec<3, T, P> const & p2, 11 | vec<3, T, P> const & p3 12 | ) 13 | { 14 | return normalize(cross(p1 - p2, p1 - p3)); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /third-party/glm/gtx/normalize_dot.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | /// @file glm/gtx/normalize_dot.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_fast_square_root (dependence) 6 | /// 7 | /// @defgroup gtx_normalize_dot GLM_GTX_normalize_dot 8 | /// @ingroup gtx 9 | /// 10 | /// @brief Dot product of vectors that need to be normalize with a single square root. 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../gtx/fast_square_root.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_normalize_dot 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_normalize_dot extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normalize_dot 30 | /// @{ 31 | 32 | /// Normalize parameters and returns the dot product of x and y. 33 | /// It's faster that dot(normalize(x), normalize(y)). 34 | /// 35 | /// @see gtx_normalize_dot extension. 36 | template class vecType> 37 | GLM_FUNC_DECL T normalizeDot(vecType const & x, vecType const & y); 38 | 39 | /// Normalize parameters and returns the dot product of x and y. 40 | /// Faster that dot(fastNormalize(x), fastNormalize(y)). 41 | /// 42 | /// @see gtx_normalize_dot extension. 43 | template class vecType> 44 | GLM_FUNC_DECL T fastNormalizeDot(vecType const & x, vecType const & y); 45 | 46 | /// @} 47 | }//namespace glm 48 | 49 | #include "normalize_dot.inl" 50 | -------------------------------------------------------------------------------- /third-party/glm/gtx/normalize_dot.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | /// @file glm/gtx/normalize_dot.inl 3 | 4 | namespace glm 5 | { 6 | template class vecType> 7 | GLM_FUNC_QUALIFIER T normalizeDot(vecType const & x, vecType const & y) 8 | { 9 | return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); 10 | } 11 | 12 | template class vecType> 13 | GLM_FUNC_QUALIFIER T fastNormalizeDot(vecType const & x, vecType const & y) 14 | { 15 | return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); 16 | } 17 | }//namespace glm 18 | -------------------------------------------------------------------------------- /third-party/glm/gtx/number_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | /// @file glm/gtx/number_precision.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_type_precision (dependence) 6 | /// @see gtc_quaternion (dependence) 7 | /// 8 | /// @defgroup gtx_number_precision GLM_GTX_number_precision 9 | /// @ingroup gtx 10 | /// 11 | /// @brief Defined size types. 12 | /// 13 | /// need to be included to use these functionalities. 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/type_precision.hpp" 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "GLM: GLM_GTX_number_precision 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 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_number_precision extension included") 27 | #endif 28 | 29 | namespace glm{ 30 | namespace gtx 31 | { 32 | ///////////////////////////// 33 | // Unsigned int vector types 34 | 35 | /// @addtogroup gtx_number_precision 36 | /// @{ 37 | 38 | typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 39 | typedef u16 u16vec1; //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 40 | typedef u32 u32vec1; //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 41 | typedef u64 u64vec1; //!< \brief 64bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 42 | 43 | ////////////////////// 44 | // Float vector types 45 | 46 | typedef f32 f32vec1; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) 47 | typedef f64 f64vec1; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) 48 | 49 | ////////////////////// 50 | // Float matrix types 51 | 52 | typedef f32 f32mat1; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) 53 | typedef f32 f32mat1x1; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) 54 | typedef f64 f64mat1; //!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension) 55 | typedef f64 f64mat1x1; //!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension) 56 | 57 | /// @} 58 | }//namespace gtx 59 | }//namespace glm 60 | 61 | #include "number_precision.inl" 62 | -------------------------------------------------------------------------------- /third-party/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | /// @file glm/gtx/number_precision.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /third-party/glm/gtx/optimum_pow.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | /// @file glm/gtx/optimum_pow.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_optimum_pow GLM_GTX_optimum_pow 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Integer exponentiation of power functions. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_optimum_pow 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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_optimum_pow extension included") 24 | #endif 25 | 26 | namespace glm{ 27 | namespace gtx 28 | { 29 | /// @addtogroup gtx_optimum_pow 30 | /// @{ 31 | 32 | /// Returns x raised to the power of 2. 33 | /// 34 | /// @see gtx_optimum_pow 35 | template 36 | GLM_FUNC_DECL genType pow2(genType const & x); 37 | 38 | /// Returns x raised to the power of 3. 39 | /// 40 | /// @see gtx_optimum_pow 41 | template 42 | GLM_FUNC_DECL genType pow3(genType const & x); 43 | 44 | /// Returns x raised to the power of 4. 45 | /// 46 | /// @see gtx_optimum_pow 47 | template 48 | GLM_FUNC_DECL genType pow4(genType const & x); 49 | 50 | /// @} 51 | }//namespace gtx 52 | }//namespace glm 53 | 54 | #include "optimum_pow.inl" 55 | -------------------------------------------------------------------------------- /third-party/glm/gtx/optimum_pow.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | /// @file glm/gtx/optimum_pow.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType pow2(genType const & x) 8 | { 9 | return x * x; 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER genType pow3(genType const & x) 14 | { 15 | return x * x * x; 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER genType pow4(genType const & x) 20 | { 21 | return (x * x) * (x * x); 22 | } 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /third-party/glm/gtx/orthonormalize.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | /// @file glm/gtx/orthonormalize.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_orthonormalize GLM_GTX_orthonormalize 8 | /// @ingroup gtx 9 | /// 10 | /// @brief Orthonormalize matrices. 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../vec3.hpp" 18 | #include "../mat3x3.hpp" 19 | #include "../geometric.hpp" 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "GLM: GLM_GTX_orthonormalize 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 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_orthonormalize extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_orthonormalize 32 | /// @{ 33 | 34 | /// Returns the orthonormalized matrix of m. 35 | /// 36 | /// @see gtx_orthonormalize 37 | template 38 | GLM_FUNC_DECL mat<3, 3, T, P> orthonormalize(mat<3, 3, T, P> const & m); 39 | 40 | /// Orthonormalizes x according y. 41 | /// 42 | /// @see gtx_orthonormalize 43 | template 44 | GLM_FUNC_DECL vec<3, T, P> orthonormalize(vec<3, T, P> const & x, vec<3, T, P> const & y); 45 | 46 | /// @} 47 | }//namespace glm 48 | 49 | #include "orthonormalize.inl" 50 | -------------------------------------------------------------------------------- /third-party/glm/gtx/orthonormalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | /// @file glm/gtx/orthonormalize.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<3, 3, T, P> orthonormalize(mat<3, 3, T, P> const & m) 8 | { 9 | mat<3, 3, T, P> r = m; 10 | 11 | r[0] = normalize(r[0]); 12 | 13 | T d0 = dot(r[0], r[1]); 14 | r[1] -= r[0] * d0; 15 | r[1] = normalize(r[1]); 16 | 17 | T d1 = dot(r[1], r[2]); 18 | d0 = dot(r[0], r[2]); 19 | r[2] -= r[0] * d0 + r[1] * d1; 20 | r[2] = normalize(r[2]); 21 | 22 | return r; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER vec<3, T, P> orthonormalize(vec<3, T, P> const & x, vec<3, T, P> const & y) 27 | { 28 | return normalize(x - y * dot(y, x)); 29 | } 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /third-party/glm/gtx/perpendicular.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | /// @file glm/gtx/perpendicular.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_projection (dependence) 6 | /// 7 | /// @defgroup gtx_perpendicular GLM_GTX_perpendicular 8 | /// @ingroup gtx 9 | /// 10 | /// @brief Perpendicular of a vector from other one 11 | /// 12 | /// need to be included to use these functionalities. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include "../gtx/projection.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_perpendicular 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 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_perpendicular extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_perpendicular 31 | /// @{ 32 | 33 | //! Projects x a perpendicular axis of Normal. 34 | //! From GLM_GTX_perpendicular extension. 35 | template 36 | GLM_FUNC_DECL vecType perp( 37 | vecType const & x, 38 | vecType const & Normal); 39 | 40 | /// @} 41 | }//namespace glm 42 | 43 | #include "perpendicular.inl" 44 | -------------------------------------------------------------------------------- /third-party/glm/gtx/perpendicular.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | /// @file glm/gtx/perpendicular.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vecType perp 8 | ( 9 | vecType const & x, 10 | vecType const & Normal 11 | ) 12 | { 13 | return x - proj(x, Normal); 14 | } 15 | }//namespace glm 16 | -------------------------------------------------------------------------------- /third-party/glm/gtx/polar_coordinates.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | /// @file glm/gtx/polar_coordinates.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Conversion from Euclidean space to polar space and revert. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_polar_coordinates 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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_polar_coordinates extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_polar_coordinates 29 | /// @{ 30 | 31 | /// Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude. 32 | /// 33 | /// @see gtx_polar_coordinates 34 | template 35 | GLM_FUNC_DECL vec<3, T, P> polar( 36 | vec<3, T, P> const & euclidean); 37 | 38 | /// Convert Polar to Euclidean coordinates. 39 | /// 40 | /// @see gtx_polar_coordinates 41 | template 42 | GLM_FUNC_DECL vec<3, T, P> euclidean( 43 | vec<2, T, P> const & polar); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "polar_coordinates.inl" 49 | -------------------------------------------------------------------------------- /third-party/glm/gtx/polar_coordinates.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | /// @file glm/gtx/polar_coordinates.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, P> polar 8 | ( 9 | vec<3, T, P> const & euclidean 10 | ) 11 | { 12 | T const Length(length(euclidean)); 13 | vec<3, T, P> const tmp(euclidean / Length); 14 | T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z)); 15 | 16 | return vec<3, T, P>( 17 | asin(tmp.y), // latitude 18 | atan(tmp.x, tmp.z), // longitude 19 | xz_dist); // xz distance 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER vec<3, T, P> euclidean 24 | ( 25 | vec<2, T, P> const & polar 26 | ) 27 | { 28 | T const latitude(polar.x); 29 | T const longitude(polar.y); 30 | 31 | return vec<3, T, P>( 32 | cos(latitude) * sin(longitude), 33 | sin(latitude), 34 | cos(latitude) * cos(longitude)); 35 | } 36 | 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /third-party/glm/gtx/projection.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | /// @file glm/gtx/projection.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_projection GLM_GTX_projection 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Projection of a vector to other one 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../geometric.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_projection 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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_projection extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_projection 29 | /// @{ 30 | 31 | /// Projects x on Normal. 32 | /// 33 | /// @see gtx_projection 34 | template 35 | GLM_FUNC_DECL vecType proj(vecType const & x, vecType const & Normal); 36 | 37 | /// @} 38 | }//namespace glm 39 | 40 | #include "projection.inl" 41 | -------------------------------------------------------------------------------- /third-party/glm/gtx/projection.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | /// @file glm/gtx/projection.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vecType proj(vecType const & x, vecType const & Normal) 8 | { 9 | return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; 10 | } 11 | }//namespace glm 12 | -------------------------------------------------------------------------------- /third-party/glm/gtx/range.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_range 2 | /// @file glm/gtx/range.hpp 3 | /// @author Joshua Moerman 4 | /// 5 | /// @defgroup gtx_range GLM_GTX_range 6 | /// @ingroup gtx 7 | /// 8 | /// @brief Defines begin and end for vectors and matrices. Useful for range-based for loop. 9 | /// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements). 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_range 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." 20 | #endif 21 | 22 | #if !GLM_HAS_RANGE_FOR 23 | # error "GLM_GTX_range requires C++11 suppport or 'range for'" 24 | #endif 25 | 26 | #include "../gtc/type_ptr.hpp" 27 | #include "../gtc/vec1.hpp" 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_range 32 | /// @{ 33 | 34 | template 35 | inline length_t components(vec<1, T, P> const & v) 36 | { 37 | return v.length(); 38 | } 39 | 40 | template 41 | inline length_t components(vec<2, T, P> const & v) 42 | { 43 | return v.length(); 44 | } 45 | 46 | template 47 | inline length_t components(vec<3, T, P> const & v) 48 | { 49 | return v.length(); 50 | } 51 | 52 | template 53 | inline length_t components(vec<4, T, P> const & v) 54 | { 55 | return v.length(); 56 | } 57 | 58 | template 59 | inline length_t components(genType const & m) 60 | { 61 | return m.length() * m[0].length(); 62 | } 63 | 64 | template 65 | inline typename genType::value_type const * begin(genType const & v) 66 | { 67 | return value_ptr(v); 68 | } 69 | 70 | template 71 | inline typename genType::value_type const * end(genType const & v) 72 | { 73 | return begin(v) + components(v); 74 | } 75 | 76 | template 77 | inline typename genType::value_type * begin(genType& v) 78 | { 79 | return value_ptr(v); 80 | } 81 | 82 | template 83 | inline typename genType::value_type * end(genType& v) 84 | { 85 | return begin(v) + components(v); 86 | } 87 | 88 | /// @} 89 | }//namespace glm 90 | -------------------------------------------------------------------------------- /third-party/glm/gtx/raw_data.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | /// @file glm/gtx/raw_data.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_raw_data GLM_GTX_raw_data 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Projection of a vector to other one 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | #include "../detail/type_int.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_raw_data 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_raw_data extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_raw_data 30 | /// @{ 31 | 32 | //! Type for byte numbers. 33 | //! From GLM_GTX_raw_data extension. 34 | typedef detail::uint8 byte; 35 | 36 | //! Type for word numbers. 37 | //! From GLM_GTX_raw_data extension. 38 | typedef detail::uint16 word; 39 | 40 | //! Type for dword numbers. 41 | //! From GLM_GTX_raw_data extension. 42 | typedef detail::uint32 dword; 43 | 44 | //! Type for qword numbers. 45 | //! From GLM_GTX_raw_data extension. 46 | typedef detail::uint64 qword; 47 | 48 | /// @} 49 | }// namespace glm 50 | 51 | #include "raw_data.inl" 52 | -------------------------------------------------------------------------------- /third-party/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | /// @file glm/gtx/raw_data.inl 3 | -------------------------------------------------------------------------------- /third-party/glm/gtx/rotate_normalized_axis.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_rotate_normalized_axis 2 | /// @file glm/gtx/rotate_normalized_axis.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_matrix_transform 6 | /// @see gtc_quaternion 7 | /// 8 | /// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis 9 | /// @ingroup gtx 10 | /// 11 | /// @brief Quaternions and matrices rotations around normalized axis. 12 | /// 13 | /// need to be included to use these functionalities. 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/epsilon.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | 22 | #ifndef GLM_ENABLE_EXPERIMENTAL 23 | # error "GLM: GLM_GTX_rotate_normalized_axis 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 | #endif 25 | 26 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 27 | # pragma message("GLM: GLM_GTX_rotate_normalized_axis extension included") 28 | #endif 29 | 30 | namespace glm 31 | { 32 | /// @addtogroup gtx_rotate_normalized_axis 33 | /// @{ 34 | 35 | /// Builds a rotation 4 * 4 matrix created from a normalized axis and an angle. 36 | /// 37 | /// @param m Input matrix multiplied by this rotation matrix. 38 | /// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise. 39 | /// @param axis Rotation axis, must be normalized. 40 | /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. 41 | /// 42 | /// @see gtx_rotate_normalized_axis 43 | /// @see - rotate(T angle, T x, T y, T z) 44 | /// @see - rotate(mat<4, 4, T, P> const & m, T angle, T x, T y, T z) 45 | /// @see - rotate(T angle, vec<3, T, P> const & v) 46 | template 47 | GLM_FUNC_DECL mat<4, 4, T, P> rotateNormalizedAxis( 48 | mat<4, 4, T, P> const& m, 49 | T const & angle, 50 | vec<3, T, P> const & axis); 51 | 52 | /// Rotates a quaternion from a vector of 3 components normalized axis and an angle. 53 | /// 54 | /// @param q Source orientation 55 | /// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise. 56 | /// @param axis Normalized axis of the rotation, must be normalized. 57 | /// 58 | /// @see gtx_rotate_normalized_axis 59 | template 60 | GLM_FUNC_DECL tquat rotateNormalizedAxis( 61 | tquat const & q, 62 | T const & angle, 63 | vec<3, T, P> const & axis); 64 | 65 | /// @} 66 | }//namespace glm 67 | 68 | #include "rotate_normalized_axis.inl" 69 | -------------------------------------------------------------------------------- /third-party/glm/gtx/rotate_normalized_axis.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_rotate_normalized_axis 2 | /// @file glm/gtx/rotate_normalized_axis.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotateNormalizedAxis 8 | ( 9 | mat<4, 4, T, P> const& m, 10 | T const & angle, 11 | vec<3, T, P> const & v 12 | ) 13 | { 14 | T const a = angle; 15 | T const c = cos(a); 16 | T const s = sin(a); 17 | 18 | vec<3, T, P> const axis(v); 19 | 20 | vec<3, T, P> const temp((static_cast(1) - c) * axis); 21 | 22 | mat<4, 4, T, P> Rotate(uninitialize); 23 | Rotate[0][0] = c + temp[0] * axis[0]; 24 | Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; 25 | Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; 26 | 27 | Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; 28 | Rotate[1][1] = c + temp[1] * axis[1]; 29 | Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; 30 | 31 | Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; 32 | Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; 33 | Rotate[2][2] = c + temp[2] * axis[2]; 34 | 35 | mat<4, 4, T, P> Result(uninitialize); 36 | Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; 37 | Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; 38 | Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; 39 | Result[3] = m[3]; 40 | return Result; 41 | } 42 | 43 | template 44 | GLM_FUNC_QUALIFIER tquat rotateNormalizedAxis 45 | ( 46 | tquat const & q, 47 | T const & angle, 48 | vec<3, T, P> const & v 49 | ) 50 | { 51 | vec<3, T, P> const Tmp(v); 52 | 53 | T const AngleRad(angle); 54 | T const Sin = sin(AngleRad * T(0.5)); 55 | 56 | return q * tquat(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); 57 | //return gtc::quaternion::cross(q, tquat(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin)); 58 | } 59 | }//namespace glm 60 | -------------------------------------------------------------------------------- /third-party/glm/gtx/scalar_multiplication.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx 2 | /// @file glm/gtx/scalar_multiplication.hpp 3 | /// @author Joshua Moerman 4 | /// 5 | /// @brief Enables scalar multiplication for all types 6 | /// 7 | /// Since GLSL is very strict about types, the following (often used) combinations do not work: 8 | /// double * vec4 9 | /// int * vec4 10 | /// vec4 / int 11 | /// So we'll fix that! Of course "float * vec4" should remain the same (hence the enable_if magic) 12 | 13 | #pragma once 14 | 15 | #include "../detail/setup.hpp" 16 | 17 | #ifndef GLM_ENABLE_EXPERIMENTAL 18 | # error "GLM: GLM_GTX_scalar_multiplication 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." 19 | #endif 20 | 21 | #if !GLM_HAS_TEMPLATE_ALIASES && !(GLM_COMPILER & GLM_COMPILER_GCC) 22 | # error "GLM_GTX_scalar_multiplication requires C++11 support or alias templates and if not support for GCC" 23 | #endif 24 | 25 | #include "../vec2.hpp" 26 | #include "../vec3.hpp" 27 | #include "../vec4.hpp" 28 | #include "../mat2x2.hpp" 29 | #include 30 | 31 | namespace glm 32 | { 33 | template 34 | using return_type_scalar_multiplication = typename std::enable_if< 35 | !std::is_same::value // T may not be a float 36 | && std::is_arithmetic::value, Vec // But it may be an int or double (no vec3 or mat3, ...) 37 | >::type; 38 | 39 | #define GLM_IMPLEMENT_SCAL_MULT(Vec) \ 40 | template \ 41 | return_type_scalar_multiplication \ 42 | operator*(T const & s, Vec rh){ \ 43 | return rh *= static_cast(s); \ 44 | } \ 45 | \ 46 | template \ 47 | return_type_scalar_multiplication \ 48 | operator*(Vec lh, T const & s){ \ 49 | return lh *= static_cast(s); \ 50 | } \ 51 | \ 52 | template \ 53 | return_type_scalar_multiplication \ 54 | operator/(Vec lh, T const & s){ \ 55 | return lh *= 1.0f / s; \ 56 | } 57 | 58 | GLM_IMPLEMENT_SCAL_MULT(vec2) 59 | GLM_IMPLEMENT_SCAL_MULT(vec3) 60 | GLM_IMPLEMENT_SCAL_MULT(vec4) 61 | 62 | GLM_IMPLEMENT_SCAL_MULT(mat2) 63 | GLM_IMPLEMENT_SCAL_MULT(mat2x3) 64 | GLM_IMPLEMENT_SCAL_MULT(mat2x4) 65 | GLM_IMPLEMENT_SCAL_MULT(mat3x2) 66 | GLM_IMPLEMENT_SCAL_MULT(mat3) 67 | GLM_IMPLEMENT_SCAL_MULT(mat3x4) 68 | GLM_IMPLEMENT_SCAL_MULT(mat4x2) 69 | GLM_IMPLEMENT_SCAL_MULT(mat4x3) 70 | GLM_IMPLEMENT_SCAL_MULT(mat4) 71 | 72 | #undef GLM_IMPLEMENT_SCAL_MULT 73 | } // namespace glm 74 | -------------------------------------------------------------------------------- /third-party/glm/gtx/scalar_relational.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | /// @file glm/gtx/scalar_relational.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Extend a position from a source to a position at a defined length. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_extend extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_scalar_relational 29 | /// @{ 30 | 31 | 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "scalar_relational.inl" 37 | -------------------------------------------------------------------------------- /third-party/glm/gtx/scalar_relational.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | /// @file glm/gtx/scalar_relational.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER bool lessThan 8 | ( 9 | T const & x, 10 | T const & y 11 | ) 12 | { 13 | return x < y; 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER bool lessThanEqual 18 | ( 19 | T const & x, 20 | T const & y 21 | ) 22 | { 23 | return x <= y; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER bool greaterThan 28 | ( 29 | T const & x, 30 | T const & y 31 | ) 32 | { 33 | return x > y; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER bool greaterThanEqual 38 | ( 39 | T const & x, 40 | T const & y 41 | ) 42 | { 43 | return x >= y; 44 | } 45 | 46 | template 47 | GLM_FUNC_QUALIFIER bool equal 48 | ( 49 | T const & x, 50 | T const & y 51 | ) 52 | { 53 | return x == y; 54 | } 55 | 56 | template 57 | GLM_FUNC_QUALIFIER bool notEqual 58 | ( 59 | T const & x, 60 | T const & y 61 | ) 62 | { 63 | return x != y; 64 | } 65 | 66 | GLM_FUNC_QUALIFIER bool any 67 | ( 68 | bool const & x 69 | ) 70 | { 71 | return x; 72 | } 73 | 74 | GLM_FUNC_QUALIFIER bool all 75 | ( 76 | bool const & x 77 | ) 78 | { 79 | return x; 80 | } 81 | 82 | GLM_FUNC_QUALIFIER bool not_ 83 | ( 84 | bool const & x 85 | ) 86 | { 87 | return !x; 88 | } 89 | }//namespace glm 90 | -------------------------------------------------------------------------------- /third-party/glm/gtx/spline.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_spline 2 | /// @file glm/gtx/spline.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_spline GLM_GTX_spline 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Spline functions 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtx/optimum_pow.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_spline 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_spline extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_spline 30 | /// @{ 31 | 32 | /// Return a point from a catmull rom curve. 33 | /// @see gtx_spline extension. 34 | template 35 | GLM_FUNC_DECL genType catmullRom( 36 | genType const & v1, 37 | genType const & v2, 38 | genType const & v3, 39 | genType const & v4, 40 | typename genType::value_type const & s); 41 | 42 | /// Return a point from a hermite curve. 43 | /// @see gtx_spline extension. 44 | template 45 | GLM_FUNC_DECL genType hermite( 46 | genType const & v1, 47 | genType const & t1, 48 | genType const & v2, 49 | genType const & t2, 50 | typename genType::value_type const & s); 51 | 52 | /// Return a point from a cubic curve. 53 | /// @see gtx_spline extension. 54 | template 55 | GLM_FUNC_DECL genType cubic( 56 | genType const & v1, 57 | genType const & v2, 58 | genType const & v3, 59 | genType const & v4, 60 | typename genType::value_type const & s); 61 | 62 | /// @} 63 | }//namespace glm 64 | 65 | #include "spline.inl" 66 | -------------------------------------------------------------------------------- /third-party/glm/gtx/spline.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_spline 2 | /// @file glm/gtx/spline.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType catmullRom 8 | ( 9 | genType const & v1, 10 | genType const & v2, 11 | genType const & v3, 12 | genType const & v4, 13 | typename genType::value_type const & s 14 | ) 15 | { 16 | typename genType::value_type s1 = s; 17 | typename genType::value_type s2 = pow2(s); 18 | typename genType::value_type s3 = pow3(s); 19 | 20 | typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s; 21 | typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2); 22 | typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s; 23 | typename genType::value_type f4 = s3 - s2; 24 | 25 | return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2); 26 | 27 | } 28 | 29 | template 30 | GLM_FUNC_QUALIFIER genType hermite 31 | ( 32 | genType const & v1, 33 | genType const & t1, 34 | genType const & v2, 35 | genType const & t2, 36 | typename genType::value_type const & s 37 | ) 38 | { 39 | typename genType::value_type s1 = s; 40 | typename genType::value_type s2 = pow2(s); 41 | typename genType::value_type s3 = pow3(s); 42 | 43 | typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1); 44 | typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2; 45 | typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s; 46 | typename genType::value_type f4 = s3 - s2; 47 | 48 | return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2; 49 | } 50 | 51 | template 52 | GLM_FUNC_QUALIFIER genType cubic 53 | ( 54 | genType const & v1, 55 | genType const & v2, 56 | genType const & v3, 57 | genType const & v4, 58 | typename genType::value_type const & s 59 | ) 60 | { 61 | return ((v1 * s + v2) * s + v3) * s + v4; 62 | } 63 | }//namespace glm 64 | -------------------------------------------------------------------------------- /third-party/glm/gtx/std_based_type.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | /// @file glm/gtx/std_based_type.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_std_based_type GLM_GTX_std_based_type 8 | /// @ingroup gtx 9 | /// 10 | /// @brief Adds vector types based on STL value types. 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_std_based_type 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_std_based_type extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_std_based_type 30 | /// @{ 31 | 32 | /// Vector type based of one std::size_t component. 33 | /// @see GLM_GTX_std_based_type 34 | typedef vec<1, std::size_t, defaultp> size1; 35 | 36 | /// Vector type based of two std::size_t components. 37 | /// @see GLM_GTX_std_based_type 38 | typedef vec<2, std::size_t, defaultp> size2; 39 | 40 | /// Vector type based of three std::size_t components. 41 | /// @see GLM_GTX_std_based_type 42 | typedef vec<3, std::size_t, defaultp> size3; 43 | 44 | /// Vector type based of four std::size_t components. 45 | /// @see GLM_GTX_std_based_type 46 | typedef vec<4, std::size_t, defaultp> size4; 47 | 48 | /// Vector type based of one std::size_t component. 49 | /// @see GLM_GTX_std_based_type 50 | typedef vec<1, std::size_t, defaultp> size1_t; 51 | 52 | /// Vector type based of two std::size_t components. 53 | /// @see GLM_GTX_std_based_type 54 | typedef vec<2, std::size_t, defaultp> size2_t; 55 | 56 | /// Vector type based of three std::size_t components. 57 | /// @see GLM_GTX_std_based_type 58 | typedef vec<3, std::size_t, defaultp> size3_t; 59 | 60 | /// Vector type based of four std::size_t components. 61 | /// @see GLM_GTX_std_based_type 62 | typedef vec<4, std::size_t, defaultp> size4_t; 63 | 64 | /// @} 65 | }//namespace glm 66 | 67 | #include "std_based_type.inl" 68 | -------------------------------------------------------------------------------- /third-party/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | /// @file glm/gtx/std_based_type.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /third-party/glm/gtx/string_cast.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_string_cast 2 | /// @file glm/gtx/string_cast.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_integer (dependence) 6 | /// @see gtx_quaternion (dependence) 7 | /// 8 | /// @defgroup gtx_string_cast GLM_GTX_string_cast 9 | /// @ingroup gtx 10 | /// 11 | /// @brief Setup strings for GLM type values 12 | /// 13 | /// need to be included to use these functionalities. 14 | /// This extension is not supported with CUDA 15 | 16 | #pragma once 17 | 18 | // Dependency: 19 | #include "../glm.hpp" 20 | #include "../gtc/type_precision.hpp" 21 | #include "../gtc/quaternion.hpp" 22 | #include "../gtx/dual_quaternion.hpp" 23 | #include 24 | #include 25 | 26 | #ifndef GLM_ENABLE_EXPERIMENTAL 27 | # error "GLM: GLM_GTX_string_cast 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." 28 | #endif 29 | 30 | #if(GLM_COMPILER & GLM_COMPILER_CUDA) 31 | # error "GLM_GTX_string_cast is not supported on CUDA compiler" 32 | #endif 33 | 34 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 35 | # pragma message("GLM: GLM_GTX_string_cast extension included") 36 | #endif 37 | 38 | namespace glm 39 | { 40 | /// @addtogroup gtx_string_cast 41 | /// @{ 42 | 43 | /// Create a string from a GLM vector or matrix typed variable. 44 | /// @see gtx_string_cast extension. 45 | template 46 | GLM_FUNC_DECL std::string to_string(genType const& x); 47 | 48 | /// @} 49 | }//namespace glm 50 | 51 | #include "string_cast.inl" 52 | -------------------------------------------------------------------------------- /third-party/glm/gtx/transform.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | /// @file glm/gtx/transform.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_matrix_transform (dependence) 6 | /// @see gtx_transform 7 | /// @see gtx_transform2 8 | /// 9 | /// @defgroup gtx_transform GLM_GTX_transform 10 | /// @ingroup gtx 11 | /// 12 | /// @brief Add transformation matrices 13 | /// 14 | /// need to be included to use these functionalities. 15 | 16 | #pragma once 17 | 18 | // Dependency: 19 | #include "../glm.hpp" 20 | #include "../gtc/matrix_transform.hpp" 21 | 22 | #ifndef GLM_ENABLE_EXPERIMENTAL 23 | # error "GLM: GLM_GTX_transform 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 | #endif 25 | 26 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 27 | # pragma message("GLM: GLM_GTX_transform extension included") 28 | #endif 29 | 30 | namespace glm 31 | { 32 | /// @addtogroup gtx_transform 33 | /// @{ 34 | 35 | /// Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 36 | /// @see gtc_matrix_transform 37 | /// @see gtx_transform 38 | template 39 | GLM_FUNC_DECL mat<4, 4, T, P> translate( 40 | vec<3, T, P> const & v); 41 | 42 | /// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians. 43 | /// @see gtc_matrix_transform 44 | /// @see gtx_transform 45 | template 46 | GLM_FUNC_DECL mat<4, 4, T, P> rotate( 47 | T angle, 48 | vec<3, T, P> const & v); 49 | 50 | /// Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components. 51 | /// @see gtc_matrix_transform 52 | /// @see gtx_transform 53 | template 54 | GLM_FUNC_DECL mat<4, 4, T, P> scale( 55 | vec<3, T, P> const & v); 56 | 57 | /// @} 58 | }// namespace glm 59 | 60 | #include "transform.inl" 61 | -------------------------------------------------------------------------------- /third-party/glm/gtx/transform.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | /// @file glm/gtx/transform.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<4, 4, T, P> translate(vec<3, T, P> const & v) 8 | { 9 | return translate(mat<4, 4, T, P>(static_cast(1)), v); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotate(T angle, vec<3, T, P> const & v) 14 | { 15 | return rotate(mat<4, 4, T, P>(static_cast(1)), angle, v); 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER mat<4, 4, T, P> scale(vec<3, T, P> const & v) 20 | { 21 | return scale(mat<4, 4, T, P>(static_cast(1)), v); 22 | } 23 | 24 | }//namespace glm 25 | -------------------------------------------------------------------------------- /third-party/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | /// @file glm/gtc/type_aligned.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /third-party/glm/gtx/type_trait.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ddiakopoulos/texture-visualizer-fft/ab9b2fc93bee28df7749e27f825922b433fa4588/third-party/glm/gtx/type_trait.inl -------------------------------------------------------------------------------- /third-party/glm/gtx/vector_angle.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_vector_angle 2 | /// @file glm/gtx/vector_angle.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_quaternion (dependence) 6 | /// @see gtx_epsilon (dependence) 7 | /// 8 | /// @defgroup gtx_vector_angle GLM_GTX_vector_angle 9 | /// @ingroup gtx 10 | /// 11 | /// @brief Compute angle between vectors 12 | /// 13 | /// need to be included to use these functionalities. 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/epsilon.hpp" 20 | #include "../gtx/quaternion.hpp" 21 | #include "../gtx/rotate_vector.hpp" 22 | 23 | #ifndef GLM_ENABLE_EXPERIMENTAL 24 | # error "GLM: GLM_GTX_vector_angle 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 | #endif 26 | 27 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTX_vector_angle extension included") 29 | #endif 30 | 31 | namespace glm 32 | { 33 | /// @addtogroup gtx_vector_angle 34 | /// @{ 35 | 36 | //! Returns the absolute angle between two vectors. 37 | //! Parameters need to be normalized. 38 | /// @see gtx_vector_angle extension. 39 | template 40 | GLM_FUNC_DECL typename vecType::value_type angle( 41 | vecType const & x, 42 | vecType const & y); 43 | 44 | //! Returns the oriented angle between two 2d vectors. 45 | //! Parameters need to be normalized. 46 | /// @see gtx_vector_angle extension. 47 | template 48 | GLM_FUNC_DECL T orientedAngle( 49 | vec<2, T, P> const & x, 50 | vec<2, T, P> const & y); 51 | 52 | //! Returns the oriented angle between two 3d vectors based from a reference axis. 53 | //! Parameters need to be normalized. 54 | /// @see gtx_vector_angle extension. 55 | template 56 | GLM_FUNC_DECL T orientedAngle( 57 | vec<3, T, P> const & x, 58 | vec<3, T, P> const & y, 59 | vec<3, T, P> const & ref); 60 | 61 | /// @} 62 | }// namespace glm 63 | 64 | #include "vector_angle.inl" 65 | -------------------------------------------------------------------------------- /third-party/glm/gtx/vector_angle.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_vector_angle 2 | /// @file glm/gtx/vector_angle.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType angle 8 | ( 9 | genType const & x, 10 | genType const & y 11 | ) 12 | { 13 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); 14 | return acos(clamp(dot(x, y), genType(-1), genType(1))); 15 | } 16 | 17 | template class vecType> 18 | GLM_FUNC_QUALIFIER T angle 19 | ( 20 | vecType const& x, 21 | vecType const& y 22 | ) 23 | { 24 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); 25 | return acos(clamp(dot(x, y), T(-1), T(1))); 26 | } 27 | 28 | //! \todo epsilon is hard coded to 0.01 29 | template 30 | GLM_FUNC_QUALIFIER T orientedAngle 31 | ( 32 | vec<2, T, P> const & x, 33 | vec<2, T, P> const & y 34 | ) 35 | { 36 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); 37 | T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); 38 | 39 | if(all(epsilonEqual(y, glm::rotate(x, Angle), T(0.0001)))) 40 | return Angle; 41 | else 42 | return -Angle; 43 | } 44 | 45 | template 46 | GLM_FUNC_QUALIFIER T orientedAngle 47 | ( 48 | vec<3, T, P> const & x, 49 | vec<3, T, P> const & y, 50 | vec<3, T, P> const & ref 51 | ) 52 | { 53 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); 54 | 55 | T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); 56 | return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0)); 57 | } 58 | }//namespace glm 59 | -------------------------------------------------------------------------------- /third-party/glm/gtx/wrap.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | /// @file glm/gtx/wrap.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_wrap GLM_GTX_wrap 7 | /// @ingroup gtx 8 | /// 9 | /// @brief Wrapping mode of texture coordinates. 10 | /// 11 | /// need to be included to use these functionalities. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtc/vec1.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_wrap 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_wrap extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_wrap 30 | /// @{ 31 | 32 | /// Simulate GL_CLAMP OpenGL wrap mode 33 | /// @see gtx_wrap extension. 34 | template 35 | GLM_FUNC_DECL genType clamp(genType const& Texcoord); 36 | 37 | /// Simulate GL_REPEAT OpenGL wrap mode 38 | /// @see gtx_wrap extension. 39 | template 40 | GLM_FUNC_DECL genType repeat(genType const& Texcoord); 41 | 42 | /// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode 43 | /// @see gtx_wrap extension. 44 | template 45 | GLM_FUNC_DECL genType mirrorClamp(genType const& Texcoord); 46 | 47 | /// Simulate GL_MIRROR_REPEAT OpenGL wrap mode 48 | /// @see gtx_wrap extension. 49 | template 50 | GLM_FUNC_DECL genType mirrorRepeat(genType const& Texcoord); 51 | 52 | /// @} 53 | }// namespace glm 54 | 55 | #include "wrap.inl" 56 | -------------------------------------------------------------------------------- /third-party/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | /// @file glm/gtx/wrap.inl 3 | 4 | namespace glm 5 | { 6 | template class vecType> 7 | GLM_FUNC_QUALIFIER vecType clamp(vecType const& Texcoord) 8 | { 9 | return glm::clamp(Texcoord, vecType(0), vecType(1)); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER genType clamp(genType const & Texcoord) 14 | { 15 | return clamp(vec<1, genType, defaultp>(Texcoord)).x; 16 | } 17 | 18 | template class vecType> 19 | GLM_FUNC_QUALIFIER vecType repeat(vecType const& Texcoord) 20 | { 21 | return glm::fract(Texcoord); 22 | } 23 | 24 | template 25 | GLM_FUNC_QUALIFIER genType repeat(genType const & Texcoord) 26 | { 27 | return repeat(vec<1, genType, defaultp>(Texcoord)).x; 28 | } 29 | 30 | template class vecType> 31 | GLM_FUNC_QUALIFIER vecType mirrorClamp(vecType const& Texcoord) 32 | { 33 | return glm::fract(glm::abs(Texcoord)); 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER genType mirrorClamp(genType const & Texcoord) 38 | { 39 | return mirrorClamp(vec<1, genType, defaultp>(Texcoord)).x; 40 | } 41 | 42 | template class vecType> 43 | GLM_FUNC_QUALIFIER vecType mirrorRepeat(vecType const& Texcoord) 44 | { 45 | vecType const Abs = glm::abs(Texcoord); 46 | vecType const Clamp = glm::mod(glm::floor(Abs), vecType(2)); 47 | vecType const Floor = glm::floor(Abs); 48 | vecType const Rest = Abs - Floor; 49 | vecType const Mirror = Clamp + Rest; 50 | return mix(Rest, vecType(1) - Rest, glm::greaterThanEqual(Mirror, vecType(1))); 51 | } 52 | 53 | template 54 | GLM_FUNC_QUALIFIER genType mirrorRepeat(genType const& Texcoord) 55 | { 56 | return mirrorRepeat(vec<1, genType, defaultp>(Texcoord)).x; 57 | } 58 | }//namespace glm 59 | -------------------------------------------------------------------------------- /third-party/glm/integer.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/integer.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/func_integer.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/mat2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x3.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/type_mat2x3.hpp" 7 | 8 | namespace glm 9 | { 10 | /// 2 columns of 3 components matrix of low precision floating-point numbers. 11 | /// There is no guarantee on the actual precision. 12 | /// 13 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 14 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 15 | typedef mat<2, 3, float, lowp> lowp_mat2x3; 16 | 17 | /// 2 columns of 3 components matrix of medium precision floating-point numbers. 18 | /// There is no guarantee on the actual precision. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<2, 3, float, mediump> mediump_mat2x3; 23 | 24 | /// 2 columns of 3 components matrix of high precision floating-point numbers. 25 | /// There is no guarantee on the actual precision. 26 | /// 27 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 28 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 29 | typedef mat<2, 3, float, highp> highp_mat2x3; 30 | 31 | }//namespace glm 32 | 33 | -------------------------------------------------------------------------------- /third-party/glm/mat2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x4.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/type_mat2x4.hpp" 7 | 8 | namespace glm 9 | { 10 | /// 2 columns of 4 components matrix of low precision floating-point numbers. 11 | /// There is no guarantee on the actual precision. 12 | /// 13 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 14 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 15 | typedef mat<2, 4, float, lowp> lowp_mat2x4; 16 | 17 | /// 2 columns of 4 components matrix of medium precision floating-point numbers. 18 | /// There is no guarantee on the actual precision. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<2, 4, float, mediump> mediump_mat2x4; 23 | 24 | /// 2 columns of 4 components matrix of high precision floating-point numbers. 25 | /// There is no guarantee on the actual precision. 26 | /// 27 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 28 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 29 | typedef mat<2, 4, float, highp> highp_mat2x4; 30 | 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /third-party/glm/mat3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x2.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/type_mat3x2.hpp" 7 | 8 | namespace glm 9 | { 10 | /// 3 columns of 2 components matrix of low precision floating-point numbers. 11 | /// There is no guarantee on the actual precision. 12 | /// 13 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 14 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 15 | typedef mat<3, 2, float, lowp> lowp_mat3x2; 16 | 17 | /// 3 columns of 2 components matrix of medium precision floating-point numbers. 18 | /// There is no guarantee on the actual precision. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<3, 2, float, mediump> mediump_mat3x2; 23 | 24 | /// 3 columns of 2 components matrix of high precision floating-point numbers. 25 | /// There is no guarantee on the actual precision. 26 | /// 27 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 28 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 29 | typedef mat<3, 2, float, highp> highp_mat3x2; 30 | 31 | }//namespace 32 | -------------------------------------------------------------------------------- /third-party/glm/mat3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x4.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/type_mat3x4.hpp" 7 | 8 | namespace glm 9 | { 10 | /// 3 columns of 4 components matrix of low precision floating-point numbers. 11 | /// There is no guarantee on the actual precision. 12 | /// 13 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 14 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 15 | typedef mat<3, 4, float, lowp> lowp_mat3x4; 16 | 17 | /// 3 columns of 4 components matrix of medium precision floating-point numbers. 18 | /// There is no guarantee on the actual precision. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<3, 4, float, mediump> mediump_mat3x4; 23 | 24 | /// 3 columns of 4 components matrix of high precision floating-point numbers. 25 | /// There is no guarantee on the actual precision. 26 | /// 27 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 28 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 29 | typedef mat<3, 4, float, highp> highp_mat3x4; 30 | 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /third-party/glm/mat4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x2.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/type_mat4x2.hpp" 7 | 8 | namespace glm 9 | { 10 | /// 4 columns of 2 components matrix of low precision floating-point numbers. 11 | /// There is no guarantee on the actual precision. 12 | /// 13 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 14 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 15 | typedef mat<4, 2, float, lowp> lowp_mat4x2; 16 | 17 | /// 4 columns of 2 components matrix of medium precision floating-point numbers. 18 | /// There is no guarantee on the actual precision. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<4, 2, float, mediump> mediump_mat4x2; 23 | 24 | /// 4 columns of 2 components matrix of high precision floating-point numbers. 25 | /// There is no guarantee on the actual precision. 26 | /// 27 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 28 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 29 | typedef mat<4, 2, float, highp> highp_mat4x2; 30 | 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /third-party/glm/mat4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x3.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/type_mat4x3.hpp" 7 | 8 | namespace glm 9 | { 10 | /// 4 columns of 3 components matrix of low precision floating-point numbers. 11 | /// There is no guarantee on the actual precision. 12 | /// 13 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 14 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 15 | typedef mat<4, 3, float, lowp> lowp_mat4x3; 16 | 17 | /// 4 columns of 3 components matrix of medium precision floating-point numbers. 18 | /// There is no guarantee on the actual precision. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<4, 3, float, mediump> mediump_mat4x3; 23 | 24 | /// 4 columns of 3 components matrix of high precision floating-point numbers. 25 | /// There is no guarantee on the actual precision. 26 | /// 27 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 28 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 29 | typedef mat<4, 3, float, highp> highp_mat4x3; 30 | 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /third-party/glm/matrix.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/matrix.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/func_matrix.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/packing.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/func_packing.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/simd/exponential.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/experimental.h 3 | 4 | #pragma once 5 | 6 | #include "platform.h" 7 | 8 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_sqrt_lowp(glm_vec4 x) 11 | { 12 | return _mm_mul_ss(_mm_rsqrt_ss(x), x); 13 | } 14 | 15 | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sqrt_lowp(glm_vec4 x) 16 | { 17 | return _mm_mul_ps(_mm_rsqrt_ps(x), x); 18 | } 19 | 20 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 21 | -------------------------------------------------------------------------------- /third-party/glm/simd/packing.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/packing.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /third-party/glm/simd/trigonometric.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/trigonometric.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | -------------------------------------------------------------------------------- /third-party/glm/simd/vector_relational.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/vector_relational.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /third-party/glm/trigonometric.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/trigonometric.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/func_trigonometric.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/vec2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec2.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/type_vec2.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/vec3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec3.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/type_vec3.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/vec4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec4.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/type_vec4.hpp" 7 | -------------------------------------------------------------------------------- /third-party/glm/vector_relational.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vector_relational.hpp 3 | 4 | #pragma once 5 | 6 | #include "detail/func_vector_relational.hpp" 7 | -------------------------------------------------------------------------------- /third-party/kissfft/kiss_fftr.hpp: -------------------------------------------------------------------------------- 1 | #ifndef KISS_FTR_H 2 | #define KISS_FTR_H 3 | 4 | #include "kiss_fft.hpp" 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | 10 | /* 11 | 12 | Real optimized version can save about 45% cpu time vs. complex fft of a real seq. 13 | 14 | 15 | 16 | */ 17 | 18 | typedef struct kiss_fftr_state *kiss_fftr_cfg; 19 | 20 | 21 | kiss_fftr_cfg kiss_fftr_alloc(int nfft,int inverse_fft,void * mem, size_t * lenmem); 22 | /* 23 | nfft must be even 24 | 25 | If you don't care to allocate space, use mem = lenmem = NULL 26 | */ 27 | 28 | 29 | void kiss_fftr(kiss_fftr_cfg cfg,const kiss_fft_scalar *timedata,kiss_fft_cpx *freqdata); 30 | /* 31 | input timedata has nfft scalar points 32 | output freqdata has nfft/2+1 complex points 33 | */ 34 | 35 | void kiss_fftri(kiss_fftr_cfg cfg,const kiss_fft_cpx *freqdata,kiss_fft_scalar *timedata); 36 | /* 37 | input freqdata has nfft/2+1 complex points 38 | output timedata has nfft scalar points 39 | */ 40 | 41 | #define kiss_fftr_free free 42 | 43 | #ifdef __cplusplus 44 | } 45 | #endif 46 | #endif 47 | -------------------------------------------------------------------------------- /third-party/linalg_util.hpp: -------------------------------------------------------------------------------- 1 | #ifndef linalg_util_h 2 | #define linalg_util_h 3 | 4 | #include "linalg.h" 5 | #include 6 | 7 | using namespace linalg::aliases; 8 | 9 | static const float4x4 Identity4x4 = {{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}}; 10 | static const float3x3 Identity3x3 = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}; 11 | static const float2x2 Identity2x2 = {{1, 0}, {0, 1}}; 12 | 13 | static const float4x4 Zero4x4 = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}; 14 | static const float3x3 Zero3x3 = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}}; 15 | static const float2x2 Zero2x2 = {{0, 0}, {0, 0}}; 16 | 17 | template linalg::vec safe_normalize(const linalg::vec & a) { return a / std::max(T(1E-6), length(a)); } 18 | template linalg::mat inv(const linalg::mat & a) { return inverse(a); } 19 | 20 | template std::ostream & operator << (std::ostream & a, const linalg::vec & b) { return a << '{' << b.x << ", " << b.y << '}'; } 21 | template std::ostream & operator << (std::ostream & a, const linalg::vec & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; } 22 | template std::ostream & operator << (std::ostream & a, const linalg::vec & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; } 23 | 24 | template std::ostream & operator << (std::ostream & a, const linalg::mat & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n'; } 25 | template std::ostream & operator << (std::ostream & a, const linalg::mat & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; } 26 | template std::ostream & operator << (std::ostream & a, const linalg::mat & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; } 27 | 28 | #endif -------------------------------------------------------------------------------- /visualizer.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 14 4 | VisualStudioVersion = 14.0.25420.1 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "visualizer", "visualizer.vcxproj", "{E8595BE1-022E-46B2-9079-A12C655C5E4B}" 7 | EndProject 8 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "glfw3", "third-party\glfw-3.1.2\glfw3.vcxproj", "{BE423E72-28C2-4FB7-9FE1-42AA2F393BBC}" 9 | EndProject 10 | Global 11 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 12 | Debug|x64 = Debug|x64 13 | Debug|x86 = Debug|x86 14 | Release|x64 = Release|x64 15 | Release|x86 = Release|x86 16 | EndGlobalSection 17 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 18 | {E8595BE1-022E-46B2-9079-A12C655C5E4B}.Debug|x64.ActiveCfg = Debug|x64 19 | {E8595BE1-022E-46B2-9079-A12C655C5E4B}.Debug|x64.Build.0 = Debug|x64 20 | {E8595BE1-022E-46B2-9079-A12C655C5E4B}.Debug|x86.ActiveCfg = Debug|Win32 21 | {E8595BE1-022E-46B2-9079-A12C655C5E4B}.Debug|x86.Build.0 = Debug|Win32 22 | {E8595BE1-022E-46B2-9079-A12C655C5E4B}.Release|x64.ActiveCfg = Release|x64 23 | {E8595BE1-022E-46B2-9079-A12C655C5E4B}.Release|x64.Build.0 = Release|x64 24 | {E8595BE1-022E-46B2-9079-A12C655C5E4B}.Release|x86.ActiveCfg = Release|Win32 25 | {E8595BE1-022E-46B2-9079-A12C655C5E4B}.Release|x86.Build.0 = Release|Win32 26 | {BE423E72-28C2-4FB7-9FE1-42AA2F393BBC}.Debug|x64.ActiveCfg = Debug|x64 27 | {BE423E72-28C2-4FB7-9FE1-42AA2F393BBC}.Debug|x64.Build.0 = Debug|x64 28 | {BE423E72-28C2-4FB7-9FE1-42AA2F393BBC}.Debug|x86.ActiveCfg = Debug|Win32 29 | {BE423E72-28C2-4FB7-9FE1-42AA2F393BBC}.Debug|x86.Build.0 = Debug|Win32 30 | {BE423E72-28C2-4FB7-9FE1-42AA2F393BBC}.Release|x64.ActiveCfg = Release|x64 31 | {BE423E72-28C2-4FB7-9FE1-42AA2F393BBC}.Release|x64.Build.0 = Release|x64 32 | {BE423E72-28C2-4FB7-9FE1-42AA2F393BBC}.Release|x86.ActiveCfg = Release|Win32 33 | {BE423E72-28C2-4FB7-9FE1-42AA2F393BBC}.Release|x86.Build.0 = Release|Win32 34 | EndGlobalSection 35 | GlobalSection(SolutionProperties) = preSolution 36 | HideSolutionNode = FALSE 37 | EndGlobalSection 38 | EndGlobal 39 | -------------------------------------------------------------------------------- /visualizer.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {efd66821-3742-46ed-9a1e-57bbe23ad692} 6 | 7 | 8 | {a630496b-de92-4660-b76b-e9fe2a840309} 9 | 10 | 11 | {92da8cf3-e39a-427a-9f66-76519e742891} 12 | 13 | 14 | {706d6669-3a76-4bea-8b03-6baf0bbdb579} 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | third-party\kiss-fft\include 23 | 24 | 25 | 26 | --------------------------------------------------------------------------------