├── .gitignore ├── CMakeLists.txt ├── LICENSE.md ├── README.md ├── assets ├── data │ ├── ex20_scene_graphs │ │ ├── human.json │ │ ├── simple.json │ │ └── solar-system.json │ ├── ex23_sampler_objects │ │ └── scene.json │ ├── ex25_blending │ │ └── scene.json │ ├── ex26_frame_buffer │ │ └── external.json │ ├── ex29_light │ │ └── scene.json │ └── ex32_textured_material │ │ ├── lights.json │ │ └── scene.json ├── images │ ├── common │ │ ├── color-grid.png │ │ ├── materials │ │ │ ├── asphalt │ │ │ │ ├── albedo.jpg │ │ │ │ ├── emissive.jpg │ │ │ │ ├── roughness.jpg │ │ │ │ └── specular.jpg │ │ │ ├── metal │ │ │ │ ├── albedo.jpg │ │ │ │ ├── roughness.jpg │ │ │ │ └── specular.jpg │ │ │ ├── suzanne │ │ │ │ └── ambient_occlusion.jpg │ │ │ └── wood │ │ │ │ ├── albedo.jpg │ │ │ │ ├── roughness.jpg │ │ │ │ └── specular.jpg │ │ ├── monarch.png │ │ └── moon.jpg │ ├── ex24_displacement │ │ ├── Attribution.txt │ │ ├── Heightmap_Billow.png │ │ ├── Heightmap_Default.png │ │ ├── Heightmap_Island.png │ │ ├── Heightmap_Mountain.png │ │ ├── Heightmap_Plateau.png │ │ ├── Heightmap_Rocky.png │ │ ├── grass_ground_d.jpg │ │ └── mntn_white_d.jpg │ ├── ex25_blending │ │ ├── fog.png │ │ ├── glass-panels.png │ │ └── metal.png │ └── ex27_postprocessing │ │ ├── Attribution.txt │ │ └── water-normal.png ├── models │ ├── House │ │ ├── Attribution.txt │ │ ├── House.jpeg │ │ └── House.obj │ └── Suzanne │ │ ├── Suzanne.mtl │ │ └── Suzanne.obj └── shaders │ ├── ex02_shader_introduction │ ├── red.frag │ └── triangle.vert │ ├── ex03_uniforms │ ├── quad.vert │ └── uniform_color.frag │ ├── ex04_varyings │ ├── colored_triangle.vert │ └── varying_color.frag │ ├── ex05_attributes │ └── attribute_position.vert │ ├── ex06_multiple_attributes │ └── multiple_attributes.vert │ ├── ex11_transformation │ ├── tint.frag │ └── transform.vert │ ├── ex21_texture │ ├── fullscreen_triangle.vert │ └── texel_fetch.frag │ ├── ex22_texture_sampling │ ├── texture.frag │ └── transform.vert │ ├── ex24_displacement │ ├── terrain.frag │ └── terrain.vert │ ├── ex25_blending │ └── alpha_test.frag │ ├── ex27_postprocessing │ ├── blit.frag │ ├── distortion.frag │ ├── fog.frag │ └── fullscreen_triangle.vert │ ├── ex28_multiple_render_targets │ └── mrt.frag │ ├── ex29_light │ ├── directional_light.frag │ ├── light_common.glsl │ ├── light_transform.vert │ ├── point_light.frag │ └── spot_light.frag │ ├── ex30_light_array │ └── light_array.frag │ └── ex32_textured_material │ ├── light_array.frag │ ├── light_common.glsl │ ├── sky.frag │ └── sky_transform.vert ├── screenshots └── .gitignore ├── source ├── common │ ├── application.cpp │ ├── application.hpp │ ├── camera │ │ ├── camera.hpp │ │ └── controllers │ │ │ ├── fly_camera_controller.hpp │ │ │ └── orbit_camera_controller.hpp │ ├── data-types.h │ ├── imgui-utils │ │ └── utils.hpp │ ├── input │ │ ├── keyboard.hpp │ │ └── mouse.hpp │ ├── mesh │ │ ├── common-vertex-attributes.hpp │ │ ├── common-vertex-types.hpp │ │ ├── mesh-utils.cpp │ │ ├── mesh-utils.hpp │ │ ├── mesh.hpp │ │ └── vertex-attributes.hpp │ ├── shader.cpp │ ├── shader.hpp │ └── texture │ │ ├── screenshot.cpp │ │ ├── screenshot.h │ │ ├── texture-utils.cpp │ │ └── texture-utils.h └── examples │ ├── ex01_empty_window.cpp │ ├── ex02_shader_introduction.cpp │ ├── ex03_uniforms.cpp │ ├── ex04_varyings.cpp │ ├── ex05_attributes.cpp │ ├── ex06_multiple_attributes.cpp │ ├── ex07_interleaved_attributes.cpp │ ├── ex08_elements.cpp │ ├── ex09_stream.cpp │ ├── ex10_model_loading.cpp │ ├── ex11_transformation.cpp │ ├── ex12_composition.cpp │ ├── ex13_camera.cpp │ ├── ex14_projection.cpp │ ├── ex15_depth_testing.cpp │ ├── ex16_face_culling.cpp │ ├── ex17_viewports_and_scissors.cpp │ ├── ex18_camera_stacking.cpp │ ├── ex19_ray_casting.cpp │ ├── ex20_scene_graphs.cpp │ ├── ex21_texture.cpp │ ├── ex22_texture_sampling.cpp │ ├── ex23_sampler_objects.cpp │ ├── ex24_displacement.cpp │ ├── ex25_blending.cpp │ ├── ex26_frame_buffer.cpp │ ├── ex27_postprocessing.cpp │ ├── ex28_multiple_render_targets.cpp │ ├── ex29_light.cpp │ ├── ex30_light_array.cpp │ ├── ex31_light_multipass.cpp │ └── ex32_textured_material.cpp └── vendor ├── glad ├── include │ ├── KHR │ │ └── khrplatform.h │ └── glad │ │ └── gl.h └── src │ └── gl.c ├── glfw ├── CMake │ ├── GenerateMappings.cmake │ ├── MacOSXBundleInfo.plist.in │ ├── i686-w64-mingw32-clang.cmake │ ├── i686-w64-mingw32.cmake │ ├── modules │ │ ├── FindEpollShim.cmake │ │ ├── FindOSMesa.cmake │ │ ├── FindWaylandProtocols.cmake │ │ └── FindXKBCommon.cmake │ ├── x86_64-w64-mingw32-clang.cmake │ └── x86_64-w64-mingw32.cmake ├── CMakeLists.txt ├── LICENSE.md ├── README.md ├── cmake_uninstall.cmake.in ├── deps │ ├── getopt.c │ ├── getopt.h │ ├── glad │ │ ├── gl.h │ │ ├── khrplatform.h │ │ ├── vk_platform.h │ │ └── vulkan.h │ ├── glad_gl.c │ ├── glad_vulkan.c │ ├── linmath.h │ ├── mingw │ │ ├── _mingw_dxhelper.h │ │ ├── dinput.h │ │ └── xinput.h │ ├── nuklear.h │ ├── nuklear_glfw_gl2.h │ ├── stb_image_write.h │ ├── tinycthread.c │ ├── tinycthread.h │ └── vs2008 │ │ └── stdint.h ├── include │ └── GLFW │ │ ├── glfw3.h │ │ └── glfw3native.h └── src │ ├── CMakeLists.txt │ ├── cocoa_init.m │ ├── cocoa_joystick.h │ ├── cocoa_joystick.m │ ├── cocoa_monitor.m │ ├── cocoa_platform.h │ ├── cocoa_time.c │ ├── cocoa_window.m │ ├── context.c │ ├── egl_context.c │ ├── egl_context.h │ ├── glfw3.pc.in │ ├── glfw3Config.cmake.in │ ├── glfw_config.h.in │ ├── glx_context.c │ ├── glx_context.h │ ├── init.c │ ├── input.c │ ├── internal.h │ ├── linux_joystick.c │ ├── linux_joystick.h │ ├── mappings.h │ ├── mappings.h.in │ ├── monitor.c │ ├── nsgl_context.h │ ├── nsgl_context.m │ ├── null_init.c │ ├── null_joystick.c │ ├── null_joystick.h │ ├── null_monitor.c │ ├── null_platform.h │ ├── null_window.c │ ├── osmesa_context.c │ ├── osmesa_context.h │ ├── posix_thread.c │ ├── posix_thread.h │ ├── posix_time.c │ ├── posix_time.h │ ├── vulkan.c │ ├── wgl_context.c │ ├── wgl_context.h │ ├── win32_init.c │ ├── win32_joystick.c │ ├── win32_joystick.h │ ├── win32_monitor.c │ ├── win32_platform.h │ ├── win32_thread.c │ ├── win32_time.c │ ├── win32_window.c │ ├── window.c │ ├── wl_init.c │ ├── wl_monitor.c │ ├── wl_platform.h │ ├── wl_window.c │ ├── x11_init.c │ ├── x11_monitor.c │ ├── x11_platform.h │ ├── x11_window.c │ ├── xkb_unicode.c │ └── xkb_unicode.h ├── glm └── glm │ ├── CMakeLists.txt │ ├── common.hpp │ ├── detail │ ├── _features.hpp │ ├── _fixes.hpp │ ├── _noise.hpp │ ├── _swizzle.hpp │ ├── _swizzle_func.hpp │ ├── _vectorize.hpp │ ├── compute_common.hpp │ ├── compute_vector_relational.hpp │ ├── func_common.inl │ ├── func_common_simd.inl │ ├── func_exponential.inl │ ├── func_exponential_simd.inl │ ├── func_geometric.inl │ ├── func_geometric_simd.inl │ ├── func_integer.inl │ ├── func_integer_simd.inl │ ├── func_matrix.inl │ ├── func_matrix_simd.inl │ ├── func_packing.inl │ ├── func_packing_simd.inl │ ├── func_trigonometric.inl │ ├── func_trigonometric_simd.inl │ ├── func_vector_relational.inl │ ├── func_vector_relational_simd.inl │ ├── glm.cpp │ ├── qualifier.hpp │ ├── setup.hpp │ ├── type_float.hpp │ ├── type_half.hpp │ ├── type_half.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_quat.hpp │ ├── type_quat.inl │ ├── type_quat_simd.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 │ ├── ext │ ├── matrix_clip_space.hpp │ ├── matrix_clip_space.inl │ ├── matrix_common.hpp │ ├── matrix_common.inl │ ├── matrix_double2x2.hpp │ ├── matrix_double2x2_precision.hpp │ ├── matrix_double2x3.hpp │ ├── matrix_double2x3_precision.hpp │ ├── matrix_double2x4.hpp │ ├── matrix_double2x4_precision.hpp │ ├── matrix_double3x2.hpp │ ├── matrix_double3x2_precision.hpp │ ├── matrix_double3x3.hpp │ ├── matrix_double3x3_precision.hpp │ ├── matrix_double3x4.hpp │ ├── matrix_double3x4_precision.hpp │ ├── matrix_double4x2.hpp │ ├── matrix_double4x2_precision.hpp │ ├── matrix_double4x3.hpp │ ├── matrix_double4x3_precision.hpp │ ├── matrix_double4x4.hpp │ ├── matrix_double4x4_precision.hpp │ ├── matrix_float2x2.hpp │ ├── matrix_float2x2_precision.hpp │ ├── matrix_float2x3.hpp │ ├── matrix_float2x3_precision.hpp │ ├── matrix_float2x4.hpp │ ├── matrix_float2x4_precision.hpp │ ├── matrix_float3x2.hpp │ ├── matrix_float3x2_precision.hpp │ ├── matrix_float3x3.hpp │ ├── matrix_float3x3_precision.hpp │ ├── matrix_float3x4.hpp │ ├── matrix_float3x4_precision.hpp │ ├── matrix_float4x2.hpp │ ├── matrix_float4x2_precision.hpp │ ├── matrix_float4x3.hpp │ ├── matrix_float4x3_precision.hpp │ ├── matrix_float4x4.hpp │ ├── matrix_float4x4_precision.hpp │ ├── matrix_int2x2.hpp │ ├── matrix_int2x2_sized.hpp │ ├── matrix_int2x3.hpp │ ├── matrix_int2x3_sized.hpp │ ├── matrix_int2x4.hpp │ ├── matrix_int2x4_sized.hpp │ ├── matrix_int3x2.hpp │ ├── matrix_int3x2_sized.hpp │ ├── matrix_int3x3.hpp │ ├── matrix_int3x3_sized.hpp │ ├── matrix_int3x4.hpp │ ├── matrix_int3x4_sized.hpp │ ├── matrix_int4x2.hpp │ ├── matrix_int4x2_sized.hpp │ ├── matrix_int4x3.hpp │ ├── matrix_int4x3_sized.hpp │ ├── matrix_int4x4.hpp │ ├── matrix_int4x4_sized.hpp │ ├── matrix_projection.hpp │ ├── matrix_projection.inl │ ├── matrix_relational.hpp │ ├── matrix_relational.inl │ ├── matrix_transform.hpp │ ├── matrix_transform.inl │ ├── matrix_uint2x2.hpp │ ├── matrix_uint2x2_sized.hpp │ ├── matrix_uint2x3.hpp │ ├── matrix_uint2x3_sized.hpp │ ├── matrix_uint2x4.hpp │ ├── matrix_uint2x4_sized.hpp │ ├── matrix_uint3x2.hpp │ ├── matrix_uint3x2_sized.hpp │ ├── matrix_uint3x3.hpp │ ├── matrix_uint3x3_sized.hpp │ ├── matrix_uint3x4.hpp │ ├── matrix_uint3x4_sized.hpp │ ├── matrix_uint4x2.hpp │ ├── matrix_uint4x2_sized.hpp │ ├── matrix_uint4x3.hpp │ ├── matrix_uint4x3_sized.hpp │ ├── matrix_uint4x4.hpp │ ├── matrix_uint4x4_sized.hpp │ ├── quaternion_common.hpp │ ├── quaternion_common.inl │ ├── quaternion_common_simd.inl │ ├── quaternion_double.hpp │ ├── quaternion_double_precision.hpp │ ├── quaternion_exponential.hpp │ ├── quaternion_exponential.inl │ ├── quaternion_float.hpp │ ├── quaternion_float_precision.hpp │ ├── quaternion_geometric.hpp │ ├── quaternion_geometric.inl │ ├── quaternion_relational.hpp │ ├── quaternion_relational.inl │ ├── quaternion_transform.hpp │ ├── quaternion_transform.inl │ ├── quaternion_trigonometric.hpp │ ├── quaternion_trigonometric.inl │ ├── scalar_common.hpp │ ├── scalar_common.inl │ ├── scalar_constants.hpp │ ├── scalar_constants.inl │ ├── scalar_int_sized.hpp │ ├── scalar_integer.hpp │ ├── scalar_integer.inl │ ├── scalar_packing.hpp │ ├── scalar_packing.inl │ ├── scalar_relational.hpp │ ├── scalar_relational.inl │ ├── scalar_uint_sized.hpp │ ├── scalar_ulp.hpp │ ├── scalar_ulp.inl │ ├── vector_bool1.hpp │ ├── vector_bool1_precision.hpp │ ├── vector_bool2.hpp │ ├── vector_bool2_precision.hpp │ ├── vector_bool3.hpp │ ├── vector_bool3_precision.hpp │ ├── vector_bool4.hpp │ ├── vector_bool4_precision.hpp │ ├── vector_common.hpp │ ├── vector_common.inl │ ├── vector_double1.hpp │ ├── vector_double1_precision.hpp │ ├── vector_double2.hpp │ ├── vector_double2_precision.hpp │ ├── vector_double3.hpp │ ├── vector_double3_precision.hpp │ ├── vector_double4.hpp │ ├── vector_double4_precision.hpp │ ├── vector_float1.hpp │ ├── vector_float1_precision.hpp │ ├── vector_float2.hpp │ ├── vector_float2_precision.hpp │ ├── vector_float3.hpp │ ├── vector_float3_precision.hpp │ ├── vector_float4.hpp │ ├── vector_float4_precision.hpp │ ├── vector_int1.hpp │ ├── vector_int1_sized.hpp │ ├── vector_int2.hpp │ ├── vector_int2_sized.hpp │ ├── vector_int3.hpp │ ├── vector_int3_sized.hpp │ ├── vector_int4.hpp │ ├── vector_int4_sized.hpp │ ├── vector_integer.hpp │ ├── vector_integer.inl │ ├── vector_packing.hpp │ ├── vector_packing.inl │ ├── vector_relational.hpp │ ├── vector_relational.inl │ ├── vector_uint1.hpp │ ├── vector_uint1_sized.hpp │ ├── vector_uint2.hpp │ ├── vector_uint2_sized.hpp │ ├── vector_uint3.hpp │ ├── vector_uint3_sized.hpp │ ├── vector_uint4.hpp │ ├── vector_uint4_sized.hpp │ ├── vector_ulp.hpp │ └── vector_ulp.inl │ ├── 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 │ ├── 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 │ ├── 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 │ ├── easing.hpp │ ├── easing.inl │ ├── euler_angles.hpp │ ├── euler_angles.inl │ ├── extend.hpp │ ├── extend.inl │ ├── extended_min_max.hpp │ ├── extended_min_max.inl │ ├── exterior_product.hpp │ ├── exterior_product.inl │ ├── fast_exponential.hpp │ ├── fast_exponential.inl │ ├── fast_square_root.hpp │ ├── fast_square_root.inl │ ├── fast_trigonometry.hpp │ ├── fast_trigonometry.inl │ ├── float_notmalize.inl │ ├── functions.hpp │ ├── functions.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_factorisation.hpp │ ├── matrix_factorisation.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 │ ├── texture.hpp │ ├── texture.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 │ ├── neon.h │ ├── packing.h │ ├── platform.h │ ├── trigonometric.h │ └── vector_relational.h │ ├── trigonometric.hpp │ ├── vec2.hpp │ ├── vec3.hpp │ ├── vec4.hpp │ └── vector_relational.hpp ├── imgui ├── LICENSE.txt ├── imconfig.h ├── imgui.cpp ├── imgui.h ├── imgui_demo.cpp ├── imgui_draw.cpp ├── imgui_impl │ ├── imgui_impl_glfw.cpp │ ├── imgui_impl_glfw.h │ ├── imgui_impl_opengl3.cpp │ └── imgui_impl_opengl3.h ├── imgui_internal.h ├── imgui_widgets.cpp ├── imstb_rectpack.h ├── imstb_textedit.h └── imstb_truetype.h └── utils ├── json └── json.hpp ├── stb ├── LICENSE ├── stb_image.h ├── stb_image_write.h └── stb_include.h ├── tinygltf ├── LICENSE ├── json.hpp ├── stb_image.h ├── stb_image_write.h └── tiny_gltf.h └── tinyobj └── tiny_obj_loader.h /.gitignore: -------------------------------------------------------------------------------- 1 | # build directories 2 | cmake-build-*/ 3 | build/ 4 | out/ 5 | 6 | # imgui saved state 7 | imgui.ini 8 | 9 | # Since ".obj" are ignored by default, we force them to be added 10 | !assets/models/**/*.obj 11 | 12 | # Visual Studio specific files 13 | CMakeSettings.json 14 | .vs/ 15 | 16 | # Clion specific files 17 | .idea/ 18 | 19 | # Visual Studio Code specific files 20 | .vscode/ -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Yahia Zakaria 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /assets/data/ex20_scene_graphs/simple.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "root", 3 | "mesh": "cube", 4 | "children": { 5 | "child-1": { 6 | "translation": [-2, 2, 0], 7 | "scale": [0.5, 0.5, 0.5], 8 | "mesh": "cube", 9 | "children": { 10 | "grand-child-1": { 11 | "translation": [0, 2, -2], 12 | "scale": [0.5, 0.5, 0.5], 13 | "mesh": "cube" 14 | }, 15 | "grand-child-2": { 16 | "translation": [0, 2, 2], 17 | "scale": [0.5, 0.5, 0.5], 18 | "mesh": "cube" 19 | } 20 | } 21 | }, 22 | "child-2": { 23 | "translation": [2, 2, 0], 24 | "scale": [0.5, 0.5, 0.5], 25 | "mesh": "cube", 26 | "children": { 27 | "grand-child-1": { 28 | "translation": [0, 2, -2], 29 | "scale": [0.5, 0.5, 0.5], 30 | "mesh": "cube" 31 | }, 32 | "grand-child-2": { 33 | "translation": [0, 2, 2], 34 | "scale": [0.5, 0.5, 0.5], 35 | "mesh": "cube" 36 | } 37 | } 38 | } 39 | } 40 | } -------------------------------------------------------------------------------- /assets/data/ex23_sampler_objects/scene.json: -------------------------------------------------------------------------------- 1 | { 2 | "children": { 3 | "ground": { 4 | "mesh": "plane", 5 | "scale": [500, 1, 500], 6 | "texture": "checkerboard", 7 | "tint": [0.96, 0.9, 0.64, 1] 8 | }, 9 | "house": { 10 | "mesh": "house", 11 | "texture": "house" 12 | }, 13 | "moon-axis": { 14 | "translation": [10, 10, -10], 15 | "rotation": [1, 0.5, 1], 16 | "children": { 17 | "moon": { 18 | "mesh": "sphere", 19 | "texture": "moon", 20 | "scale": [3, 3, 3] 21 | } 22 | } 23 | } 24 | } 25 | } -------------------------------------------------------------------------------- /assets/data/ex26_frame_buffer/external.json: -------------------------------------------------------------------------------- 1 | { 2 | "children": { 3 | "ground": { 4 | "mesh": "plane", 5 | "scale": [500, 1, 500], 6 | "texture": "checkerboard", 7 | "tint": [0.32, 0.16, 0.64, 1] 8 | }, 9 | "house": { 10 | "mesh": "house", 11 | "texture": "color_rt" 12 | }, 13 | "cube": { 14 | "mesh": "cube", 15 | "texture": "color_rt", 16 | "translation": [10, 1, 0], 17 | "scale": [2, 2, 2] 18 | }, 19 | "moon-axis": { 20 | "translation": [10, 10, -10], 21 | "rotation": [1, 0.5, 1], 22 | "children": { 23 | "moon": { 24 | "mesh": "sphere", 25 | "texture": "color_rt", 26 | "scale": [5, 5, 5], 27 | "tint": [0.5, 0.75, 1, 1] 28 | } 29 | } 30 | } 31 | } 32 | } -------------------------------------------------------------------------------- /assets/data/ex32_textured_material/lights.json: -------------------------------------------------------------------------------- 1 | { 2 | "sky": { 3 | "top_color": [0.25, 0.3, 0.5], 4 | "middle_color": [0.35, 0.35, 0.4], 5 | "bottom_color": [0.25, 0.25, 0.25] 6 | }, 7 | "lights": [ 8 | { 9 | "type": "directional", 10 | "color": [1, 0.8, 0.2], 11 | "direction": [-1, -1, -1] 12 | }, 13 | { 14 | "type": "point", 15 | "color": [0.2, 1, 0.5], 16 | "position": [0, 1, 3] 17 | }, 18 | { 19 | "type": "spot", 20 | "color": [1, 0.1, 0.2], 21 | "position": [0, 1, -4], 22 | "direction": [0, 0, 1], 23 | "spot_angle": { 24 | "inner": 0.78539816339, 25 | "outer": 1.57079632679 26 | } 27 | }, 28 | { 29 | "type": "point", 30 | "enabled": false, 31 | "color": [1, 1, 1], 32 | "position": [10, 10, -10], 33 | "attenuation": { 34 | "constant": 0, 35 | "linear": 1, 36 | "quadratic": 0 37 | } 38 | } 39 | ] 40 | } -------------------------------------------------------------------------------- /assets/images/common/color-grid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/color-grid.png -------------------------------------------------------------------------------- /assets/images/common/materials/asphalt/albedo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/asphalt/albedo.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/asphalt/emissive.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/asphalt/emissive.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/asphalt/roughness.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/asphalt/roughness.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/asphalt/specular.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/asphalt/specular.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/metal/albedo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/metal/albedo.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/metal/roughness.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/metal/roughness.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/metal/specular.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/metal/specular.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/suzanne/ambient_occlusion.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/suzanne/ambient_occlusion.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/wood/albedo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/wood/albedo.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/wood/roughness.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/wood/roughness.jpg -------------------------------------------------------------------------------- /assets/images/common/materials/wood/specular.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/materials/wood/specular.jpg -------------------------------------------------------------------------------- /assets/images/common/monarch.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/monarch.png -------------------------------------------------------------------------------- /assets/images/common/moon.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/common/moon.jpg -------------------------------------------------------------------------------- /assets/images/ex24_displacement/Attribution.txt: -------------------------------------------------------------------------------- 1 | The Heightmaps: 2 | - Heighmap_Billow.png 3 | - Heighmap_Island.png 4 | - Heighmap_Mountain.png 5 | - Heighmap_Plateau.png 6 | - Heighmap_Rock.png 7 | were downloaded from: https://fools-errand.itch.io/5-free-terrain-heightmaps 8 | 9 | -------------------------------------------------------------------------------- /assets/images/ex24_displacement/Heightmap_Billow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex24_displacement/Heightmap_Billow.png -------------------------------------------------------------------------------- /assets/images/ex24_displacement/Heightmap_Default.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex24_displacement/Heightmap_Default.png -------------------------------------------------------------------------------- /assets/images/ex24_displacement/Heightmap_Island.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex24_displacement/Heightmap_Island.png -------------------------------------------------------------------------------- /assets/images/ex24_displacement/Heightmap_Mountain.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex24_displacement/Heightmap_Mountain.png -------------------------------------------------------------------------------- /assets/images/ex24_displacement/Heightmap_Plateau.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex24_displacement/Heightmap_Plateau.png -------------------------------------------------------------------------------- /assets/images/ex24_displacement/Heightmap_Rocky.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex24_displacement/Heightmap_Rocky.png -------------------------------------------------------------------------------- /assets/images/ex24_displacement/grass_ground_d.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex24_displacement/grass_ground_d.jpg -------------------------------------------------------------------------------- /assets/images/ex24_displacement/mntn_white_d.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex24_displacement/mntn_white_d.jpg -------------------------------------------------------------------------------- /assets/images/ex25_blending/fog.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex25_blending/fog.png -------------------------------------------------------------------------------- /assets/images/ex25_blending/glass-panels.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex25_blending/glass-panels.png -------------------------------------------------------------------------------- /assets/images/ex25_blending/metal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex25_blending/metal.png -------------------------------------------------------------------------------- /assets/images/ex27_postprocessing/Attribution.txt: -------------------------------------------------------------------------------- 1 | Source for water-normal.png : https://catlikecoding.com/unity/tutorials/flow/texture-distortion/ -------------------------------------------------------------------------------- /assets/images/ex27_postprocessing/water-normal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/images/ex27_postprocessing/water-normal.png -------------------------------------------------------------------------------- /assets/models/House/Attribution.txt: -------------------------------------------------------------------------------- 1 | Made by Denis Loginovskiy 2 | https://skfb.ly/6vYUW -------------------------------------------------------------------------------- /assets/models/House/House.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/assets/models/House/House.jpeg -------------------------------------------------------------------------------- /assets/models/Suzanne/Suzanne.mtl: -------------------------------------------------------------------------------- 1 | # Blender MTL File: 'None' 2 | # Material Count: 1 3 | 4 | newmtl Default_OBJ 5 | Ns 225.000000 6 | Ka 1.000000 1.000000 1.000000 7 | Kd 0.800000 0.800000 0.800000 8 | Ks 0.500000 0.500000 0.500000 9 | Ke 0.000000 0.000000 0.000000 10 | Ni 1.450000 11 | d 1.000000 12 | illum 2 13 | -------------------------------------------------------------------------------- /assets/shaders/ex02_shader_introduction/red.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | // The first line of any shader must a '#version" command which defines the glsl version to use 3 | 4 | // This will be the output (you can choose any name) and it will be sent to the frame buffer (back buffer of the window). 5 | out vec4 frag_color; 6 | 7 | // This is entry point of the fragment shader and it will be called for every fragment covered by the rasterized geometry 8 | void main() { 9 | // Here we just output a constant color which is red (R=1, G=0, B=0, A=1) 10 | frag_color = vec4(1.0, 0.0, 0.0, 1.0); 11 | } 12 | -------------------------------------------------------------------------------- /assets/shaders/ex03_uniforms/quad.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // Here we will define Uniform Variable 4 | // they are called uniform because every run of the shader (under the same draw call) will see the same value 5 | // so it is uniform across all executions of the shader 6 | uniform vec2 scale; 7 | uniform vec2 translation; 8 | uniform float time; 9 | uniform bool vibrate; 10 | 11 | // Just a constant 12 | #define PI 3.1415926535897932384626433832795 13 | 14 | void main() { 15 | // This time we have 6 points since we are drawing a Quad (in NDC, it is a square). 16 | const vec3 positions[6] = vec3[6]( 17 | vec3(-1.0, -1.0, 0.0), 18 | vec3( 1.0, -1.0, 0.0), 19 | vec3( 1.0, 1.0, 0.0), 20 | vec3( 1.0, 1.0, 0.0), 21 | vec3(-1.0, 1.0, 0.0), 22 | vec3(-1.0, -1.0, 0.0) 23 | ); 24 | 25 | // get the position based on the vertex id 26 | vec3 position = positions[gl_VertexID]; 27 | // Scale it 28 | position.xy *= scale; 29 | // If vibrate is on, scale it with a sinusoidal wave that oscillates over time 30 | if(vibrate) 31 | position.xy *= 1 + 0.1 * sin(2 * PI * time); 32 | // Translate it 33 | position.xy += translation; 34 | 35 | // Finally send the value to "gl_Position". 36 | gl_Position = vec4(position, 1.0); 37 | } -------------------------------------------------------------------------------- /assets/shaders/ex03_uniforms/uniform_color.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // Here we will define Uniform Variable 4 | // they are called uniform because every run of the shader (under the same draw call) will see the same value 5 | // so it is uniform across all executions of the shader 6 | uniform vec3 color; 7 | uniform float time; 8 | uniform bool flicker; 9 | 10 | // The output that goes to the frame buffer 11 | out vec4 frag_color; 12 | 13 | // Just a constant 14 | #define PI 3.1415926535897932384626433832795 15 | 16 | void main() { 17 | // Convert RGB to RGBA (in other words, add an alpha value). 18 | frag_color = vec4(color, 1.0); 19 | // If flickering, multiply it with a sinusoidal wave that oscillates over time 20 | if(flicker) 21 | frag_color.rgb *= 0.5 * (1 + cos(2 * PI * time)); 22 | } 23 | -------------------------------------------------------------------------------- /assets/shaders/ex04_varyings/colored_triangle.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // This output will be sent to the fragment shader 4 | // These are usually called "Varyings" since their value varys from one run to the other 5 | // However, "Varyings" are *only* used to denote variables connecting between the vertex and the fragment shaders 6 | out vec4 vertex_color; 7 | 8 | void main() { 9 | // Array of triangle positions 10 | const vec3 positions[3] = vec3[3]( 11 | vec3( 0.5, -0.5, 0.0), 12 | vec3(-0.5, -0.5, 0.0), 13 | vec3( 0.0, 0.5, 0.0) 14 | ); 15 | 16 | // Array of colors 17 | const vec4 colors[3] = vec4[3]( 18 | vec4(1.0, 0.0, 0.0, 1.0), 19 | vec4(0.0, 1.0, 0.0, 1.0), 20 | vec4(0.0, 0.0, 1.0, 1.0) 21 | ); 22 | 23 | // As usual, we will pick one position and send to "gl_Position" 24 | gl_Position = vec4(positions[gl_VertexID], 1.0); 25 | // Similarly, we'll pick a color and send it to a Varying 26 | vertex_color = colors[gl_VertexID]; 27 | } -------------------------------------------------------------------------------- /assets/shaders/ex04_varyings/varying_color.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // This output is received from the vertex shader 4 | // These are usually called "Varyings" since their value varys from one run to the other 5 | // However, "Varyings" are *only* used to denote variables connecting between different shaders 6 | in vec4 vertex_color; 7 | // It is noteworthy that the vertex shader sends a value for each vertex only 8 | // So to get a value for each fragment, the rasterizer interpolates the values using what is called "barycentric coordinates". 9 | // barycentric coordinates are 3 values that define how near we are to each vertex of a triangle (and they always sum to 1). 10 | 11 | // This is the output of the fragment shader 12 | // Note that even though this value will vary on each execution of the shader, it is still *not* called a "Varying". 13 | // That's because it is not passed between the vertex and the fragment shader 14 | out vec4 frag_color; 15 | 16 | void main() { 17 | // Just pass the varying to the output 18 | frag_color = vertex_color; 19 | } 20 | -------------------------------------------------------------------------------- /assets/shaders/ex05_attributes/attribute_position.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // This an input recieved from the vertex buffers and injected into the vertex shader. 4 | // This type of variables is called "Attributes". Only vertex shaders can receive attributes. 5 | // The "vertex array" object is what defines how the data is read from the vertex buffer and send to this attribute. 6 | // In "layout(location = 0)", we request that this attribute is put into location 0. 7 | // If we omit the "layout" specifier, OpenGL will automatically select a location for it. 8 | layout(location = 0) in vec3 position; 9 | 10 | void main() { 11 | // Just send the attribute value to "gl_Position". 12 | gl_Position = vec4(position, 1.0); 13 | } -------------------------------------------------------------------------------- /assets/shaders/ex06_multiple_attributes/multiple_attributes.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // Here we are receiving 2 attributes 4 | // We gave each of them a different location 5 | layout(location = 0) in vec3 position; 6 | layout(location = 1) in vec4 color; 7 | // INFO: a location can only hold up to 4 floats or ints (a vec4 or a ivec4), 8 | // so if we send a 4x4 matrix (mat4), it will use 4 locations. 9 | // So this code is invalid: 10 | // layout(location = 0) in mat4 matrix; 11 | // layout(location = 1) in vec4 color; 12 | // since "color" will overlap with "matrix". So we can modify it like this: 13 | // layout(location = 0) in mat4 matrix; 14 | // layout(location = 4) in vec4 color; 15 | // Now it should work. 16 | // Note that a 2x2 matrix has 4 floats only but it will still take 2 locations since each column will take a separate location. 17 | // The same rule applies to array, so an array of N-floats will take N-locations (not N/4) since each float will take a whole location for itself. 18 | // Since locations are limited, it is more efficient to try and pack data into 4D vectors. 19 | 20 | // The varying for the vertex color 21 | out vec4 vertex_color; 22 | 23 | void main() { 24 | // Just passing data unmodified 25 | gl_Position = vec4(position, 1.0); 26 | vertex_color = color; 27 | } -------------------------------------------------------------------------------- /assets/shaders/ex11_transformation/tint.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | in vec4 vertex_color; 4 | 5 | uniform vec4 tint; // A tint is something we can use to modify colors 6 | 7 | out vec4 frag_color; 8 | 9 | void main() { 10 | // We use a uniform and a varying together to be able to have a unique color for each object while sharing the same vertex data. 11 | frag_color = tint * vertex_color; 12 | } 13 | -------------------------------------------------------------------------------- /assets/shaders/ex11_transformation/transform.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // The attributes 4 | layout(location = 0) in vec3 position; 5 | layout(location = 1) in vec4 color; 6 | 7 | // A transformation matrix sent as a Uniform 8 | uniform mat4 transform; 9 | 10 | // The varying 11 | out vec4 vertex_color; 12 | 13 | void main() { 14 | // To apply the transformation, we just multiply 15 | gl_Position = transform * vec4(position, 1.0); 16 | vertex_color = color; 17 | } 18 | 19 | // NOTE: Since "transform" is allowed to modify "w", we can create a matrix that applies perspective projection which is a key factor of realistic 3D visuals. -------------------------------------------------------------------------------- /assets/shaders/ex21_texture/fullscreen_triangle.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | void main() { 4 | // This triangle will cover the whole screen (viewport) 5 | const vec2 positions[3] = vec2[3]( 6 | vec2(-1, -1), 7 | vec2(3, -1), 8 | vec2(-1, 3) 9 | ); 10 | 11 | gl_Position = vec4(positions[gl_VertexID], 0.0, 1.0); 12 | } 13 | -------------------------------------------------------------------------------- /assets/shaders/ex21_texture/texel_fetch.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // To read colors from a texture, we need a "Sampler" which fetches the color from texture based on our query 4 | uniform sampler2D sampler; 5 | // The Level-Of-Detail (lod) allows us to select a mip level to read the color from. 6 | // Higher LOD means smaller mip size, thus a lower resolution version of the texture. 7 | uniform int lod; 8 | // Since some mip levels are too small, we will use the zoom variable to zoom in. 9 | uniform float zoom; 10 | 11 | out vec4 frag_color; 12 | 13 | void main() { 14 | // Get the mip level size based on the Level-Of-Detail (lod) 15 | // NOTE: the size of a mip level at a specific lod should be: full_texture_size / 2^lod 16 | ivec2 texture_size = textureSize(sampler, lod); 17 | // Get the pixel location on the framebuffer and apply zooming 18 | ivec2 frag_coord = ivec2(gl_FragCoord.xy / zoom); 19 | // Since we should query a color from outside the mip level range (behaviour is undefined), 20 | // We only read the colors if fragment coordinate is less than the mip level size 21 | if(all(lessThan(frag_coord, texture_size))) 22 | frag_color = texelFetch(sampler, frag_coord, lod); // Fetch a color from the texture at the given mip level (lod). 23 | else 24 | frag_color = vec4(0, 0, 0, 1); // Send black if fragment coordinate is out of range 25 | } 26 | -------------------------------------------------------------------------------- /assets/shaders/ex22_texture_sampling/texture.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // Since we are now receiving multiple Varyings, it would be nice to pack them together in what is called an "Interface Block". 4 | // "Varyings" is just a name for the block (we can choose any name as long as it is the same in the vertex shader). 5 | // "vsout" is an instance name (we can make an array of the same block and pick any name we want). 6 | // instance names can be different in the vertex shader and the blocks will still match and link together. 7 | // Interface blocks are nice for organization. 8 | in Varyings { 9 | vec4 color; 10 | vec2 tex_coord; 11 | } fsin; 12 | 13 | uniform vec4 tint; 14 | uniform sampler2D sampler; // We need a sampler to sample from a texture 15 | 16 | out vec4 frag_color; 17 | 18 | void main() { 19 | // Unlike "texelFetch" which is queried by coordinates in the pixel space, 20 | // "texture" is queried by the coordinates in the texture space. 21 | // Also "texture" applies filtering (so it also selects a suitable Level-Of-Detail automatically). 22 | frag_color = tint * fsin.color * texture(sampler, fsin.tex_coord); 23 | 24 | // NOTE: (coordinates in pixel space) = (coordinates in texture space) * (texture size) 25 | // So texture space is convenient since it is independent of the texture size. 26 | } 27 | -------------------------------------------------------------------------------- /assets/shaders/ex22_texture_sampling/transform.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | layout(location = 0) in vec3 position; 4 | layout(location = 1) in vec4 color; 5 | // Now we are recieving a new attribute "Texture Coordinate" (tex_coord). 6 | // This attribute will define where the vertex lies in the texture space 7 | layout(location = 2) in vec2 tex_coord; 8 | 9 | uniform mat4 transform; 10 | 11 | // Since we are now sending multiple Varyings, it would be nice to pack them together in what is called an "Interface Block". 12 | // "Varyings" is just a name for the block (we can choose any name as long as it is the same in the fragment shader). 13 | // "vsout" is an instance name (we can make an array of the same block and pick any name we want). 14 | // instance names can be different in the fragment shader and the blocks will still match and link together. 15 | // Interface blocks are nice for organization. 16 | out Varyings { 17 | vec4 color; 18 | vec2 tex_coord; 19 | } vsout; 20 | 21 | void main() { 22 | gl_Position = transform * vec4(position, 1.0); 23 | vsout.color = color; 24 | // The fragment shader will use the texture coordinates so we pass them to it. 25 | vsout.tex_coord = tex_coord; 26 | } 27 | -------------------------------------------------------------------------------- /assets/shaders/ex25_blending/alpha_test.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | in Varyings { 4 | vec4 color; 5 | vec2 tex_coord; 6 | } fsin; 7 | 8 | uniform vec4 tint; 9 | uniform sampler2D sampler; 10 | // We will use this threshold to decide which pixels to discard based on its alpha value. 11 | uniform float alpha_threshold; 12 | 13 | out vec4 frag_color; 14 | 15 | void main() { 16 | vec4 color = tint * fsin.color * texture(sampler, fsin.tex_coord); 17 | // If the alpha value is below the threshold, discard the whole pixel. 18 | if(color.a < alpha_threshold) discard; 19 | frag_color = color; 20 | } 21 | -------------------------------------------------------------------------------- /assets/shaders/ex27_postprocessing/blit.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | in vec2 tex_coord; 4 | 5 | // This will be used to sample a color from the off-screen framebuffer on which we draw our scene. 6 | uniform sampler2D color_sampler; 7 | 8 | out vec4 frag_color; 9 | 10 | void main() { 11 | // Get the texture size at mip level 0. 12 | ivec2 texture_size = textureSize(color_sampler, 0); 13 | // Convert the screen-space texture coordinate to a pixel coordinate in the "color_sampler" texture. 14 | ivec2 frag_coord = ivec2(tex_coord * texture_size); 15 | // Read and output color using texelFetch. Note that we don't need to use texture since we know that the texture_size and screen size is the same 16 | // so the pixels in the "color_sampler" and the screen will map 1:1 so no need for the filtering overhead. 17 | frag_color = texelFetch(color_sampler, frag_coord, 0); 18 | } 19 | -------------------------------------------------------------------------------- /assets/shaders/ex27_postprocessing/distortion.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | in vec2 tex_coord; 4 | 5 | // This will be used to sample a color from the off-screen framebuffer on which we draw our scene. 6 | uniform sampler2D color_sampler; 7 | // This will be used to distort our texture coordinates to get an underwater look. 8 | uniform sampler2D distortion_sampler; 9 | // This controls how much the texture coordinates will be distorted. 0 means no distortion. 10 | uniform float distortion_power; 11 | 12 | out vec4 frag_color; 13 | 14 | void main() { 15 | // First, we sample a distortion value from the distortion texture, we then subtract 0.5 such that the values are centered around 0 then we apply the power. 16 | vec2 distortion = (texture(distortion_sampler, tex_coord).xy - 0.5f) * distortion_power; 17 | // Before sampling the scene color, we add the distortion to sample a color from a slightly different location thus causing the distorted look. 18 | frag_color = texture(color_sampler, tex_coord + distortion); 19 | } 20 | -------------------------------------------------------------------------------- /assets/shaders/ex27_postprocessing/fullscreen_triangle.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | out vec2 tex_coord; 4 | 5 | void main() { 6 | // A fullscreen triangle 7 | const vec2 positions[3] = vec2[3]( 8 | vec2(-1, -1), 9 | vec2(3, -1), 10 | vec2(-1, 3) 11 | ); 12 | 13 | // Get the triangle position based on the vertex ID. 14 | vec2 position = positions[gl_VertexID]; 15 | gl_Position = vec4(position, 0.0, 1.0); 16 | // Convert the vertex position to a screen-space texture coordinate. 17 | tex_coord = (position + 1.0f) * 0.5f; 18 | } 19 | -------------------------------------------------------------------------------- /assets/shaders/ex28_multiple_render_targets/mrt.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | in Varyings { 4 | vec4 color; 5 | vec2 tex_coord; 6 | } fsin; 7 | 8 | uniform vec4 tint; 9 | uniform sampler2D sampler; 10 | 11 | // Here we will output 3 values and each value will go to a certain render target. 12 | layout(location = 0) out vec4 frag_color; 13 | layout(location = 1) out vec2 tex_coord; 14 | layout(location = 2) out vec2 tex_coord_derivative; 15 | 16 | void main() { 17 | // First output will be the texture color after applying the per-vertex color and tint. 18 | frag_color = tint * fsin.color * texture(sampler, fsin.tex_coord); 19 | // Second output will be the fractional part of the texture coordinates. 20 | tex_coord = fract(fsin.tex_coord); 21 | // Third output will be gradient length of the texture coordinates with respect to the screen pixels. 22 | tex_coord_derivative = fwidth(fsin.tex_coord); 23 | } 24 | -------------------------------------------------------------------------------- /assets/shaders/ex29_light/light_common.glsl: -------------------------------------------------------------------------------- 1 | #ifndef OUR_LIGHT_COMMON_GLSL_INCLUDED 2 | #define OUR_LIGHT_COMMON_GLSL_INCLUDED 3 | 4 | // These are some common functions and data structures for all types of lights so we wrote them in a single file to be included in the other files. 5 | 6 | // This will be used to compute the diffuse factor. 7 | float calculate_lambert(vec3 normal, vec3 light_direction){ 8 | return max(0.0f, dot(normal, -light_direction)); 9 | } 10 | 11 | // This will be used to compute the phong specular. 12 | float calculate_phong(vec3 normal, vec3 light_direction, vec3 view, float shininess){ 13 | vec3 reflected = reflect(light_direction, normal); 14 | return pow(max(0.0f, dot(view, reflected)), shininess); 15 | } 16 | 17 | // This contains all the material properties in a single struct. 18 | struct Material { 19 | vec3 diffuse; 20 | vec3 specular; 21 | vec3 ambient; 22 | float shininess; 23 | }; 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /assets/shaders/ex32_textured_material/sky.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | in Varyings { 4 | // To compute the sky color, we only need the view direction. 5 | vec3 view; 6 | } fsin; 7 | 8 | // These are the 3 colors of the sky. 9 | struct SkyLight { 10 | vec3 top_color, middle_color, bottom_color; 11 | }; 12 | 13 | uniform SkyLight sky_light; 14 | uniform float exposure; // Exposure will be used to control how bright the sky will look. 15 | 16 | out vec4 frag_color; 17 | 18 | void main() { 19 | // First, we normalize the view direction. 20 | vec3 view = normalize(fsin.view); 21 | 22 | // Then we compute the sky color based on the view direction. 23 | vec3 sky_color = exposure * (view.y > 0 ? 24 | mix(sky_light.middle_color, sky_light.top_color, view.y) : 25 | mix(sky_light.middle_color, sky_light.bottom_color, -view.y)); 26 | 27 | frag_color = vec4(sky_color, 1.0f); 28 | } 29 | -------------------------------------------------------------------------------- /assets/shaders/ex32_textured_material/sky_transform.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | layout(location = 0) in vec3 position; 4 | 5 | // The sky box will always follow the camera so there is no need for an object to world matrix since we will translate it using the camera position. 6 | uniform mat4 view_projection; 7 | uniform vec3 camera_position; 8 | 9 | out Varyings { 10 | // To compute the sky color, we only need the view direction. 11 | vec3 view; 12 | } vsout; 13 | 14 | void main() { 15 | // The view direction will be the position in the local space. 16 | vsout.view = position; 17 | // Then we transform the position to the homogenous clip space. 18 | vec4 clip_space = view_projection * vec4(position + camera_position, 1.0); 19 | // We replace z with w since this makes sure that the depth will always be 1 after normalization. This means that the sky will always be farther than any other object in the scene. 20 | gl_Position = clip_space.xyww; 21 | } 22 | -------------------------------------------------------------------------------- /screenshots/.gitignore: -------------------------------------------------------------------------------- 1 | screenshot*.png -------------------------------------------------------------------------------- /source/common/data-types.h: -------------------------------------------------------------------------------- 1 | #ifndef OUR_DATA_TYPES_H 2 | #define OUR_DATA_TYPES_H 3 | 4 | #include 5 | 6 | namespace our { 7 | // Since we may want to store colors in bytes instead of floats for efficiency, 8 | // we are creating our own 32-bit R8G8B8A8 Color data type with the default GLM precision 9 | typedef glm::vec<4, glm::uint8, glm::defaultp> Color; 10 | } 11 | 12 | #endif //OUR_DATA_TYPES_H 13 | -------------------------------------------------------------------------------- /source/common/mesh/mesh-utils.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OUR_MESH_UTILS_H 2 | #define OUR_MESH_UTILS_H 3 | 4 | #include "mesh.hpp" 5 | 6 | #include 7 | 8 | namespace our::mesh_utils { 9 | 10 | // Load an ".obj" file into the mesh 11 | bool loadOBJ(Mesh& mesh, const char* filename); 12 | 13 | void Cuboid(Mesh& mesh, bool colored_faces = false, 14 | const glm::vec3& center = {0,0,0}, 15 | const glm::vec3& size = {1,1,1}, 16 | const glm::vec2& texture_offset = {0, 0}, 17 | const glm::vec2& texture_tiling = {1, 1}); 18 | 19 | void Sphere(Mesh& mesh, 20 | const glm::ivec2& segments = {32, 16}, 21 | bool colored = false, 22 | const glm::vec3& center = {0,0,0}, 23 | float radius = 0.5f, 24 | const glm::vec2& texture_offset = {0, 0}, 25 | const glm::vec2& texture_tiling = {1, 1}); 26 | 27 | void Plane(our::Mesh& mesh, 28 | const glm::ivec2& resolution = {1, 1}, 29 | bool colored = false, 30 | const glm::vec3& center={0, 0, 0}, 31 | const glm::vec2& size={1, 1}, 32 | const glm::vec2& texture_offset = {0, 0}, 33 | const glm::vec2& texture_tiling = {1, 1}); 34 | 35 | } 36 | 37 | #endif //OUR_MESH_UTILS_H 38 | -------------------------------------------------------------------------------- /source/common/mesh/vertex-attributes.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OUR_VERTEX_ATTRIBUTES_H 2 | #define OUR_VERTEX_ATTRIBUTES_H 3 | 4 | #include 5 | 6 | namespace our { 7 | 8 | // Just as convenience, we write which location "we" use for each attribute in our shader. 9 | // If you used different locations, modify these constants or just ignore (dont' use) them 10 | namespace default_attribute_locations { 11 | inline constexpr GLuint POSITION = 0; 12 | inline constexpr GLuint COLOR = 1; 13 | inline constexpr GLuint TEX_COORD = 2; 14 | inline constexpr GLuint NORMAL = 3; 15 | } 16 | 17 | // Also for convenience, we will specialize this function for every vertex struct we make to define how it should be sent to the attributes 18 | template 19 | void setup_buffer_accessors() { 20 | // Make sure this is specialized for every type it is called for 21 | static_assert(sizeof(T) != sizeof(T), "No accessors defined for this type"); 22 | }; 23 | } 24 | 25 | #endif //OUR_VERTEX_ATTRIBUTES_H 26 | -------------------------------------------------------------------------------- /source/common/texture/screenshot.h: -------------------------------------------------------------------------------- 1 | #ifndef GFX_LAB_SCREENSHOT_H 2 | #define GFX_LAB_SCREENSHOT_H 3 | 4 | #include 5 | 6 | namespace our { 7 | 8 | bool screenshot_png(const std::string& filename, bool include_alpha = false); 9 | 10 | } 11 | 12 | #endif //GFX_LAB_SCREENSHOT_H 13 | -------------------------------------------------------------------------------- /source/common/texture/texture-utils.h: -------------------------------------------------------------------------------- 1 | #ifndef OUR_TEXTURE_UTILS_H 2 | #define OUR_TEXTURE_UTILS_H 3 | 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | 11 | namespace our::texture_utils { 12 | 13 | // Load an image from a file 14 | glm::ivec2 loadImage(GLuint texture, const char* filename, bool generate_mipmap = true); 15 | // Load an image from a file but read it as a grayscale image 16 | glm::ivec2 loadImageGrayscale(GLuint texture, const char* filename, bool generate_mipmap = true); 17 | 18 | void singleColor(GLuint texture, Color color={255,255,255,255}, glm::ivec2 size={1,1}); 19 | 20 | void checkerBoard(GLuint texture, glm::ivec2 size, glm::ivec2 patternSize, our::Color color1, our::Color color2); 21 | 22 | } 23 | 24 | #endif //OUR_TEXTURE_UTILS_H 25 | -------------------------------------------------------------------------------- /source/examples/ex01_empty_window.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // This exercise Window Application that derives from "Application" parent 4 | class EmptyWindowApplication : public our::Application { 5 | 6 | // This overriden function sets the window configuration params struct (title, size, isFullscreen). 7 | our::WindowConfiguration getWindowConfiguration() override { 8 | return { "Empty Window", {1280, 720}, false }; 9 | } 10 | 11 | // onInitialize() function is called once before the application loop 12 | void onInitialize() override { 13 | 14 | //Specify the red, green, blue, and alpha values used when the color buffers are cleared. 15 | //Here the clear color is Magenta 16 | glClearColor(0.5f, 0.2f, 0.7f, 1.0f); 17 | } 18 | 19 | void onImmediateGui(ImGuiIO &io) override { 20 | // Shows a metric window just as an example of ImGui operations 21 | ImGui::ShowMetricsWindow(); 22 | } 23 | 24 | // onDraw(deltaTime) function is called every frame 25 | void onDraw(double deltaTime) override { 26 | //At the start of frame we want to clear the screen. Otherwise we would still see the results from the previous frame. 27 | glClear(GL_COLOR_BUFFER_BIT); 28 | } 29 | 30 | }; 31 | 32 | // Example Entry point 33 | int main(int argc, char** argv) { 34 | 35 | // Creates an instance of EmptyWindowApplication and call run on this instance 36 | return EmptyWindowApplication().run(); 37 | } 38 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/GenerateMappings.cmake: -------------------------------------------------------------------------------- 1 | # Usage: 2 | # cmake -P GenerateMappings.cmake 3 | 4 | set(source_url "https://raw.githubusercontent.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt") 5 | set(source_path "${CMAKE_CURRENT_BINARY_DIR}/gamecontrollerdb.txt") 6 | set(template_path "${CMAKE_ARGV3}") 7 | set(target_path "${CMAKE_ARGV4}") 8 | 9 | if (NOT EXISTS "${template_path}") 10 | message(FATAL_ERROR "Failed to find template file ${template_path}") 11 | endif() 12 | 13 | file(DOWNLOAD "${source_url}" "${source_path}" 14 | STATUS download_status 15 | TLS_VERIFY on) 16 | 17 | list(GET download_status 0 status_code) 18 | list(GET download_status 1 status_message) 19 | 20 | if (status_code) 21 | message(FATAL_ERROR "Failed to download ${source_url}: ${status_message}") 22 | endif() 23 | 24 | file(STRINGS "${source_path}" lines) 25 | foreach(line ${lines}) 26 | if ("${line}" MATCHES "^[0-9a-fA-F].*$") 27 | set(GLFW_GAMEPAD_MAPPINGS "${GLFW_GAMEPAD_MAPPINGS}\"${line}\",\n") 28 | endif() 29 | endforeach() 30 | 31 | configure_file("${template_path}" "${target_path}" @ONLY NEWLINE_STYLE UNIX) 32 | file(REMOVE "${source_path}") 33 | 34 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/MacOSXBundleInfo.plist.in: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleExecutable 8 | ${MACOSX_BUNDLE_EXECUTABLE_NAME} 9 | CFBundleGetInfoString 10 | ${MACOSX_BUNDLE_INFO_STRING} 11 | CFBundleIconFile 12 | ${MACOSX_BUNDLE_ICON_FILE} 13 | CFBundleIdentifier 14 | ${MACOSX_BUNDLE_GUI_IDENTIFIER} 15 | CFBundleInfoDictionaryVersion 16 | 6.0 17 | CFBundleLongVersionString 18 | ${MACOSX_BUNDLE_LONG_VERSION_STRING} 19 | CFBundleName 20 | ${MACOSX_BUNDLE_BUNDLE_NAME} 21 | CFBundlePackageType 22 | APPL 23 | CFBundleShortVersionString 24 | ${MACOSX_BUNDLE_SHORT_VERSION_STRING} 25 | CFBundleSignature 26 | ???? 27 | CFBundleVersion 28 | ${MACOSX_BUNDLE_BUNDLE_VERSION} 29 | CSResourcesFileMapped 30 | 31 | LSRequiresCarbon 32 | 33 | NSHumanReadableCopyright 34 | ${MACOSX_BUNDLE_COPYRIGHT} 35 | NSHighResolutionCapable 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/i686-w64-mingw32-clang.cmake: -------------------------------------------------------------------------------- 1 | # Define the environment for cross-compiling with 32-bit MinGW-w64 Clang 2 | SET(CMAKE_SYSTEM_NAME Windows) # Target system name 3 | SET(CMAKE_SYSTEM_VERSION 1) 4 | SET(CMAKE_C_COMPILER "i686-w64-mingw32-clang") 5 | SET(CMAKE_CXX_COMPILER "i686-w64-mingw32-clang++") 6 | SET(CMAKE_RC_COMPILER "i686-w64-mingw32-windres") 7 | SET(CMAKE_RANLIB "i686-w64-mingw32-ranlib") 8 | 9 | # Configure the behaviour of the find commands 10 | SET(CMAKE_FIND_ROOT_PATH "/usr/i686-w64-mingw32") 11 | SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) 12 | SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) 13 | SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) 14 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/i686-w64-mingw32.cmake: -------------------------------------------------------------------------------- 1 | # Define the environment for cross-compiling with 32-bit MinGW-w64 GCC 2 | SET(CMAKE_SYSTEM_NAME Windows) # Target system name 3 | SET(CMAKE_SYSTEM_VERSION 1) 4 | SET(CMAKE_C_COMPILER "i686-w64-mingw32-gcc") 5 | SET(CMAKE_CXX_COMPILER "i686-w64-mingw32-g++") 6 | SET(CMAKE_RC_COMPILER "i686-w64-mingw32-windres") 7 | SET(CMAKE_RANLIB "i686-w64-mingw32-ranlib") 8 | 9 | # Configure the behaviour of the find commands 10 | SET(CMAKE_FIND_ROOT_PATH "/usr/i686-w64-mingw32") 11 | SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) 12 | SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) 13 | SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) 14 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/modules/FindEpollShim.cmake: -------------------------------------------------------------------------------- 1 | # Find EpollShim 2 | # Once done, this will define 3 | # 4 | # EPOLLSHIM_FOUND - System has EpollShim 5 | # EPOLLSHIM_INCLUDE_DIRS - The EpollShim include directories 6 | # EPOLLSHIM_LIBRARIES - The libraries needed to use EpollShim 7 | 8 | find_path(EPOLLSHIM_INCLUDE_DIRS NAMES sys/epoll.h sys/timerfd.h HINTS /usr/local/include/libepoll-shim) 9 | find_library(EPOLLSHIM_LIBRARIES NAMES epoll-shim libepoll-shim HINTS /usr/local/lib) 10 | 11 | if (EPOLLSHIM_INCLUDE_DIRS AND EPOLLSHIM_LIBRARIES) 12 | set(EPOLLSHIM_FOUND TRUE) 13 | endif (EPOLLSHIM_INCLUDE_DIRS AND EPOLLSHIM_LIBRARIES) 14 | 15 | include(FindPackageHandleStandardArgs) 16 | find_package_handle_standard_args(EPOLLSHIM DEFAULT_MSG EPOLLSHIM_LIBRARIES EPOLLSHIM_INCLUDE_DIRS) 17 | mark_as_advanced(EPOLLSHIM_INCLUDE_DIRS EPOLLSHIM_LIBRARIES) 18 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/modules/FindOSMesa.cmake: -------------------------------------------------------------------------------- 1 | # Try to find OSMesa on a Unix system 2 | # 3 | # This will define: 4 | # 5 | # OSMESA_LIBRARIES - Link these to use OSMesa 6 | # OSMESA_INCLUDE_DIR - Include directory for OSMesa 7 | # 8 | # Copyright (c) 2014 Brandon Schaefer 9 | 10 | if (NOT WIN32) 11 | 12 | find_package (PkgConfig) 13 | pkg_check_modules (PKG_OSMESA QUIET osmesa) 14 | 15 | set (OSMESA_INCLUDE_DIR ${PKG_OSMESA_INCLUDE_DIRS}) 16 | set (OSMESA_LIBRARIES ${PKG_OSMESA_LIBRARIES}) 17 | 18 | endif () 19 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/modules/FindWaylandProtocols.cmake: -------------------------------------------------------------------------------- 1 | find_package(PkgConfig) 2 | 3 | pkg_check_modules(WaylandProtocols QUIET wayland-protocols>=${WaylandProtocols_FIND_VERSION}) 4 | 5 | execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=pkgdatadir wayland-protocols 6 | OUTPUT_VARIABLE WaylandProtocols_PKGDATADIR 7 | RESULT_VARIABLE _pkgconfig_failed) 8 | if (_pkgconfig_failed) 9 | message(FATAL_ERROR "Missing wayland-protocols pkgdatadir") 10 | endif() 11 | 12 | string(REGEX REPLACE "[\r\n]" "" WaylandProtocols_PKGDATADIR "${WaylandProtocols_PKGDATADIR}") 13 | 14 | find_package_handle_standard_args(WaylandProtocols 15 | FOUND_VAR 16 | WaylandProtocols_FOUND 17 | REQUIRED_VARS 18 | WaylandProtocols_PKGDATADIR 19 | VERSION_VAR 20 | WaylandProtocols_VERSION 21 | HANDLE_COMPONENTS 22 | ) 23 | 24 | set(WAYLAND_PROTOCOLS_FOUND ${WaylandProtocols_FOUND}) 25 | set(WAYLAND_PROTOCOLS_PKGDATADIR ${WaylandProtocols_PKGDATADIR}) 26 | set(WAYLAND_PROTOCOLS_VERSION ${WaylandProtocols_VERSION}) 27 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/modules/FindXKBCommon.cmake: -------------------------------------------------------------------------------- 1 | # - Try to find XKBCommon 2 | # Once done, this will define 3 | # 4 | # XKBCOMMON_FOUND - System has XKBCommon 5 | # XKBCOMMON_INCLUDE_DIRS - The XKBCommon include directories 6 | # XKBCOMMON_LIBRARIES - The libraries needed to use XKBCommon 7 | # XKBCOMMON_DEFINITIONS - Compiler switches required for using XKBCommon 8 | 9 | find_package(PkgConfig) 10 | pkg_check_modules(PC_XKBCOMMON QUIET xkbcommon) 11 | set(XKBCOMMON_DEFINITIONS ${PC_XKBCOMMON_CFLAGS_OTHER}) 12 | 13 | find_path(XKBCOMMON_INCLUDE_DIR 14 | NAMES xkbcommon/xkbcommon.h 15 | HINTS ${PC_XKBCOMMON_INCLUDE_DIR} ${PC_XKBCOMMON_INCLUDE_DIRS} 16 | ) 17 | 18 | find_library(XKBCOMMON_LIBRARY 19 | NAMES xkbcommon 20 | HINTS ${PC_XKBCOMMON_LIBRARY} ${PC_XKBCOMMON_LIBRARY_DIRS} 21 | ) 22 | 23 | set(XKBCOMMON_LIBRARIES ${XKBCOMMON_LIBRARY}) 24 | set(XKBCOMMON_LIBRARY_DIRS ${XKBCOMMON_LIBRARY_DIRS}) 25 | set(XKBCOMMON_INCLUDE_DIRS ${XKBCOMMON_INCLUDE_DIR}) 26 | 27 | include(FindPackageHandleStandardArgs) 28 | find_package_handle_standard_args(XKBCommon DEFAULT_MSG 29 | XKBCOMMON_LIBRARY 30 | XKBCOMMON_INCLUDE_DIR 31 | ) 32 | 33 | mark_as_advanced(XKBCOMMON_LIBRARY XKBCOMMON_INCLUDE_DIR) 34 | 35 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/x86_64-w64-mingw32-clang.cmake: -------------------------------------------------------------------------------- 1 | # Define the environment for cross-compiling with 64-bit MinGW-w64 Clang 2 | SET(CMAKE_SYSTEM_NAME Windows) # Target system name 3 | SET(CMAKE_SYSTEM_VERSION 1) 4 | SET(CMAKE_C_COMPILER "x86_64-w64-mingw32-clang") 5 | SET(CMAKE_CXX_COMPILER "x86_64-w64-mingw32-clang++") 6 | SET(CMAKE_RC_COMPILER "x86_64-w64-mingw32-windres") 7 | SET(CMAKE_RANLIB "x86_64-w64-mingw32-ranlib") 8 | 9 | # Configure the behaviour of the find commands 10 | SET(CMAKE_FIND_ROOT_PATH "/usr/x86_64-w64-mingw32") 11 | SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) 12 | SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) 13 | SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) 14 | -------------------------------------------------------------------------------- /vendor/glfw/CMake/x86_64-w64-mingw32.cmake: -------------------------------------------------------------------------------- 1 | # Define the environment for cross-compiling with 64-bit MinGW-w64 GCC 2 | SET(CMAKE_SYSTEM_NAME Windows) # Target system name 3 | SET(CMAKE_SYSTEM_VERSION 1) 4 | SET(CMAKE_C_COMPILER "x86_64-w64-mingw32-gcc") 5 | SET(CMAKE_CXX_COMPILER "x86_64-w64-mingw32-g++") 6 | SET(CMAKE_RC_COMPILER "x86_64-w64-mingw32-windres") 7 | SET(CMAKE_RANLIB "x86_64-w64-mingw32-ranlib") 8 | 9 | # Configure the behaviour of the find commands 10 | SET(CMAKE_FIND_ROOT_PATH "/usr/x86_64-w64-mingw32") 11 | SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) 12 | SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) 13 | SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) 14 | -------------------------------------------------------------------------------- /vendor/glfw/LICENSE.md: -------------------------------------------------------------------------------- 1 | Copyright (c) 2002-2006 Marcus Geelnard 2 | 3 | Copyright (c) 2006-2019 Camilla Löwy 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would 16 | be appreciated but is not required. 17 | 18 | 2. Altered source versions must be plainly marked as such, and must not 19 | be misrepresented as being the original software. 20 | 21 | 3. This notice may not be removed or altered from any source 22 | distribution. 23 | 24 | -------------------------------------------------------------------------------- /vendor/glfw/cmake_uninstall.cmake.in: -------------------------------------------------------------------------------- 1 | 2 | if (NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") 3 | message(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"") 4 | endif() 5 | 6 | file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) 7 | string(REGEX REPLACE "\n" ";" files "${files}") 8 | 9 | foreach (file ${files}) 10 | message(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"") 11 | if (EXISTS "$ENV{DESTDIR}${file}") 12 | exec_program("@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" 13 | OUTPUT_VARIABLE rm_out 14 | RETURN_VALUE rm_retval) 15 | if (NOT "${rm_retval}" STREQUAL 0) 16 | MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"") 17 | endif() 18 | elseif (IS_SYMLINK "$ENV{DESTDIR}${file}") 19 | EXEC_PROGRAM("@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" 20 | OUTPUT_VARIABLE rm_out 21 | RETURN_VALUE rm_retval) 22 | if (NOT "${rm_retval}" STREQUAL 0) 23 | message(FATAL_ERROR "Problem when removing symlink \"$ENV{DESTDIR}${file}\"") 24 | endif() 25 | else() 26 | message(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.") 27 | endif() 28 | endforeach() 29 | 30 | -------------------------------------------------------------------------------- /vendor/glfw/src/glfw3.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | exec_prefix=${prefix} 3 | includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ 4 | libdir=@CMAKE_INSTALL_FULL_LIBDIR@ 5 | 6 | Name: GLFW 7 | Description: A multi-platform library for OpenGL, window and input 8 | Version: @GLFW_VERSION@ 9 | URL: https://www.glfw.org/ 10 | Requires.private: @GLFW_PKG_DEPS@ 11 | Libs: -L${libdir} -l@GLFW_LIB_NAME@ 12 | Libs.private: @GLFW_PKG_LIBS@ 13 | Cflags: -I${includedir} 14 | -------------------------------------------------------------------------------- /vendor/glfw/src/glfw3Config.cmake.in: -------------------------------------------------------------------------------- 1 | include("${CMAKE_CURRENT_LIST_DIR}/glfw3Targets.cmake") 2 | -------------------------------------------------------------------------------- /vendor/glfw/src/null_joystick.h: -------------------------------------------------------------------------------- 1 | //======================================================================== 2 | // GLFW 3.3 - www.glfw.org 3 | //------------------------------------------------------------------------ 4 | // Copyright (c) 2006-2017 Camilla Löwy 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 | #define _GLFW_PLATFORM_JOYSTICK_STATE struct { int dummyJoystick; } 28 | #define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE struct { int dummyLibraryJoystick; } 29 | 30 | #define _GLFW_PLATFORM_MAPPING_NAME "" 31 | 32 | -------------------------------------------------------------------------------- /vendor/glfw/src/xkb_unicode.h: -------------------------------------------------------------------------------- 1 | //======================================================================== 2 | // GLFW 3.3 Linux - www.glfw.org 3 | //------------------------------------------------------------------------ 4 | // Copyright (c) 2014 Jonas Ådahl 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 | long _glfwKeySym2Unicode(unsigned int keysym); 28 | 29 | -------------------------------------------------------------------------------- /vendor/glm/glm/detail/_fixes.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //! Workaround for compatibility with other libraries 4 | #ifdef max 5 | #undef max 6 | #endif 7 | 8 | //! Workaround for compatibility with other libraries 9 | #ifdef min 10 | #undef min 11 | #endif 12 | 13 | //! Workaround for Android 14 | #ifdef isnan 15 | #undef isnan 16 | #endif 17 | 18 | //! Workaround for Android 19 | #ifdef isinf 20 | #undef isinf 21 | #endif 22 | 23 | //! Workaround for Chrone Native Client 24 | #ifdef log2 25 | #undef log2 26 | #endif 27 | 28 | -------------------------------------------------------------------------------- /vendor/glm/glm/detail/compute_common.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "setup.hpp" 4 | #include 5 | 6 | namespace glm{ 7 | namespace detail 8 | { 9 | template 10 | struct compute_abs 11 | {}; 12 | 13 | template 14 | struct compute_abs 15 | { 16 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x) 17 | { 18 | GLM_STATIC_ASSERT( 19 | std::numeric_limits::is_iec559 || std::numeric_limits::is_signed, 20 | "'abs' only accept floating-point and integer scalar or vector inputs"); 21 | 22 | return x >= genFIType(0) ? x : -x; 23 | // TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff; 24 | } 25 | }; 26 | 27 | #if GLM_COMPILER & GLM_COMPILER_CUDA 28 | template<> 29 | struct compute_abs 30 | { 31 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static float call(float x) 32 | { 33 | return fabsf(x); 34 | } 35 | }; 36 | #endif 37 | 38 | template 39 | struct compute_abs 40 | { 41 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x) 42 | { 43 | GLM_STATIC_ASSERT( 44 | (!std::numeric_limits::is_signed && std::numeric_limits::is_integer), 45 | "'abs' only accept floating-point and integer scalar or vector inputs"); 46 | return x; 47 | } 48 | }; 49 | }//namespace detail 50 | }//namespace glm 51 | -------------------------------------------------------------------------------- /vendor/glm/glm/detail/compute_vector_relational.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "compute_common.hpp" 4 | #include "setup.hpp" 5 | #include 6 | 7 | namespace glm{ 8 | namespace detail 9 | { 10 | template 11 | struct compute_equal 12 | { 13 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) 14 | { 15 | return a == b; 16 | } 17 | }; 18 | /* 19 | template 20 | struct compute_equal 21 | { 22 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) 23 | { 24 | return detail::compute_abs::is_signed>::call(b - a) <= static_cast(0); 25 | //return std::memcmp(&a, &b, sizeof(T)) == 0; 26 | } 27 | }; 28 | */ 29 | }//namespace detail 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /vendor/glm/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, Q, true> 13 | { 14 | GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) 15 | { 16 | vec<4, float, Q> Result; 17 | Result.data = _mm_sqrt_ps(v.data); 18 | return Result; 19 | } 20 | }; 21 | 22 | # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE 23 | template<> 24 | struct compute_sqrt<4, float, aligned_lowp, true> 25 | { 26 | GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v) 27 | { 28 | vec<4, float, aligned_lowp> Result; 29 | Result.data = glm_vec4_sqrt_lowp(v.data); 30 | return Result; 31 | } 32 | }; 33 | # endif 34 | }//namespace detail 35 | }//namespace glm 36 | 37 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 38 | -------------------------------------------------------------------------------- /vendor/glm/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /vendor/glm/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/vendor/glm/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /vendor/glm/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /vendor/glm/glm/detail/type_half.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "setup.hpp" 4 | 5 | namespace glm{ 6 | namespace detail 7 | { 8 | typedef short hdata; 9 | 10 | GLM_FUNC_DECL float toFloat32(hdata value); 11 | GLM_FUNC_DECL hdata toFloat16(float const& value); 12 | 13 | }//namespace detail 14 | }//namespace glm 15 | 16 | #include "type_half.inl" 17 | -------------------------------------------------------------------------------- /vendor/glm/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_common.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_common 2 | /// @file glm/ext/matrix_common.hpp 3 | /// 4 | /// @defgroup ext_matrix_common GLM_EXT_matrix_common 5 | /// @ingroup ext 6 | /// 7 | /// Defines functions for common matrix operations. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_matrix_common 12 | 13 | #pragma once 14 | 15 | #include "../detail/qualifier.hpp" 16 | #include "../detail/_fixes.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_transform extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_common 25 | /// @{ 26 | 27 | template 28 | GLM_FUNC_DECL mat mix(mat const& x, mat const& y, mat const& a); 29 | 30 | template 31 | GLM_FUNC_DECL mat mix(mat const& x, mat const& y, U a); 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "matrix_common.inl" 37 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_common.inl: -------------------------------------------------------------------------------- 1 | #include "../matrix.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, U a) 7 | { 8 | return mat(x) * (static_cast(1) - a) + mat(y) * a; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, mat const& a) 13 | { 14 | return matrixCompMult(mat(x), static_cast(1) - a) + matrixCompMult(mat(y), a); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_double2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 2, double, defaultp> dmat2x2; 16 | 17 | /// 2 columns of 2 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<2, 2, double, defaultp> dmat2; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_double2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 3, double, defaultp> dmat2x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_double2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 4, double, defaultp> dmat2x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_double3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 2, double, defaultp> dmat3x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_double3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 3, double, defaultp> dmat3x3; 16 | 17 | /// 3 columns of 3 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<3, 3, double, defaultp> dmat3; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_double3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 4, double, defaultp> dmat3x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_double4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 2, double, defaultp> dmat4x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_double4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 3, double, defaultp> dmat4x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_double4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 4, double, defaultp> dmat4x4; 16 | 17 | /// 4 columns of 4 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<4, 4, double, defaultp> dmat4; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_float2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 2, float, defaultp> mat2x2; 16 | 17 | /// 2 columns of 2 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<2, 2, float, defaultp> mat2; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_float2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 3, float, defaultp> mat2x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_float2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 4, float, defaultp> mat2x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_float3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core 10 | /// @{ 11 | 12 | /// 3 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 2, float, defaultp> mat3x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_float3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 3, float, defaultp> mat3x3; 16 | 17 | /// 3 columns of 3 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<3, 3, float, defaultp> mat3; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_float3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 4, float, defaultp> mat3x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_float4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 2, float, defaultp> mat4x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_float4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 3, float, defaultp> mat4x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_float4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @ingroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 4, float, defaultp> mat4x4; 16 | 17 | /// 4 columns of 4 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<4, 4, float, defaultp> mat4; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x2 2 | /// @file glm/ext/matrix_int2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x2 GLM_EXT_matrix_int2x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x2 25 | /// @{ 26 | 27 | /// Signed integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_int2x2 30 | typedef mat<2, 2, int, defaultp> imat2x2; 31 | 32 | /// Signed integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_int2x2 35 | typedef mat<2, 2, int, defaultp> imat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x3 2 | /// @file glm/ext/matrix_int2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_int2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x3 25 | /// @{ 26 | 27 | /// Signed integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_int2x3 30 | typedef mat<2, 3, int, defaultp> imat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int2x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x3_sized 2 | /// @file glm/ext/matrix_int2x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3_sized GLM_EXT_matrix_int2x3_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int2x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int2x3_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 2x3 matrix. 29 | /// 30 | /// @see ext_matrix_int2x3_sized 31 | typedef mat<2, 3, int8, defaultp> i8mat2x3; 32 | 33 | /// 16 bit signed integer 2x3 matrix. 34 | /// 35 | /// @see ext_matrix_int2x3_sized 36 | typedef mat<2, 3, int16, defaultp> i16mat2x3; 37 | 38 | /// 32 bit signed integer 2x3 matrix. 39 | /// 40 | /// @see ext_matrix_int2x3_sized 41 | typedef mat<2, 3, int32, defaultp> i32mat2x3; 42 | 43 | /// 64 bit signed integer 2x3 matrix. 44 | /// 45 | /// @see ext_matrix_int2x3_sized 46 | typedef mat<2, 3, int64, defaultp> i64mat2x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x4 2 | /// @file glm/ext/matrix_int2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x4 25 | /// @{ 26 | 27 | /// Signed integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_int2x4 30 | typedef mat<2, 4, int, defaultp> imat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int2x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x4_sized 2 | /// @file glm/ext/matrix_int2x4_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x4_sized GLM_EXT_matrix_int2x4_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int2x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int2x4_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 2x4 matrix. 29 | /// 30 | /// @see ext_matrix_int2x4_sized 31 | typedef mat<2, 4, int8, defaultp> i8mat2x4; 32 | 33 | /// 16 bit signed integer 2x4 matrix. 34 | /// 35 | /// @see ext_matrix_int2x4_sized 36 | typedef mat<2, 4, int16, defaultp> i16mat2x4; 37 | 38 | /// 32 bit signed integer 2x4 matrix. 39 | /// 40 | /// @see ext_matrix_int2x4_sized 41 | typedef mat<2, 4, int32, defaultp> i32mat2x4; 42 | 43 | /// 64 bit signed integer 2x4 matrix. 44 | /// 45 | /// @see ext_matrix_int2x4_sized 46 | typedef mat<2, 4, int64, defaultp> i64mat2x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x2 2 | /// @file glm/ext/matrix_int3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_int3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x2 25 | /// @{ 26 | 27 | /// Signed integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_int3x2 30 | typedef mat<3, 2, int, defaultp> imat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int3x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x2_sized 2 | /// @file glm/ext/matrix_int3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2_sized GLM_EXT_matrix_int3x2_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int3x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int3x2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 3x2 matrix. 29 | /// 30 | /// @see ext_matrix_int3x2_sized 31 | typedef mat<3, 2, int8, defaultp> i8mat3x2; 32 | 33 | /// 16 bit signed integer 3x2 matrix. 34 | /// 35 | /// @see ext_matrix_int3x2_sized 36 | typedef mat<3, 2, int16, defaultp> i16mat3x2; 37 | 38 | /// 32 bit signed integer 3x2 matrix. 39 | /// 40 | /// @see ext_matrix_int3x2_sized 41 | typedef mat<3, 2, int32, defaultp> i32mat3x2; 42 | 43 | /// 64 bit signed integer 3x2 matrix. 44 | /// 45 | /// @see ext_matrix_int3x2_sized 46 | typedef mat<3, 2, int64, defaultp> i64mat3x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x3 2 | /// @file glm/ext/matrix_int3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x3 GLM_EXT_matrix_int3x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x3 25 | /// @{ 26 | 27 | /// Signed integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_int3x3 30 | typedef mat<3, 3, int, defaultp> imat3x3; 31 | 32 | /// Signed integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_int3x3 35 | typedef mat<3, 3, int, defaultp> imat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x4 2 | /// @file glm/ext/matrix_int3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x4 GLM_EXT_matrix_int3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_int3x4 30 | typedef mat<3, 4, int, defaultp> imat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int3x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x4_sized 2 | /// @file glm/ext/matrix_int3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x4_sized GLM_EXT_matrix_int3x4_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int3x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int3x4_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 3x4 matrix. 29 | /// 30 | /// @see ext_matrix_int3x4_sized 31 | typedef mat<3, 4, int8, defaultp> i8mat3x4; 32 | 33 | /// 16 bit signed integer 3x4 matrix. 34 | /// 35 | /// @see ext_matrix_int3x4_sized 36 | typedef mat<3, 4, int16, defaultp> i16mat3x4; 37 | 38 | /// 32 bit signed integer 3x4 matrix. 39 | /// 40 | /// @see ext_matrix_int3x4_sized 41 | typedef mat<3, 4, int32, defaultp> i32mat3x4; 42 | 43 | /// 64 bit signed integer 3x4 matrix. 44 | /// 45 | /// @see ext_matrix_int3x4_sized 46 | typedef mat<3, 4, int64, defaultp> i64mat3x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x2 2 | /// @file glm/ext/matrix_int4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x2 GLM_EXT_matrix_int4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x2 25 | /// @{ 26 | 27 | /// Signed integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_int4x2 30 | typedef mat<4, 2, int, defaultp> imat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int4x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x2_sized 2 | /// @file glm/ext/matrix_int4x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x2_sized GLM_EXT_matrix_int4x2_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int4x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int4x2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 4x2 matrix. 29 | /// 30 | /// @see ext_matrix_int4x2_sized 31 | typedef mat<4, 2, int8, defaultp> i8mat4x2; 32 | 33 | /// 16 bit signed integer 4x2 matrix. 34 | /// 35 | /// @see ext_matrix_int4x2_sized 36 | typedef mat<4, 2, int16, defaultp> i16mat4x2; 37 | 38 | /// 32 bit signed integer 4x2 matrix. 39 | /// 40 | /// @see ext_matrix_int4x2_sized 41 | typedef mat<4, 2, int32, defaultp> i32mat4x2; 42 | 43 | /// 64 bit signed integer 4x2 matrix. 44 | /// 45 | /// @see ext_matrix_int4x2_sized 46 | typedef mat<4, 2, int64, defaultp> i64mat4x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x3 2 | /// @file glm/ext/matrix_int4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x3 GLM_EXT_matrix_int4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x3 25 | /// @{ 26 | 27 | /// Signed integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_int4x3 30 | typedef mat<4, 3, int, defaultp> imat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int4x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x3_sized 2 | /// @file glm/ext/matrix_int4x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x3_sized GLM_EXT_matrix_int4x3_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int4x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int4x3_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 4x3 matrix. 29 | /// 30 | /// @see ext_matrix_int4x3_sized 31 | typedef mat<4, 3, int8, defaultp> i8mat4x3; 32 | 33 | /// 16 bit signed integer 4x3 matrix. 34 | /// 35 | /// @see ext_matrix_int4x3_sized 36 | typedef mat<4, 3, int16, defaultp> i16mat4x3; 37 | 38 | /// 32 bit signed integer 4x3 matrix. 39 | /// 40 | /// @see ext_matrix_int4x3_sized 41 | typedef mat<4, 3, int32, defaultp> i32mat4x3; 42 | 43 | /// 64 bit signed integer 4x3 matrix. 44 | /// 45 | /// @see ext_matrix_int4x3_sized 46 | typedef mat<4, 3, int64, defaultp> i64mat4x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_int4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x4 2 | /// @file glm/ext/matrix_int4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x4 GLM_EXT_matrix_int4x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x4 25 | /// @{ 26 | 27 | /// Signed integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_int4x4 30 | typedef mat<4, 4, int, defaultp> imat4x4; 31 | 32 | /// Signed integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_int4x4 35 | typedef mat<4, 4, int, defaultp> imat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x2 2 | /// @file glm/ext/matrix_uint2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x2 GLM_EXT_matrix_uint2x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x2 25 | /// @{ 26 | 27 | /// Unsigned integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x2 30 | typedef mat<2, 2, uint, defaultp> umat2x2; 31 | 32 | /// Unsigned integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_uint2x2 35 | typedef mat<2, 2, uint, defaultp> umat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x3 2 | /// @file glm/ext/matrix_uint2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_uint2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x3 25 | /// @{ 26 | 27 | /// Unsigned integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x3 30 | typedef mat<2, 3, uint, defaultp> umat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint2x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x3_sized 2 | /// @file glm/ext/matrix_uint2x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x3_sized GLM_EXT_matrix_uint2x3_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint2x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint2x3_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 2x3 matrix. 29 | /// 30 | /// @see ext_matrix_uint2x3_sized 31 | typedef mat<2, 3, uint8, defaultp> u8mat2x3; 32 | 33 | /// 16 bit unsigned integer 2x3 matrix. 34 | /// 35 | /// @see ext_matrix_uint2x3_sized 36 | typedef mat<2, 3, uint16, defaultp> u16mat2x3; 37 | 38 | /// 32 bit unsigned integer 2x3 matrix. 39 | /// 40 | /// @see ext_matrix_uint2x3_sized 41 | typedef mat<2, 3, uint32, defaultp> u32mat2x3; 42 | 43 | /// 64 bit unsigned integer 2x3 matrix. 44 | /// 45 | /// @see ext_matrix_uint2x3_sized 46 | typedef mat<2, 3, uint64, defaultp> u64mat2x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x4 2 | /// @file glm/ext/matrix_uint2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x4 25 | /// @{ 26 | 27 | /// Unsigned integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x4 30 | typedef mat<2, 4, uint, defaultp> umat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint2x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x4_sized 2 | /// @file glm/ext/matrixu_uint2x4_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x4_sized GLM_EXT_matrix_uint2x4_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint2x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint2x4_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 2x4 matrix. 29 | /// 30 | /// @see ext_matrix_uint2x4_sized 31 | typedef mat<2, 4, uint8, defaultp> u8mat2x4; 32 | 33 | /// 16 bit unsigned integer 2x4 matrix. 34 | /// 35 | /// @see ext_matrix_uint2x4_sized 36 | typedef mat<2, 4, uint16, defaultp> u16mat2x4; 37 | 38 | /// 32 bit unsigned integer 2x4 matrix. 39 | /// 40 | /// @see ext_matrix_uint2x4_sized 41 | typedef mat<2, 4, uint32, defaultp> u32mat2x4; 42 | 43 | /// 64 bit unsigned integer 2x4 matrix. 44 | /// 45 | /// @see ext_matrix_uint2x4_sized 46 | typedef mat<2, 4, uint64, defaultp> u64mat2x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x2 2 | /// @file glm/ext/matrix_uint3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_uint3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x2 25 | /// @{ 26 | 27 | /// Unsigned integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x2 30 | typedef mat<3, 2, uint, defaultp> umat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint3x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x2_sized 2 | /// @file glm/ext/matrix_uint3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x2_sized GLM_EXT_matrix_uint3x2_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint3x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint3x2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 3x2 matrix. 29 | /// 30 | /// @see ext_matrix_uint3x2_sized 31 | typedef mat<3, 2, uint8, defaultp> u8mat3x2; 32 | 33 | /// 16 bit signed integer 3x2 matrix. 34 | /// 35 | /// @see ext_matrix_uint3x2_sized 36 | typedef mat<3, 2, uint16, defaultp> u16mat3x2; 37 | 38 | /// 32 bit signed integer 3x2 matrix. 39 | /// 40 | /// @see ext_matrix_uint3x2_sized 41 | typedef mat<3, 2, uint32, defaultp> u32mat3x2; 42 | 43 | /// 64 bit signed integer 3x2 matrix. 44 | /// 45 | /// @see ext_matrix_uint3x2_sized 46 | typedef mat<3, 2, uint64, defaultp> u64mat3x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x3 2 | /// @file glm/ext/matrix_uint3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x3 GLM_EXT_matrix_uint3x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x3 25 | /// @{ 26 | 27 | /// Unsigned integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x3 30 | typedef mat<3, 3, uint, defaultp> umat3x3; 31 | 32 | /// Unsigned integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_uint3x3 35 | typedef mat<3, 3, uint, defaultp> umat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x4 2 | /// @file glm/ext/matrix_uint3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x4 GLM_EXT_matrix_uint3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x4 30 | typedef mat<3, 4, uint, defaultp> umat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint3x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x4_sized 2 | /// @file glm/ext/matrix_uint3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x4_sized GLM_EXT_matrix_uint3x4_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint3x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint3x4_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 3x4 matrix. 29 | /// 30 | /// @see ext_matrix_uint3x4_sized 31 | typedef mat<3, 4, uint8, defaultp> u8mat3x4; 32 | 33 | /// 16 bit unsigned integer 3x4 matrix. 34 | /// 35 | /// @see ext_matrix_uint3x4_sized 36 | typedef mat<3, 4, uint16, defaultp> u16mat3x4; 37 | 38 | /// 32 bit unsigned integer 3x4 matrix. 39 | /// 40 | /// @see ext_matrix_uint3x4_sized 41 | typedef mat<3, 4, uint32, defaultp> u32mat3x4; 42 | 43 | /// 64 bit unsigned integer 3x4 matrix. 44 | /// 45 | /// @see ext_matrix_uint3x4_sized 46 | typedef mat<3, 4, uint64, defaultp> u64mat3x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x2 2 | /// @file glm/ext/matrix_uint4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x2 GLM_EXT_matrix_uint4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x2 25 | /// @{ 26 | 27 | /// Unsigned integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x2 30 | typedef mat<4, 2, uint, defaultp> umat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint4x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x2_sized 2 | /// @file glm/ext/matrix_uint4x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x2_sized GLM_EXT_matrix_uint4x2_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint4x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint4x2_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 4x2 matrix. 29 | /// 30 | /// @see ext_matrix_uint4x2_sized 31 | typedef mat<4, 2, uint8, defaultp> u8mat4x2; 32 | 33 | /// 16 bit unsigned integer 4x2 matrix. 34 | /// 35 | /// @see ext_matrix_uint4x2_sized 36 | typedef mat<4, 2, uint16, defaultp> u16mat4x2; 37 | 38 | /// 32 bit unsigned integer 4x2 matrix. 39 | /// 40 | /// @see ext_matrix_uint4x2_sized 41 | typedef mat<4, 2, uint32, defaultp> u32mat4x2; 42 | 43 | /// 64 bit unsigned integer 4x2 matrix. 44 | /// 45 | /// @see ext_matrix_uint4x2_sized 46 | typedef mat<4, 2, uint64, defaultp> u64mat4x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x3 2 | /// @file glm/ext/matrix_uint4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x3 GLM_EXT_matrix_uint4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x3 25 | /// @{ 26 | 27 | /// Unsigned integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x3 30 | typedef mat<4, 3, uint, defaultp> umat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint4x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x3_sized 2 | /// @file glm/ext/matrix_uint4x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x3_sized GLM_EXT_matrix_uint4x3_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint4x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint4x3_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 4x3 matrix. 29 | /// 30 | /// @see ext_matrix_uint4x3_sized 31 | typedef mat<4, 3, uint8, defaultp> u8mat4x3; 32 | 33 | /// 16 bit unsigned integer 4x3 matrix. 34 | /// 35 | /// @see ext_matrix_uint4x3_sized 36 | typedef mat<4, 3, uint16, defaultp> u16mat4x3; 37 | 38 | /// 32 bit unsigned integer 4x3 matrix. 39 | /// 40 | /// @see ext_matrix_uint4x3_sized 41 | typedef mat<4, 3, uint32, defaultp> u32mat4x3; 42 | 43 | /// 64 bit unsigned integer 4x3 matrix. 44 | /// 45 | /// @see ext_matrix_uint4x3_sized 46 | typedef mat<4, 3, uint64, defaultp> u64mat4x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/matrix_uint4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x4 2 | /// @file glm/ext/matrix_uint4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x4 GLM_EXT_matrix_uint4x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x4 25 | /// @{ 26 | 27 | /// Unsigned integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x4 30 | typedef mat<4, 4, uint, defaultp> umat4x4; 31 | 32 | /// Unsigned integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_uint4x4 35 | typedef mat<4, 4, uint, defaultp> umat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/quaternion_common_simd.inl: -------------------------------------------------------------------------------- 1 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 2 | 3 | namespace glm{ 4 | namespace detail 5 | { 6 | template 7 | struct compute_dot, float, true> 8 | { 9 | static GLM_FUNC_QUALIFIER float call(qua const& x, qua const& y) 10 | { 11 | return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); 12 | } 13 | }; 14 | }//namespace detail 15 | }//namespace glm 16 | 17 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 18 | 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/quaternion_double.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_quaternion_double 2 | /// @file glm/ext/quaternion_double.hpp 3 | /// 4 | /// @defgroup ext_quaternion_double GLM_EXT_quaternion_double 5 | /// @ingroup ext 6 | /// 7 | /// Exposes double-precision floating point quaternion type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_quaternion_float 12 | /// @see ext_quaternion_double_precision 13 | /// @see ext_quaternion_common 14 | /// @see ext_quaternion_exponential 15 | /// @see ext_quaternion_geometric 16 | /// @see ext_quaternion_relational 17 | /// @see ext_quaternion_transform 18 | /// @see ext_quaternion_trigonometric 19 | 20 | #pragma once 21 | 22 | // Dependency: 23 | #include "../detail/type_quat.hpp" 24 | 25 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_EXT_quaternion_double extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup ext_quaternion_double 32 | /// @{ 33 | 34 | /// Quaternion of double-precision floating-point numbers. 35 | typedef qua dquat; 36 | 37 | /// @} 38 | } //namespace glm 39 | 40 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/quaternion_double_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_quaternion_double_precision 2 | /// @file glm/ext/quaternion_double_precision.hpp 3 | /// 4 | /// @defgroup ext_quaternion_double_precision GLM_EXT_quaternion_double_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes double-precision floating point quaternion type with various precision in term of ULPs. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | // Dependency: 14 | #include "../detail/type_quat.hpp" 15 | 16 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 17 | # pragma message("GLM: GLM_EXT_quaternion_double_precision extension included") 18 | #endif 19 | 20 | namespace glm 21 | { 22 | /// @addtogroup ext_quaternion_double_precision 23 | /// @{ 24 | 25 | /// Quaternion of double-precision floating-point numbers using high precision arithmetic in term of ULPs. 26 | /// 27 | /// @see ext_quaternion_double_precision 28 | typedef qua lowp_dquat; 29 | 30 | /// Quaternion of medium double-qualifier floating-point numbers using high precision arithmetic in term of ULPs. 31 | /// 32 | /// @see ext_quaternion_double_precision 33 | typedef qua mediump_dquat; 34 | 35 | /// Quaternion of high double-qualifier floating-point numbers using high precision arithmetic in term of ULPs. 36 | /// 37 | /// @see ext_quaternion_double_precision 38 | typedef qua highp_dquat; 39 | 40 | /// @} 41 | } //namespace glm 42 | 43 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/quaternion_float.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_quaternion_float 2 | /// @file glm/ext/quaternion_float.hpp 3 | /// 4 | /// @defgroup ext_quaternion_float GLM_EXT_quaternion_float 5 | /// @ingroup ext 6 | /// 7 | /// Exposes single-precision floating point quaternion type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_quaternion_double 12 | /// @see ext_quaternion_float_precision 13 | /// @see ext_quaternion_common 14 | /// @see ext_quaternion_exponential 15 | /// @see ext_quaternion_geometric 16 | /// @see ext_quaternion_relational 17 | /// @see ext_quaternion_transform 18 | /// @see ext_quaternion_trigonometric 19 | 20 | #pragma once 21 | 22 | // Dependency: 23 | #include "../detail/type_quat.hpp" 24 | 25 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_EXT_quaternion_float extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup ext_quaternion_float 32 | /// @{ 33 | 34 | /// Quaternion of single-precision floating-point numbers. 35 | typedef qua quat; 36 | 37 | /// @} 38 | } //namespace glm 39 | 40 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/quaternion_float_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_quaternion_float_precision 2 | /// @file glm/ext/quaternion_float_precision.hpp 3 | /// 4 | /// @defgroup ext_quaternion_float_precision GLM_EXT_quaternion_float_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes single-precision floating point quaternion type with various precision in term of ULPs. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | // Dependency: 14 | #include "../detail/type_quat.hpp" 15 | 16 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 17 | # pragma message("GLM: GLM_EXT_quaternion_float_precision extension included") 18 | #endif 19 | 20 | namespace glm 21 | { 22 | /// @addtogroup ext_quaternion_float_precision 23 | /// @{ 24 | 25 | /// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 26 | typedef qua lowp_quat; 27 | 28 | /// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 29 | typedef qua mediump_quat; 30 | 31 | /// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 32 | typedef qua highp_quat; 33 | 34 | /// @} 35 | } //namespace glm 36 | 37 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/quaternion_geometric.inl: -------------------------------------------------------------------------------- 1 | namespace glm 2 | { 3 | template 4 | GLM_FUNC_QUALIFIER T dot(qua const& x, qua const& y) 5 | { 6 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); 7 | return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); 8 | } 9 | 10 | template 11 | GLM_FUNC_QUALIFIER T length(qua const& q) 12 | { 13 | return glm::sqrt(dot(q, q)); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER qua normalize(qua const& q) 18 | { 19 | T len = length(q); 20 | if(len <= static_cast(0)) // Problem 21 | return qua(static_cast(1), static_cast(0), static_cast(0), static_cast(0)); 22 | T oneOverLen = static_cast(1) / len; 23 | return qua(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen); 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER qua cross(qua const& q1, qua const& q2) 28 | { 29 | return qua( 30 | q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z, 31 | q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y, 32 | q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z, 33 | q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x); 34 | } 35 | }//namespace glm 36 | 37 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/quaternion_relational.inl: -------------------------------------------------------------------------------- 1 | namespace glm 2 | { 3 | template 4 | GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(qua const& x, qua const& y) 5 | { 6 | vec<4, bool, Q> Result; 7 | for(length_t i = 0; i < x.length(); ++i) 8 | Result[i] = x[i] == y[i]; 9 | return Result; 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(qua const& x, qua const& y, T epsilon) 14 | { 15 | vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); 16 | return lessThan(abs(v), vec<4, T, Q>(epsilon)); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER vec<4, bool, Q> notEqual(qua const& x, qua const& y) 21 | { 22 | vec<4, bool, Q> Result; 23 | for(length_t i = 0; i < x.length(); ++i) 24 | Result[i] = x[i] != y[i]; 25 | return Result; 26 | } 27 | 28 | template 29 | GLM_FUNC_QUALIFIER vec<4, bool, Q> notEqual(qua const& x, qua const& y, T epsilon) 30 | { 31 | vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); 32 | return greaterThanEqual(abs(v), vec<4, T, Q>(epsilon)); 33 | } 34 | }//namespace glm 35 | 36 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/quaternion_transform.inl: -------------------------------------------------------------------------------- 1 | namespace glm 2 | { 3 | template 4 | GLM_FUNC_QUALIFIER qua rotate(qua const& q, T const& angle, vec<3, T, Q> const& v) 5 | { 6 | vec<3, T, Q> Tmp = v; 7 | 8 | // Axis of rotation must be normalised 9 | T len = glm::length(Tmp); 10 | if(abs(len - static_cast(1)) > static_cast(0.001)) 11 | { 12 | T oneOverLen = static_cast(1) / len; 13 | Tmp.x *= oneOverLen; 14 | Tmp.y *= oneOverLen; 15 | Tmp.z *= oneOverLen; 16 | } 17 | 18 | T const AngleRad(angle); 19 | T const Sin = sin(AngleRad * static_cast(0.5)); 20 | 21 | return q * qua(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); 22 | } 23 | }//namespace glm 24 | 25 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/quaternion_trigonometric.inl: -------------------------------------------------------------------------------- 1 | #include "scalar_constants.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T angle(qua const& x) 7 | { 8 | if (abs(x.w) > cos_one_over_two()) 9 | { 10 | return asin(sqrt(x.x * x.x + x.y * x.y + x.z * x.z)) * static_cast(2); 11 | } 12 | 13 | return acos(x.w) * static_cast(2); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER vec<3, T, Q> axis(qua const& x) 18 | { 19 | T const tmp1 = static_cast(1) - x.w * x.w; 20 | if(tmp1 <= static_cast(0)) 21 | return vec<3, T, Q>(0, 0, 1); 22 | T const tmp2 = static_cast(1) / sqrt(tmp1); 23 | return vec<3, T, Q>(x.x * tmp2, x.y * tmp2, x.z * tmp2); 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER qua angleAxis(T const& angle, vec<3, T, Q> const& v) 28 | { 29 | T const a(angle); 30 | T const s = glm::sin(a * static_cast(0.5)); 31 | 32 | return qua(glm::cos(a * static_cast(0.5)), v * s); 33 | } 34 | }//namespace glm 35 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/scalar_constants.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_constants 2 | /// @file glm/ext/scalar_constants.hpp 3 | /// 4 | /// @defgroup ext_scalar_constants GLM_EXT_scalar_constants 5 | /// @ingroup ext 6 | /// 7 | /// Provides a list of constants and precomputed useful values. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | // Dependencies 14 | #include "../detail/setup.hpp" 15 | 16 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 17 | # pragma message("GLM: GLM_EXT_scalar_constants extension included") 18 | #endif 19 | 20 | namespace glm 21 | { 22 | /// @addtogroup ext_scalar_constants 23 | /// @{ 24 | 25 | /// Return the epsilon constant for floating point types. 26 | template 27 | GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon(); 28 | 29 | /// Return the pi constant for floating point types. 30 | template 31 | GLM_FUNC_DECL GLM_CONSTEXPR genType pi(); 32 | 33 | /// Return the value of cos(1 / 2) for floating point types. 34 | template 35 | GLM_FUNC_DECL GLM_CONSTEXPR genType cos_one_over_two(); 36 | 37 | /// @} 38 | } //namespace glm 39 | 40 | #include "scalar_constants.inl" 41 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/scalar_constants.inl: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() 7 | { 8 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'epsilon' only accepts floating-point inputs"); 9 | return std::numeric_limits::epsilon(); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() 14 | { 15 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'pi' only accepts floating-point inputs"); 16 | return static_cast(3.14159265358979323846264338327950288); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType cos_one_over_two() 21 | { 22 | return genType(0.877582561890372716130286068203503191); 23 | } 24 | } //namespace glm 25 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/scalar_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_packing 2 | /// @file glm/ext/scalar_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_scalar_packing GLM_EXT_scalar_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert scalar values to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_scalar_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_scalar_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "scalar_packing.inl" 33 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/scalar_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/vendor/glm/glm/ext/scalar_packing.inl -------------------------------------------------------------------------------- /vendor/glm/glm/ext/scalar_relational.inl: -------------------------------------------------------------------------------- 1 | #include "../common.hpp" 2 | #include "../ext/scalar_int_sized.hpp" 3 | #include "../ext/scalar_uint_sized.hpp" 4 | #include "../detail/type_float.hpp" 5 | 6 | namespace glm 7 | { 8 | template 9 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon) 10 | { 11 | return abs(x - y) <= epsilon; 12 | } 13 | 14 | template 15 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon) 16 | { 17 | return abs(x - y) > epsilon; 18 | } 19 | 20 | template 21 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, int MaxULPs) 22 | { 23 | detail::float_t const a(x); 24 | detail::float_t const b(y); 25 | 26 | // Different signs means they do not match. 27 | if(a.negative() != b.negative()) 28 | return false; 29 | 30 | // Find the difference in ULPs. 31 | typename detail::float_t::int_type const DiffULPs = abs(a.i - b.i); 32 | return DiffULPs <= MaxULPs; 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, int ULPs) 37 | { 38 | return !equal(x, y, ULPs); 39 | } 40 | }//namespace glm 41 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_bool1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_bool1 2 | /// @file glm/ext/vector_bool1.hpp 3 | /// 4 | /// @defgroup ext_vector_bool1 GLM_EXT_vector_bool1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes bvec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_bool1_precision extension. 12 | 13 | #pragma once 14 | 15 | #include "../detail/type_vec1.hpp" 16 | 17 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 18 | # pragma message("GLM: GLM_EXT_vector_bool1 extension included") 19 | #endif 20 | 21 | namespace glm 22 | { 23 | /// @addtogroup ext_vector_bool1 24 | /// @{ 25 | 26 | /// 1 components vector of boolean. 27 | typedef vec<1, bool, defaultp> bvec1; 28 | 29 | /// @} 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_bool1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_bool1_precision 2 | /// @file glm/ext/vector_bool1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_bool1_precision GLM_EXT_vector_bool1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_bvec1, mediump_bvec1 and lowp_bvec1 types. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | #include "../detail/type_vec1.hpp" 14 | 15 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 16 | # pragma message("GLM: GLM_EXT_vector_bool1_precision extension included") 17 | #endif 18 | 19 | namespace glm 20 | { 21 | /// @addtogroup ext_vector_bool1_precision 22 | /// @{ 23 | 24 | /// 1 component vector of bool values. 25 | typedef vec<1, bool, highp> highp_bvec1; 26 | 27 | /// 1 component vector of bool values. 28 | typedef vec<1, bool, mediump> mediump_bvec1; 29 | 30 | /// 1 component vector of bool values. 31 | typedef vec<1, bool, lowp> lowp_bvec1; 32 | 33 | /// @} 34 | }//namespace glm 35 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_bool2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, bool, defaultp> bvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_bool2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 2 components vector of high qualifier bool numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<2, bool, highp> highp_bvec2; 17 | 18 | /// 2 components vector of medium qualifier bool numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<2, bool, mediump> mediump_bvec2; 23 | 24 | /// 2 components vector of low qualifier bool numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<2, bool, lowp> lowp_bvec2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_bool3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, bool, defaultp> bvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_bool3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 3 components vector of high qualifier bool numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<3, bool, highp> highp_bvec3; 17 | 18 | /// 3 components vector of medium qualifier bool numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<3, bool, mediump> mediump_bvec3; 23 | 24 | /// 3 components vector of low qualifier bool numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<3, bool, lowp> lowp_bvec3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_bool4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, bool, defaultp> bvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_bool4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool4_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 4 components vector of high qualifier bool numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<4, bool, highp> highp_bvec4; 17 | 18 | /// 4 components vector of medium qualifier bool numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<4, bool, mediump> mediump_bvec4; 23 | 24 | /// 4 components vector of low qualifier bool numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<4, bool, lowp> lowp_bvec4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_double1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_double1 2 | /// @file glm/ext/vector_double1.hpp 3 | /// 4 | /// @defgroup ext_vector_double1 GLM_EXT_vector_double1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes double-precision floating point vector type with one component. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_double1_precision extension. 12 | /// @see ext_vector_float1 extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_double1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_double1 25 | /// @{ 26 | 27 | /// 1 components vector of double-precision floating-point numbers. 28 | typedef vec<1, double, defaultp> dvec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_double1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_double1_precision 2 | /// @file glm/ext/vector_double1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_double1_precision GLM_EXT_vector_double1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_dvec1, mediump_dvec1 and lowp_dvec1 types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_double1 12 | 13 | #pragma once 14 | 15 | #include "../detail/type_vec1.hpp" 16 | 17 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 18 | # pragma message("GLM: GLM_EXT_vector_double1_precision extension included") 19 | #endif 20 | 21 | namespace glm 22 | { 23 | /// @addtogroup ext_vector_double1_precision 24 | /// @{ 25 | 26 | /// 1 component vector of double-precision floating-point numbers using high precision arithmetic in term of ULPs. 27 | typedef vec<1, double, highp> highp_dvec1; 28 | 29 | /// 1 component vector of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. 30 | typedef vec<1, double, mediump> mediump_dvec1; 31 | 32 | /// 1 component vector of double-precision floating-point numbers using low precision arithmetic in term of ULPs. 33 | typedef vec<1, double, lowp> lowp_dvec1; 34 | 35 | /// @} 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_double2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, double, defaultp> dvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_double2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 2 components vector of high double-qualifier floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<2, double, highp> highp_dvec2; 17 | 18 | /// 2 components vector of medium double-qualifier floating-point numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<2, double, mediump> mediump_dvec2; 23 | 24 | /// 2 components vector of low double-qualifier floating-point numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<2, double, lowp> lowp_dvec2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_double3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, double, defaultp> dvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_double4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, double, defaultp> dvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_float1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_float1 2 | /// @file glm/ext/vector_float1.hpp 3 | /// 4 | /// @defgroup ext_vector_float1 GLM_EXT_vector_float1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes single-precision floating point vector type with one component. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_float1_precision extension. 12 | /// @see ext_vector_double1 extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_float1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_float1 25 | /// @{ 26 | 27 | /// 1 components vector of single-precision floating-point numbers. 28 | typedef vec<1, float, defaultp> vec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_float1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_float1_precision 2 | /// @file glm/ext/vector_float1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_float1_precision GLM_EXT_vector_float1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_vec1, mediump_vec1 and lowp_vec1 types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_float1 extension. 12 | 13 | #pragma once 14 | 15 | #include "../detail/type_vec1.hpp" 16 | 17 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 18 | # pragma message("GLM: GLM_EXT_vector_float1_precision extension included") 19 | #endif 20 | 21 | namespace glm 22 | { 23 | /// @addtogroup ext_vector_float1_precision 24 | /// @{ 25 | 26 | /// 1 component vector of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 27 | typedef vec<1, float, highp> highp_vec1; 28 | 29 | /// 1 component vector of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. 30 | typedef vec<1, float, mediump> mediump_vec1; 31 | 32 | /// 1 component vector of single-precision floating-point numbers using low precision arithmetic in term of ULPs. 33 | typedef vec<1, float, lowp> lowp_vec1; 34 | 35 | /// @} 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_float2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, float, defaultp> vec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_float2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 2 components vector of high single-qualifier floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<2, float, highp> highp_vec2; 17 | 18 | /// 2 components vector of medium single-qualifier floating-point numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<2, float, mediump> mediump_vec2; 23 | 24 | /// 2 components vector of low single-qualifier floating-point numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<2, float, lowp> lowp_vec2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_float3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, float, defaultp> vec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_float3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 3 components vector of high single-qualifier floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<3, float, highp> highp_vec3; 17 | 18 | /// 3 components vector of medium single-qualifier floating-point numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<3, float, mediump> mediump_vec3; 23 | 24 | /// 3 components vector of low single-qualifier floating-point numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<3, float, lowp> lowp_vec3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_float4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, float, defaultp> vec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_float4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float4_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 4 components vector of high single-qualifier floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<4, float, highp> highp_vec4; 17 | 18 | /// 4 components vector of medium single-qualifier floating-point numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<4, float, mediump> mediump_vec4; 23 | 24 | /// 4 components vector of low single-qualifier floating-point numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<4, float, lowp> lowp_vec4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_int1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int1 2 | /// @file glm/ext/vector_int1.hpp 3 | /// 4 | /// @defgroup ext_vector_int1 GLM_EXT_vector_int1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes ivec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_uint1 extension. 12 | /// @see ext_vector_int1_precision extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_int1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_int1 25 | /// @{ 26 | 27 | /// 1 component vector of signed integer numbers. 28 | typedef vec<1, int, defaultp> ivec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | 33 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_int1_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int1_sized 2 | /// @file glm/ext/vector_int1_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int1_sized GLM_EXT_vector_int1_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint1_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int1.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int1_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int1_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 1 component type. 29 | /// 30 | /// @see ext_vector_int1_sized 31 | typedef vec<1, int8, defaultp> i8vec1; 32 | 33 | /// 16 bit signed integer vector of 1 component type. 34 | /// 35 | /// @see ext_vector_int1_sized 36 | typedef vec<1, int16, defaultp> i16vec1; 37 | 38 | /// 32 bit signed integer vector of 1 component type. 39 | /// 40 | /// @see ext_vector_int1_sized 41 | typedef vec<1, int32, defaultp> i32vec1; 42 | 43 | /// 64 bit signed integer vector of 1 component type. 44 | /// 45 | /// @see ext_vector_int1_sized 46 | typedef vec<1, int64, defaultp> i64vec1; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_int2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, int, defaultp> ivec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_int2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int2_sized 2 | /// @file glm/ext/vector_int2_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int2_sized GLM_EXT_vector_int2_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector of 2 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint2_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int2.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 2 components type. 29 | /// 30 | /// @see ext_vector_int2_sized 31 | typedef vec<2, int8, defaultp> i8vec2; 32 | 33 | /// 16 bit signed integer vector of 2 components type. 34 | /// 35 | /// @see ext_vector_int2_sized 36 | typedef vec<2, int16, defaultp> i16vec2; 37 | 38 | /// 32 bit signed integer vector of 2 components type. 39 | /// 40 | /// @see ext_vector_int2_sized 41 | typedef vec<2, int32, defaultp> i32vec2; 42 | 43 | /// 64 bit signed integer vector of 2 components type. 44 | /// 45 | /// @see ext_vector_int2_sized 46 | typedef vec<2, int64, defaultp> i64vec2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_int3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, int, defaultp> ivec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_int3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int3_sized 2 | /// @file glm/ext/vector_int3_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int3_sized GLM_EXT_vector_int3_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector of 3 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint3_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int3.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int3_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 3 components type. 29 | /// 30 | /// @see ext_vector_int3_sized 31 | typedef vec<3, int8, defaultp> i8vec3; 32 | 33 | /// 16 bit signed integer vector of 3 components type. 34 | /// 35 | /// @see ext_vector_int3_sized 36 | typedef vec<3, int16, defaultp> i16vec3; 37 | 38 | /// 32 bit signed integer vector of 3 components type. 39 | /// 40 | /// @see ext_vector_int3_sized 41 | typedef vec<3, int32, defaultp> i32vec3; 42 | 43 | /// 64 bit signed integer vector of 3 components type. 44 | /// 45 | /// @see ext_vector_int3_sized 46 | typedef vec<3, int64, defaultp> i64vec3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_int4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, int, defaultp> ivec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_int4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int4_sized 2 | /// @file glm/ext/vector_int4_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int4_sized GLM_EXT_vector_int4_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector of 4 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint4_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int4.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int4_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 4 components type. 29 | /// 30 | /// @see ext_vector_int4_sized 31 | typedef vec<4, int8, defaultp> i8vec4; 32 | 33 | /// 16 bit signed integer vector of 4 components type. 34 | /// 35 | /// @see ext_vector_int4_sized 36 | typedef vec<4, int16, defaultp> i16vec4; 37 | 38 | /// 32 bit signed integer vector of 4 components type. 39 | /// 40 | /// @see ext_vector_int4_sized 41 | typedef vec<4, int32, defaultp> i32vec4; 42 | 43 | /// 64 bit signed integer vector of 4 components type. 44 | /// 45 | /// @see ext_vector_int4_sized 46 | typedef vec<4, int64, defaultp> i64vec4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_packing 2 | /// @file glm/ext/vector_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_vector_packing GLM_EXT_vector_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert vectors to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "vector_packing.inl" 33 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/vendor/glm/glm/ext/vector_packing.inl -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_uint1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint1 2 | /// @file glm/ext/vector_uint1.hpp 3 | /// 4 | /// @defgroup ext_vector_uint1 GLM_EXT_vector_uint1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes uvec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_int1 extension. 12 | /// @see ext_vector_uint1_precision extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_uint1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_uint1 25 | /// @{ 26 | 27 | /// 1 component vector of unsigned integer numbers. 28 | typedef vec<1, unsigned int, defaultp> uvec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | 33 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_uint1_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint1_sized 2 | /// @file glm/ext/vector_uint1_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_uint1_sized GLM_EXT_vector_uint1_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer vector types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | /// @see ext_vector_int1_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_uint1.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_uint1_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_uint1_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer vector of 1 component type. 29 | /// 30 | /// @see ext_vector_uint1_sized 31 | typedef vec<1, uint8, defaultp> u8vec1; 32 | 33 | /// 16 bit unsigned integer vector of 1 component type. 34 | /// 35 | /// @see ext_vector_uint1_sized 36 | typedef vec<1, uint16, defaultp> u16vec1; 37 | 38 | /// 32 bit unsigned integer vector of 1 component type. 39 | /// 40 | /// @see ext_vector_uint1_sized 41 | typedef vec<1, uint32, defaultp> u32vec1; 42 | 43 | /// 64 bit unsigned integer vector of 1 component type. 44 | /// 45 | /// @see ext_vector_uint1_sized 46 | typedef vec<1, uint64, defaultp> u64vec1; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_uint2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, unsigned int, defaultp> uvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_uint2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint2_sized 2 | /// @file glm/ext/vector_uint2_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_uint2_sized GLM_EXT_vector_uint2_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer vector of 2 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | /// @see ext_vector_int2_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_uint2.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_uint2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_uint2_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer vector of 2 components type. 29 | /// 30 | /// @see ext_vector_uint2_sized 31 | typedef vec<2, uint8, defaultp> u8vec2; 32 | 33 | /// 16 bit unsigned integer vector of 2 components type. 34 | /// 35 | /// @see ext_vector_uint2_sized 36 | typedef vec<2, uint16, defaultp> u16vec2; 37 | 38 | /// 32 bit unsigned integer vector of 2 components type. 39 | /// 40 | /// @see ext_vector_uint2_sized 41 | typedef vec<2, uint32, defaultp> u32vec2; 42 | 43 | /// 64 bit unsigned integer vector of 2 components type. 44 | /// 45 | /// @see ext_vector_uint2_sized 46 | typedef vec<2, uint64, defaultp> u64vec2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_uint3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, unsigned int, defaultp> uvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_uint3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint3_sized 2 | /// @file glm/ext/vector_uint3_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_uint3_sized GLM_EXT_vector_uint3_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer vector of 3 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | /// @see ext_vector_int3_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_uint3.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_uint3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_uint3_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer vector of 3 components type. 29 | /// 30 | /// @see ext_vector_uint3_sized 31 | typedef vec<3, uint8, defaultp> u8vec3; 32 | 33 | /// 16 bit unsigned integer vector of 3 components type. 34 | /// 35 | /// @see ext_vector_uint3_sized 36 | typedef vec<3, uint16, defaultp> u16vec3; 37 | 38 | /// 32 bit unsigned integer vector of 3 components type. 39 | /// 40 | /// @see ext_vector_uint3_sized 41 | typedef vec<3, uint32, defaultp> u32vec3; 42 | 43 | /// 64 bit unsigned integer vector of 3 components type. 44 | /// 45 | /// @see ext_vector_uint3_sized 46 | typedef vec<3, uint64, defaultp> u64vec3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_uint4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, unsigned int, defaultp> uvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /vendor/glm/glm/ext/vector_uint4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint4_sized 2 | /// @file glm/ext/vector_uint4_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_uint4_sized GLM_EXT_vector_uint4_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer vector of 4 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | /// @see ext_vector_int4_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_uint4.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_uint4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_uint4_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer vector of 4 components type. 29 | /// 30 | /// @see ext_vector_uint4_sized 31 | typedef vec<4, uint8, defaultp> u8vec4; 32 | 33 | /// 16 bit unsigned integer vector of 4 components type. 34 | /// 35 | /// @see ext_vector_uint4_sized 36 | typedef vec<4, uint16, defaultp> u16vec4; 37 | 38 | /// 32 bit unsigned integer vector of 4 components type. 39 | /// 40 | /// @see ext_vector_uint4_sized 41 | typedef vec<4, uint32, defaultp> u32vec4; 42 | 43 | /// 64 bit unsigned integer vector of 4 components type. 44 | /// 45 | /// @see ext_vector_uint4_sized 46 | typedef vec<4, uint64, defaultp> u64vec4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtc/matrix_access.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_access 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType row 7 | ( 8 | genType const& m, 9 | length_t index, 10 | typename genType::row_type const& x 11 | ) 12 | { 13 | assert(index >= 0 && index < m[0].length()); 14 | 15 | genType Result = m; 16 | for(length_t i = 0; i < m.length(); ++i) 17 | Result[i][index] = x[i]; 18 | return Result; 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER typename genType::row_type row 23 | ( 24 | genType const& m, 25 | length_t index 26 | ) 27 | { 28 | assert(index >= 0 && index < m[0].length()); 29 | 30 | typename genType::row_type Result(0); 31 | for(length_t i = 0; i < m.length(); ++i) 32 | Result[i] = m[i][index]; 33 | return Result; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER genType column 38 | ( 39 | genType const& m, 40 | length_t index, 41 | typename genType::col_type const& x 42 | ) 43 | { 44 | assert(index >= 0 && index < m.length()); 45 | 46 | genType Result = m; 47 | Result[index] = x; 48 | return Result; 49 | } 50 | 51 | template 52 | GLM_FUNC_QUALIFIER typename genType::col_type column 53 | ( 54 | genType const& m, 55 | length_t index 56 | ) 57 | { 58 | assert(index >= 0 && index < m.length()); 59 | 60 | return m[index]; 61 | } 62 | }//namespace glm 63 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtc/matrix_transform.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_transform 2 | /// @file glm/gtc/matrix_transform.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_transform 6 | /// @see gtx_transform2 7 | /// 8 | /// @defgroup gtc_matrix_transform GLM_GTC_matrix_transform 9 | /// @ingroup gtc 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Defines functions that generate common transformation matrices. 14 | /// 15 | /// The matrices generated by this extension use standard OpenGL fixed-function 16 | /// conventions. For example, the lookAt function generates a transform from world 17 | /// space into the specific eye space that the projective matrix functions 18 | /// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility 19 | /// specifications defines the particular layout of this eye space. 20 | 21 | #pragma once 22 | 23 | // Dependencies 24 | #include "../mat4x4.hpp" 25 | #include "../vec2.hpp" 26 | #include "../vec3.hpp" 27 | #include "../vec4.hpp" 28 | #include "../ext/matrix_projection.hpp" 29 | #include "../ext/matrix_clip_space.hpp" 30 | #include "../ext/matrix_transform.hpp" 31 | 32 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 33 | # pragma message("GLM: GLM_GTC_matrix_transform extension included") 34 | #endif 35 | 36 | #include "matrix_transform.inl" 37 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtc/matrix_transform.inl: -------------------------------------------------------------------------------- 1 | #include "../geometric.hpp" 2 | #include "../trigonometric.hpp" 3 | #include "../matrix.hpp" 4 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/vendor/glm/glm/gtc/quaternion_simd.inl -------------------------------------------------------------------------------- /vendor/glm/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtc/vec1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_vec1 2 | /// @file glm/gtc/vec1.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_vec1 GLM_GTC_vec1 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Add vec1, ivec1, uvec1 and bvec1 types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../ext/vector_bool1.hpp" 17 | #include "../ext/vector_bool1_precision.hpp" 18 | #include "../ext/vector_float1.hpp" 19 | #include "../ext/vector_float1_precision.hpp" 20 | #include "../ext/vector_double1.hpp" 21 | #include "../ext/vector_double1_precision.hpp" 22 | #include "../ext/vector_int1.hpp" 23 | #include "../ext/vector_int1_sized.hpp" 24 | #include "../ext/vector_uint1.hpp" 25 | #include "../ext/vector_uint1_sized.hpp" 26 | 27 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTC_vec1 extension included") 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/closest_point.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_closest_point 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> closestPointOnLine 7 | ( 8 | vec<3, T, Q> const& point, 9 | vec<3, T, Q> const& a, 10 | vec<3, T, Q> const& b 11 | ) 12 | { 13 | T LineLength = distance(a, b); 14 | vec<3, T, Q> Vector = point - a; 15 | vec<3, T, Q> LineDirection = (b - a) / LineLength; 16 | 17 | // Project Vector to LineDirection to get the distance of point from a 18 | T Distance = dot(Vector, LineDirection); 19 | 20 | if(Distance <= T(0)) return a; 21 | if(Distance >= LineLength) return b; 22 | return a + LineDirection * Distance; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER vec<2, T, Q> closestPointOnLine 27 | ( 28 | vec<2, T, Q> const& point, 29 | vec<2, T, Q> const& a, 30 | vec<2, T, Q> const& b 31 | ) 32 | { 33 | T LineLength = distance(a, b); 34 | vec<2, T, Q> Vector = point - a; 35 | vec<2, T, Q> LineDirection = (b - a) / LineLength; 36 | 37 | // Project Vector to LineDirection to get the distance of point from a 38 | T Distance = dot(Vector, LineDirection); 39 | 40 | if(Distance <= T(0)) return a; 41 | if(Distance >= LineLength) return b; 42 | return a + LineDirection * Distance; 43 | } 44 | 45 | }//namespace glm 46 | -------------------------------------------------------------------------------- /vendor/glm/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 | /// Include to use the features of this extension. 10 | /// 11 | /// Extend a position from a source to a position at a defined length. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # else 22 | # pragma message("GLM: GLM_GTX_extend extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 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 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/extend.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_extend 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType extend 7 | ( 8 | genType const& Origin, 9 | genType const& Source, 10 | genType const& Distance 11 | ) 12 | { 13 | return Origin + (Source - Origin) * Distance; 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER vec<2, T, Q> extend 18 | ( 19 | vec<2, T, Q> const& Origin, 20 | vec<2, T, Q> const& Source, 21 | T const& Distance 22 | ) 23 | { 24 | return Origin + (Source - Origin) * Distance; 25 | } 26 | 27 | template 28 | GLM_FUNC_QUALIFIER vec<3, T, Q> extend 29 | ( 30 | vec<3, T, Q> const& Origin, 31 | vec<3, T, Q> const& Source, 32 | T const& Distance 33 | ) 34 | { 35 | return Origin + (Source - Origin) * Distance; 36 | } 37 | 38 | template 39 | GLM_FUNC_QUALIFIER vec<4, T, Q> extend 40 | ( 41 | vec<4, T, Q> const& Origin, 42 | vec<4, T, Q> const& Source, 43 | T const& Distance 44 | ) 45 | { 46 | return Origin + (Source - Origin) * Distance; 47 | } 48 | }//namespace glm 49 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/exterior_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_exterior_product 2 | /// @file glm/gtx/exterior_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_exterior_product (dependence) 6 | /// 7 | /// @defgroup gtx_exterior_product GLM_GTX_exterior_product 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// @brief Allow to perform bit operations on integer values 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # ifndef GLM_ENABLE_EXPERIMENTAL 22 | # pragma message("GLM: GLM_GTX_exterior_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 23 | # else 24 | # pragma message("GLM: GLM_GTX_exterior_product extension included") 25 | # endif 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_exterior_product 31 | /// @{ 32 | 33 | /// Returns the cross product of x and y. 34 | /// 35 | /// @tparam T Floating-point scalar types 36 | /// @tparam Q Value from qualifier enum 37 | /// 38 | /// @see Exterior product 39 | template 40 | GLM_FUNC_DECL T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u); 41 | 42 | /// @} 43 | } //namespace glm 44 | 45 | #include "exterior_product.inl" 46 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/exterior_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_exterior_product 2 | 3 | #include 4 | 5 | namespace glm { 6 | namespace detail 7 | { 8 | template 9 | struct compute_cross_vec2 10 | { 11 | GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) 12 | { 13 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); 14 | 15 | return v.x * u.y - u.x * v.y; 16 | } 17 | }; 18 | }//namespace detail 19 | 20 | template 21 | GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y) 22 | { 23 | return detail::compute_cross_vec2::value>::call(x, y); 24 | } 25 | }//namespace glm 26 | 27 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/float_notmalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_float_normalize 2 | 3 | #include 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER vec floatNormalize(vec const& v) 9 | { 10 | return vec(v) / static_cast(std::numeric_limits::max()); 11 | } 12 | 13 | }//namespace glm 14 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/functions.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_functions 2 | 3 | #include "../exponential.hpp" 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER T gauss 9 | ( 10 | T x, 11 | T ExpectedValue, 12 | T StandardDeviation 13 | ) 14 | { 15 | return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER T gauss 20 | ( 21 | vec<2, T, Q> const& Coord, 22 | vec<2, T, Q> const& ExpectedValue, 23 | vec<2, T, Q> const& StandardDeviation 24 | ) 25 | { 26 | vec<2, T, Q> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation); 27 | return exp(-(Squared.x + Squared.y)); 28 | } 29 | }//namespace glm 30 | 31 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/gradient_paint.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T radialGradient 7 | ( 8 | vec<2, T, Q> const& Center, 9 | T const& Radius, 10 | vec<2, T, Q> const& Focal, 11 | vec<2, T, Q> const& Position 12 | ) 13 | { 14 | vec<2, T, Q> F = Focal - Center; 15 | vec<2, T, Q> D = Position - Focal; 16 | T Radius2 = pow2(Radius); 17 | T Fx2 = pow2(F.x); 18 | T Fy2 = pow2(F.y); 19 | 20 | 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)); 21 | T Denominator = Radius2 - (Fx2 + Fy2); 22 | return Numerator / Denominator; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER T linearGradient 27 | ( 28 | vec<2, T, Q> const& Point0, 29 | vec<2, T, Q> const& Point1, 30 | vec<2, T, Q> const& Position 31 | ) 32 | { 33 | vec<2, T, Q> Dist = Point1 - Point0; 34 | return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist); 35 | } 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/handed_coordinate_space.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER bool rightHanded 7 | ( 8 | vec<3, T, Q> const& tangent, 9 | vec<3, T, Q> const& binormal, 10 | vec<3, T, Q> const& normal 11 | ) 12 | { 13 | return dot(cross(normal, tangent), binormal) > T(0); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER bool leftHanded 18 | ( 19 | vec<3, T, Q> const& tangent, 20 | vec<3, T, Q> const& binormal, 21 | vec<3, T, Q> const& normal 22 | ) 23 | { 24 | return dot(cross(normal, tangent), binormal) < T(0); 25 | } 26 | }//namespace glm 27 | -------------------------------------------------------------------------------- /vendor/glm/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 | /// Include to use the features of this extension. 10 | /// 11 | /// Logarithm for any base. base can be a vector or a scalar. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_log_base is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # else 22 | # pragma message("GLM: GLM_GTX_log_base extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 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 41 | GLM_FUNC_DECL vec sign( 42 | vec const& x, 43 | vec const& base); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "log_base.inl" 49 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/log_base.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base) 7 | { 8 | return glm::log(x) / glm::log(base); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER vec log(vec const& x, vec const& base) 13 | { 14 | return glm::log(x) / glm::log(base); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/matrix_cross_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> matrixCross3 7 | ( 8 | vec<3, T, Q> const& x 9 | ) 10 | { 11 | mat<3, 3, T, Q> Result(T(0)); 12 | Result[0][1] = x.z; 13 | Result[1][0] = -x.z; 14 | Result[0][2] = -x.y; 15 | Result[2][0] = x.y; 16 | Result[1][2] = x.x; 17 | Result[2][1] = -x.x; 18 | return Result; 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> matrixCross4 23 | ( 24 | vec<3, T, Q> const& x 25 | ) 26 | { 27 | mat<4, 4, T, Q> Result(T(0)); 28 | Result[0][1] = x.z; 29 | Result[1][0] = -x.z; 30 | Result[0][2] = -x.y; 31 | Result[2][0] = x.y; 32 | Result[1][2] = x.x; 33 | Result[2][1] = -x.x; 34 | return Result; 35 | } 36 | 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yahiaetman/OpenGL-Examples/718a0704e4cc18e45dfad6e630b21de6204f8f5f/vendor/glm/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /vendor/glm/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 | /// Include to use the features of this extension. 10 | /// 11 | /// Mixed product of 3 vectors. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_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.") 21 | # else 22 | # pragma message("GLM: GLM_GTX_mixed_product extension included") 23 | # endif 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, Q> const& v1, 35 | vec<3, T, Q> const& v2, 36 | vec<3, T, Q> const& v3); 37 | 38 | /// @} 39 | }// namespace glm 40 | 41 | #include "mixed_product.inl" 42 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/mixed_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T mixedProduct 7 | ( 8 | vec<3, T, Q> const& v1, 9 | vec<3, T, Q> const& v2, 10 | vec<3, T, Q> const& v3 11 | ) 12 | { 13 | return dot(cross(v1, v2), v3); 14 | } 15 | }//namespace glm 16 | -------------------------------------------------------------------------------- /vendor/glm/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 | /// Include to use the features of this extension. 11 | /// 12 | /// Compute the normal of a triangle. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # ifndef GLM_ENABLE_EXPERIMENTAL 21 | # pragma message("GLM: GLM_GTX_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.") 22 | # else 23 | # pragma message("GLM: GLM_GTX_normal extension included") 24 | # endif 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normal 30 | /// @{ 31 | 32 | /// Computes triangle normal from triangle points. 33 | /// 34 | /// @see gtx_normal 35 | template 36 | GLM_FUNC_DECL vec<3, T, Q> triangleNormal(vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "normal.inl" 42 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/normal.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> triangleNormal 7 | ( 8 | vec<3, T, Q> const& p1, 9 | vec<3, T, Q> const& p2, 10 | vec<3, T, Q> const& p3 11 | ) 12 | { 13 | return normalize(cross(p1 - p2, p1 - p3)); 14 | } 15 | }//namespace glm 16 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/normalize_dot.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T normalizeDot(vec const& x, vec const& y) 7 | { 8 | return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER T fastNormalizeDot(vec const& x, vec const& y) 13 | { 14 | return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/optimum_pow.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType pow2(genType const& x) 7 | { 8 | return x * x; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER genType pow3(genType const& x) 13 | { 14 | return x * x * x; 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER genType pow4(genType const& x) 19 | { 20 | return (x * x) * (x * x); 21 | } 22 | }//namespace glm 23 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/orthonormalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m) 7 | { 8 | mat<3, 3, T, Q> r = m; 9 | 10 | r[0] = normalize(r[0]); 11 | 12 | T d0 = dot(r[0], r[1]); 13 | r[1] -= r[0] * d0; 14 | r[1] = normalize(r[1]); 15 | 16 | T d1 = dot(r[1], r[2]); 17 | d0 = dot(r[0], r[2]); 18 | r[2] -= r[0] * d0 + r[1] * d1; 19 | r[2] = normalize(r[2]); 20 | 21 | return r; 22 | } 23 | 24 | template 25 | GLM_FUNC_QUALIFIER vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y) 26 | { 27 | return normalize(x - y * dot(y, x)); 28 | } 29 | }//namespace glm 30 | -------------------------------------------------------------------------------- /vendor/glm/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 | /// Include to use the features of this extension. 11 | /// 12 | /// Perpendicular of a vector from other one 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include "../gtx/projection.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # ifndef GLM_ENABLE_EXPERIMENTAL 22 | # pragma message("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.") 23 | # else 24 | # pragma message("GLM: GLM_GTX_perpendicular extension included") 25 | # endif 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 genType perp(genType const& x, genType const& Normal); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "perpendicular.inl" 42 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/perpendicular.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal) 7 | { 8 | return x - proj(x, Normal); 9 | } 10 | }//namespace glm 11 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/polar_coordinates.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> polar 7 | ( 8 | vec<3, T, Q> const& euclidean 9 | ) 10 | { 11 | T const Length(length(euclidean)); 12 | vec<3, T, Q> const tmp(euclidean / Length); 13 | T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z)); 14 | 15 | return vec<3, T, Q>( 16 | asin(tmp.y), // latitude 17 | atan(tmp.x, tmp.z), // longitude 18 | xz_dist); // xz distance 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER vec<3, T, Q> euclidean 23 | ( 24 | vec<2, T, Q> const& polar 25 | ) 26 | { 27 | T const latitude(polar.x); 28 | T const longitude(polar.y); 29 | 30 | return vec<3, T, Q>( 31 | cos(latitude) * sin(longitude), 32 | sin(latitude), 33 | cos(latitude) * cos(longitude)); 34 | } 35 | 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /vendor/glm/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 | /// Include to use the features of this extension. 10 | /// 11 | /// Projection of a vector to other one 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../geometric.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("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.") 21 | # else 22 | # pragma message("GLM: GLM_GTX_projection extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_projection 29 | /// @{ 30 | 31 | /// Projects x on Normal. 32 | /// 33 | /// @param[in] x A vector to project 34 | /// @param[in] Normal A normal that doesn't need to be of unit length. 35 | /// 36 | /// @see gtx_projection 37 | template 38 | GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); 39 | 40 | /// @} 41 | }//namespace glm 42 | 43 | #include "projection.inl" 44 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/projection.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal) 7 | { 8 | return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; 9 | } 10 | }//namespace glm 11 | -------------------------------------------------------------------------------- /vendor/glm/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 | /// Include to use the features of this extension. 10 | /// 11 | /// Projection of a vector to other one 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../ext/scalar_uint_sized.hpp" 17 | #include "../detail/setup.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # ifndef GLM_ENABLE_EXPERIMENTAL 21 | # pragma message("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.") 22 | # else 23 | # pragma message("GLM: GLM_GTX_raw_data extension included") 24 | # endif 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 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | 3 | -------------------------------------------------------------------------------- /vendor/glm/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 | /// Include to use the features of this extension. 10 | /// 11 | /// Extend a position from a source to a position at a defined length. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # else 22 | # pragma message("GLM: GLM_GTX_extend extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_scalar_relational 29 | /// @{ 30 | 31 | 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "scalar_relational.inl" 37 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/scalar_relational.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER bool lessThan 7 | ( 8 | T const& x, 9 | T const& y 10 | ) 11 | { 12 | return x < y; 13 | } 14 | 15 | template 16 | GLM_FUNC_QUALIFIER bool lessThanEqual 17 | ( 18 | T const& x, 19 | T const& y 20 | ) 21 | { 22 | return x <= y; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER bool greaterThan 27 | ( 28 | T const& x, 29 | T const& y 30 | ) 31 | { 32 | return x > y; 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER bool greaterThanEqual 37 | ( 38 | T const& x, 39 | T const& y 40 | ) 41 | { 42 | return x >= y; 43 | } 44 | 45 | template 46 | GLM_FUNC_QUALIFIER bool equal 47 | ( 48 | T const& x, 49 | T const& y 50 | ) 51 | { 52 | return detail::compute_equal::is_iec559>::call(x, y); 53 | } 54 | 55 | template 56 | GLM_FUNC_QUALIFIER bool notEqual 57 | ( 58 | T const& x, 59 | T const& y 60 | ) 61 | { 62 | return !detail::compute_equal::is_iec559>::call(x, y); 63 | } 64 | 65 | GLM_FUNC_QUALIFIER bool any 66 | ( 67 | bool const& x 68 | ) 69 | { 70 | return x; 71 | } 72 | 73 | GLM_FUNC_QUALIFIER bool all 74 | ( 75 | bool const& x 76 | ) 77 | { 78 | return x; 79 | } 80 | 81 | GLM_FUNC_QUALIFIER bool not_ 82 | ( 83 | bool const& x 84 | ) 85 | { 86 | return !x; 87 | } 88 | }//namespace glm 89 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/texture.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | /// @file glm/gtx/texture.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_texture GLM_GTX_texture 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Wrapping mode of texture coordinates. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtc/integer.hpp" 18 | #include "../gtx/component_wise.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # ifndef GLM_ENABLE_EXPERIMENTAL 22 | # pragma message("GLM: GLM_GTX_texture is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 23 | # else 24 | # pragma message("GLM: GLM_GTX_texture extension included") 25 | # endif 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_texture 31 | /// @{ 32 | 33 | /// Compute the number of mipmaps levels necessary to create a mipmap complete texture 34 | /// 35 | /// @param Extent Extent of the texture base level mipmap 36 | /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector 37 | /// @tparam T Floating-point or signed integer scalar types 38 | /// @tparam Q Value from qualifier enum 39 | template 40 | T levels(vec const& Extent); 41 | 42 | /// @} 43 | }// namespace glm 44 | 45 | #include "texture.inl" 46 | 47 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/texture.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | 3 | namespace glm 4 | { 5 | template 6 | inline T levels(vec const& Extent) 7 | { 8 | return glm::log2(compMax(Extent)) + static_cast(1); 9 | } 10 | 11 | template 12 | inline T levels(T Extent) 13 | { 14 | return vec<1, T, defaultp>(Extent).x; 15 | } 16 | }//namespace glm 17 | 18 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/transform.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(vec<3, T, Q> const& v) 7 | { 8 | return translate(mat<4, 4, T, Q>(static_cast(1)), v); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v) 13 | { 14 | return rotate(mat<4, 4, T, Q>(static_cast(1)), angle, v); 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(vec<3, T, Q> const& v) 19 | { 20 | return scale(mat<4, 4, T, Q>(static_cast(1)), v); 21 | } 22 | 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /vendor/glm/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 | /// Include to use the features of this extension. 10 | /// 11 | /// Wrapping mode of texture coordinates. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../ext/scalar_common.hpp" 18 | #include "../ext/vector_common.hpp" 19 | #include "../gtc/vec1.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # ifndef GLM_ENABLE_EXPERIMENTAL 23 | # pragma message("GLM: GLM_GTX_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.") 24 | # else 25 | # pragma message("GLM: GLM_GTX_wrap extension included") 26 | # endif 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_wrap 32 | /// @{ 33 | 34 | /// @} 35 | }// namespace glm 36 | 37 | #include "wrap.inl" 38 | -------------------------------------------------------------------------------- /vendor/glm/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /vendor/glm/glm/mat2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x2.hpp" 6 | #include "./ext/matrix_double2x2_precision.hpp" 7 | #include "./ext/matrix_float2x2.hpp" 8 | #include "./ext/matrix_float2x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /vendor/glm/glm/mat2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x3.hpp" 6 | #include "./ext/matrix_double2x3_precision.hpp" 7 | #include "./ext/matrix_float2x3.hpp" 8 | #include "./ext/matrix_float2x3_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /vendor/glm/glm/mat2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x4.hpp" 6 | #include "./ext/matrix_double2x4_precision.hpp" 7 | #include "./ext/matrix_float2x4.hpp" 8 | #include "./ext/matrix_float2x4_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /vendor/glm/glm/mat3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x2.hpp" 6 | #include "./ext/matrix_double3x2_precision.hpp" 7 | #include "./ext/matrix_float3x2.hpp" 8 | #include "./ext/matrix_float3x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /vendor/glm/glm/mat3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x3.hpp" 6 | #include "./ext/matrix_double3x3_precision.hpp" 7 | #include "./ext/matrix_float3x3.hpp" 8 | #include "./ext/matrix_float3x3_precision.hpp" 9 | -------------------------------------------------------------------------------- /vendor/glm/glm/mat3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x4.hpp" 6 | #include "./ext/matrix_double3x4_precision.hpp" 7 | #include "./ext/matrix_float3x4.hpp" 8 | #include "./ext/matrix_float3x4_precision.hpp" 9 | -------------------------------------------------------------------------------- /vendor/glm/glm/mat4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x2.hpp" 6 | #include "./ext/matrix_double4x2_precision.hpp" 7 | #include "./ext/matrix_float4x2.hpp" 8 | #include "./ext/matrix_float4x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /vendor/glm/glm/mat4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x3.hpp" 6 | #include "./ext/matrix_double4x3_precision.hpp" 7 | #include "./ext/matrix_float4x3.hpp" 8 | #include "./ext/matrix_float4x3_precision.hpp" 9 | -------------------------------------------------------------------------------- /vendor/glm/glm/mat4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x4.hpp" 6 | #include "./ext/matrix_double4x4_precision.hpp" 7 | #include "./ext/matrix_float4x4.hpp" 8 | #include "./ext/matrix_float4x4_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /vendor/glm/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_f32vec4 glm_vec1_sqrt_lowp(glm_f32vec4 x) 11 | { 12 | return _mm_mul_ss(_mm_rsqrt_ss(x), x); 13 | } 14 | 15 | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sqrt_lowp(glm_f32vec4 x) 16 | { 17 | return _mm_mul_ps(_mm_rsqrt_ps(x), x); 18 | } 19 | 20 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 21 | -------------------------------------------------------------------------------- /vendor/glm/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 | -------------------------------------------------------------------------------- /vendor/glm/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 | -------------------------------------------------------------------------------- /vendor/glm/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 | -------------------------------------------------------------------------------- /vendor/glm/glm/vec2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec2.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool2.hpp" 6 | #include "./ext/vector_bool2_precision.hpp" 7 | #include "./ext/vector_float2.hpp" 8 | #include "./ext/vector_float2_precision.hpp" 9 | #include "./ext/vector_double2.hpp" 10 | #include "./ext/vector_double2_precision.hpp" 11 | #include "./ext/vector_int2.hpp" 12 | #include "./ext/vector_int2_sized.hpp" 13 | #include "./ext/vector_uint2.hpp" 14 | #include "./ext/vector_uint2_sized.hpp" 15 | -------------------------------------------------------------------------------- /vendor/glm/glm/vec3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec3.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool3.hpp" 6 | #include "./ext/vector_bool3_precision.hpp" 7 | #include "./ext/vector_float3.hpp" 8 | #include "./ext/vector_float3_precision.hpp" 9 | #include "./ext/vector_double3.hpp" 10 | #include "./ext/vector_double3_precision.hpp" 11 | #include "./ext/vector_int3.hpp" 12 | #include "./ext/vector_int3_sized.hpp" 13 | #include "./ext/vector_uint3.hpp" 14 | #include "./ext/vector_uint3_sized.hpp" 15 | -------------------------------------------------------------------------------- /vendor/glm/glm/vec4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec4.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool4.hpp" 6 | #include "./ext/vector_bool4_precision.hpp" 7 | #include "./ext/vector_float4.hpp" 8 | #include "./ext/vector_float4_precision.hpp" 9 | #include "./ext/vector_double4.hpp" 10 | #include "./ext/vector_double4_precision.hpp" 11 | #include "./ext/vector_int4.hpp" 12 | #include "./ext/vector_int4_sized.hpp" 13 | #include "./ext/vector_uint4.hpp" 14 | #include "./ext/vector_uint4_sized.hpp" 15 | 16 | -------------------------------------------------------------------------------- /vendor/imgui/LICENSE.txt: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014-2020 Omar Cornut 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /vendor/utils/tinygltf/LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 Syoyo Fujita, Aurélien Chatelain and many contributors 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | --------------------------------------------------------------------------------