├── LICENSE.md ├── LICENSE_third_party.md ├── README.md ├── adanerf_real_time_viewer ├── .gitignore ├── CMakeLists.txt ├── CMakeSettings.json ├── README.md ├── dependencies │ ├── GLSL_build_tools │ │ ├── build │ │ │ └── cmake │ │ │ │ └── add_glsl_sources.cmake │ │ └── source │ │ │ ├── EmbedGLSL │ │ │ ├── AssemblyInfo.cs │ │ │ ├── CommandLine.cs │ │ │ ├── Dependencies.cs │ │ │ ├── EmbedGLSL.cs │ │ │ └── LogListener.cs │ │ │ ├── GLSLStream.cpp │ │ │ ├── GLSLStream.h │ │ │ ├── Log.h │ │ │ ├── StdStreamLog.cpp │ │ │ ├── StdStreamLog.h │ │ │ ├── glsl2cpp.cpp │ │ │ ├── interface.h │ │ │ ├── io.h │ │ │ ├── main.cpp │ │ │ └── test │ │ │ ├── bla.glsl │ │ │ └── test.cpp │ ├── GL_core_tools │ │ ├── build │ │ │ └── cmake │ │ │ │ └── CMakeLists.txt │ │ ├── include │ │ │ └── GL │ │ │ │ ├── buffer.h │ │ │ │ ├── error.h │ │ │ │ ├── event.h │ │ │ │ ├── framebuffer.h │ │ │ │ ├── sampler.h │ │ │ │ ├── scoped_name.h │ │ │ │ ├── shader.h │ │ │ │ ├── texture.h │ │ │ │ ├── transform_feedback.h │ │ │ │ ├── unique_name.h │ │ │ │ └── vertex_array.h │ │ └── source │ │ │ ├── buffer.cpp │ │ │ ├── error.cpp │ │ │ ├── event.cpp │ │ │ ├── framebuffer.cpp │ │ │ ├── shader.cpp │ │ │ ├── texture.cpp │ │ │ ├── transform_feedback.cpp │ │ │ └── vertex_array.cpp │ ├── GL_platform_tools │ │ ├── build │ │ │ └── cmake │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── glcore │ │ │ │ └── CMakeLists.txt │ │ │ │ └── test │ │ │ │ └── CMakeLists.txt │ │ ├── include │ │ │ └── GL │ │ │ │ └── platform │ │ │ │ ├── Application.h │ │ │ │ ├── Context.h │ │ │ │ ├── DefaultDisplayHandler.h │ │ │ │ ├── DisplayHandler.h │ │ │ │ ├── InputHandler.h │ │ │ │ ├── Renderer.h │ │ │ │ ├── Window.h │ │ │ │ └── interface.h │ │ └── source │ │ │ ├── DefaultDisplayHandler.cpp │ │ │ ├── egl │ │ │ ├── glcore │ │ │ │ ├── context.cpp │ │ │ │ └── context.h │ │ │ └── include │ │ │ │ ├── GL │ │ │ │ └── gl.h │ │ │ │ └── glcore.h │ │ │ ├── win32 │ │ │ ├── Win32GLApplication.cpp │ │ │ ├── Win32GLApplication.h │ │ │ ├── Win32GLContext.cpp │ │ │ ├── Win32GLContext.h │ │ │ ├── Win32GLWindow.cpp │ │ │ ├── Win32GLWindow.h │ │ │ ├── Win32Input.h │ │ │ ├── glcore │ │ │ │ ├── DllMain.cpp │ │ │ │ ├── context.cpp │ │ │ │ └── context.h │ │ │ ├── include │ │ │ │ ├── GL │ │ │ │ │ └── gl.h │ │ │ │ └── win32 │ │ │ │ │ └── glcore.h │ │ │ └── wglext.h │ │ │ └── x11 │ │ │ ├── X11ColormapHandle.h │ │ │ ├── X11Display.cpp │ │ │ ├── X11Display.h │ │ │ ├── X11GLApplication.cpp │ │ │ ├── X11GLApplication.h │ │ │ ├── X11GLContext.cpp │ │ │ ├── X11GLContext.h │ │ │ ├── X11GLWindow.cpp │ │ │ ├── X11GLWindow.h │ │ │ ├── X11Input.h │ │ │ ├── X11WindowHandle.h │ │ │ ├── glxext.h │ │ │ ├── include │ │ │ └── GL │ │ │ │ └── gl.h │ │ │ ├── platform.h │ │ │ └── x11_ptr.h │ ├── Win32_core_tools │ │ ├── build │ │ │ └── cmake │ │ │ │ └── CMakeLists.txt │ │ ├── include │ │ │ └── win32 │ │ │ │ ├── WindowClass.h │ │ │ │ ├── com_error.h │ │ │ │ ├── com_ptr.h │ │ │ │ ├── com_utility.h │ │ │ │ ├── error.h │ │ │ │ ├── event.h │ │ │ │ ├── file.h │ │ │ │ ├── handle_deleter.h │ │ │ │ ├── memory.h │ │ │ │ ├── module_handle.h │ │ │ │ ├── platform.h │ │ │ │ ├── scoped_handle.h │ │ │ │ ├── unicode.h │ │ │ │ ├── unique_handle.h │ │ │ │ └── window_handle.h │ │ └── source │ │ │ ├── error.cpp │ │ │ ├── event.cpp │ │ │ └── unicode.cpp │ ├── argparse │ │ └── argparse │ │ │ └── argparse.hpp │ ├── 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_integer.hpp │ │ │ ├── matrix_integer.inl │ │ │ ├── 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_reciprocal.hpp │ │ │ ├── scalar_reciprocal.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_reciprocal.hpp │ │ │ ├── vector_reciprocal.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 │ │ │ ├── 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 │ │ │ ├── pca.hpp │ │ │ ├── pca.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 │ └── tensorrt │ │ ├── LICENSE │ │ ├── NOTICE │ │ ├── VERSION │ │ └── samples │ │ └── common │ │ ├── BatchStream.h │ │ ├── EntropyCalibrator.h │ │ ├── ErrorRecorder.h │ │ ├── argsParser.h │ │ ├── buffers.h │ │ ├── common.h │ │ ├── dumpTFWts.py │ │ ├── getOptions.cpp │ │ ├── getOptions.h │ │ ├── half.h │ │ ├── logger.cpp │ │ ├── logger.h │ │ ├── logging.h │ │ ├── parserOnnxConfig.h │ │ ├── safeCommon.h │ │ ├── sampleConfig.h │ │ ├── sampleDevice.h │ │ ├── sampleEngines.cpp │ │ ├── sampleEngines.h │ │ ├── sampleInference.cpp │ │ ├── sampleInference.h │ │ ├── sampleOptions.cpp │ │ ├── sampleOptions.h │ │ ├── sampleReporting.cpp │ │ ├── sampleReporting.h │ │ ├── sampleUtils.h │ │ └── windows │ │ ├── getopt.c │ │ └── getopt.h ├── include │ ├── basicbuffermanager.h │ ├── bmp.h │ ├── buffermanager.h │ ├── camera.h │ ├── config.h │ ├── cuda │ │ ├── adanerf_cuda_helper.h │ │ ├── adanerf_cuda_kernels.cuh │ │ └── helper_math.h │ ├── encoding.h │ ├── featureset.h │ ├── helper.h │ ├── imagegenerator.h │ ├── inputhandler.h │ ├── interoprenderbuffer.h │ ├── neuralrenderer.h │ └── settings.h ├── sample │ ├── config.ini │ ├── dataset_info.txt │ ├── model0.onnx │ └── model1.onnx ├── sample_pavillon_16 │ ├── config.ini │ ├── dataset_info.txt │ ├── model0.onnx │ └── model1.onnx └── src │ ├── basicbuffermanager.cpp │ ├── camera.cpp │ ├── config.cpp │ ├── cuda │ ├── adaptive_cuda_kernels.cu │ ├── base_cuda_kernels.cu │ └── coarse_cuda_kernels.cu │ ├── encoding.cpp │ ├── featureset.cpp │ ├── imagegenerator.cpp │ ├── inputhandler.cpp │ ├── interoprenderbuffer.cpp │ ├── main.cpp │ ├── neuralrenderer.cpp │ └── settings.cpp ├── adanerf_teaser.png ├── blender_export.py ├── blender_export_per_scene_stub.py ├── configs ├── dense_training.ini ├── dense_training_ndc.ini ├── fine_training.ini └── fine_training_ndc.ini ├── requirements.txt └── src ├── camera.py ├── comparison.py ├── convert_llff.py ├── datasets.py ├── evaluate.py ├── export.py ├── features.py ├── losses.py ├── models.py ├── native ├── disc_depth_multiclass.cpp └── disc_depth_multiclass_cuda.cu ├── native_extensions.py ├── nerf_raymarch_common.py ├── plots.py ├── prepare_dataset.py ├── sampled_sequence.py ├── test.py ├── train.py ├── train_data.py └── util ├── IW_SSIM_PyTorch.py ├── config.py ├── depth_transformations.py ├── feature_encoding.py ├── flip_loss.py ├── helper.py ├── load_llff.py ├── load_llff_nex.py ├── raygeneration.py ├── sample_placement_tracker.py └── saveimage.py /adanerf_real_time_viewer/.gitignore: -------------------------------------------------------------------------------- 1 | 2 | # IDE files 3 | .vs/ 4 | .vscode/ 5 | 6 | # Build files 7 | /out/ 8 | /build/ 9 | 10 | # Sample runtime files (engine, outputs, ...) 11 | sample/engine* 12 | sample/*.bmp 13 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/CMakeSettings.json: -------------------------------------------------------------------------------- 1 | { 2 | "configurations": [ 3 | { 4 | "name": "x64-Debug", 5 | "generator": "Ninja", 6 | "configurationType": "Debug", 7 | "inheritEnvironments": [ "msvc_x64_x64" ], 8 | "buildRoot": "${projectDir}\\out\\build\\${name}", 9 | "installRoot": "${projectDir}\\out\\install\\${name}", 10 | "cmakeCommandArgs": "", 11 | "buildCommandArgs": "", 12 | "ctestCommandArgs": "" 13 | }, 14 | { 15 | "name": "x64-Release", 16 | "generator": "Ninja", 17 | "configurationType": "Release", 18 | "buildRoot": "${projectDir}\\out\\build\\${name}", 19 | "installRoot": "${projectDir}\\out\\install\\${name}", 20 | "cmakeCommandArgs": "", 21 | "buildCommandArgs": "", 22 | "ctestCommandArgs": "", 23 | "inheritEnvironments": [ "msvc_x64_x64" ], 24 | "variables": [] 25 | } 26 | ] 27 | } -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GLSL_build_tools/build/cmake/add_glsl_sources.cmake: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.16) 2 | 3 | 4 | add_executable(glsl2cpp ${CMAKE_CURRENT_LIST_DIR}/../../source/glsl2cpp.cpp) 5 | 6 | 7 | macro(glsl_add_definitions sources defs) 8 | set_property(SOURCE ${sources} APPEND PROPERTY GLSL_DEFINITIONS ${defs}) 9 | endmacro() 10 | 11 | macro(glsl_add_include_directories sources dirs) 12 | set_property(SOURCE ${sources} APPEND PROPERTY GLSL_INCLUDE_DIRS ${dirs}) 13 | endmacro() 14 | 15 | function(glsl_source target source) 16 | get_property(idirs SOURCE ${source} PROPERTY GLSL_INCLUDE_DIRS) 17 | foreach (i ${idirs}) 18 | list(APPEND cmdline -I ${i}) 19 | endforeach() 20 | 21 | get_property(defs SOURCE ${source} PROPERTY GLSL_DEFINITIONS) 22 | foreach (d ${defs}) 23 | list(APPEND cmdline -D${d}) 24 | endforeach() 25 | 26 | add_custom_command( 27 | OUTPUT ${target} 28 | COMMAND glsl2cpp 29 | ARGS ${cmdline} -o ${target} ${source} 30 | MAIN_DEPENDENCY ${source} 31 | ) 32 | endfunction() 33 | 34 | function(add_glsl_sources library sources) 35 | foreach (f ${sources}) 36 | get_filename_component(n ${f} NAME) 37 | glsl_source(${n}.cpp ${f}) 38 | list(APPEND shader_files ${n}.cpp) 39 | endforeach() 40 | add_library(${library} ${shader_files}) 41 | endfunction() 42 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GLSL_build_tools/source/Log.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_LOG_H 5 | #define INCLUDED_LOG_H 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "interface.h" 12 | 13 | 14 | class INTERFACE Log 15 | { 16 | protected: 17 | Log() {} 18 | Log(const Log&) {} 19 | ~Log() {} 20 | Log& operator =(const Log&) { return *this; } 21 | public: 22 | virtual int errors() const = 0; 23 | virtual int warnings() const = 0; 24 | 25 | virtual void warning(const char* message, const char* file, int line) = 0; 26 | virtual void warning(const std::string& message, const char* file, int line) = 0; 27 | virtual void error(const char* message, const char* file, int line) = 0; 28 | virtual void error(const std::string& message, const char* file, int line) = 0; 29 | }; 30 | 31 | 32 | #endif // INCLUDED_LOG_H 33 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GLSL_build_tools/source/StdStreamLog.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include 5 | 6 | #include "StdStreamLog.h" 7 | 8 | 9 | StdStreamLog::StdStreamLog() 10 | : log_errors(0), 11 | log_warnings(0) 12 | { 13 | } 14 | 15 | void StdStreamLog::warning(const char* message, const char* file, int line) 16 | { 17 | ++log_warnings; 18 | std::cout << file << '(' << line << "): warning: " << message << std::endl; 19 | } 20 | 21 | void StdStreamLog::warning(const std::string& message, const char* file, int line) 22 | { 23 | ++log_warnings; 24 | std::cout << file << '(' << line << "): warning: " << message << std::endl; 25 | } 26 | 27 | void StdStreamLog::error(const char* message, const char* file, int line) 28 | { 29 | ++log_errors; 30 | std::cout << file << '(' << line << "): error: " << message << std::endl; 31 | } 32 | 33 | void StdStreamLog::error(const std::string& message, const char* file, int line) 34 | { 35 | ++log_errors; 36 | std::cout << file << '(' << line << "): error: " << message << std::endl; 37 | } 38 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GLSL_build_tools/source/StdStreamLog.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_STDSTREAMLOG_H 5 | #define INCLUDED_STDSTREAMLOG_H 6 | 7 | #pragma once 8 | 9 | #include "Log.h" 10 | 11 | 12 | class StdStreamLog : public virtual Log 13 | { 14 | protected: 15 | StdStreamLog(const StdStreamLog&); 16 | StdStreamLog& operator =(const StdStreamLog&); 17 | 18 | int log_warnings; 19 | int log_errors; 20 | 21 | public: 22 | StdStreamLog(); 23 | 24 | int errors() const { return log_errors; } 25 | int warnings() const { return log_warnings; } 26 | 27 | void warning(const char* message, const char* file, int line); 28 | void warning(const std::string& message, const char* file, int line); 29 | void error(const char* message, const char* file, int line); 30 | void error(const std::string& message, const char* file, int line); 31 | }; 32 | 33 | 34 | #endif // INCLUDED_STDSTREAMLOG_H 35 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GLSL_build_tools/source/interface.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_INTERFACE_H 5 | #define INCLUDED_INTERFACE_H 6 | 7 | #pragma once 8 | 9 | 10 | #ifdef _MSC_VER 11 | #define INTERFACE __declspec(novtable) 12 | #else 13 | #define INTERFACE 14 | #endif 15 | 16 | 17 | #endif // INCLUDED_INTERFACE_H 18 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GLSL_build_tools/source/test/bla.glsl: -------------------------------------------------------------------------------- 1 | 2 | 3 | #version 330 4 | 5 | 6 | void main() 7 | { 8 | gl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f); 9 | } 10 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GLSL_build_tools/source/test/test.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include 5 | 6 | extern const char bla[]; 7 | 8 | int main() 9 | { 10 | std::cout << bla; 11 | 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/build/cmake/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.16) 2 | 3 | project(GL_core_tools) 4 | 5 | set(INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../include/") 6 | set(SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../source/") 7 | 8 | 9 | file(GLOB GL_core_tools_SOURCES "${SOURCE_DIR}/*.cpp") 10 | 11 | include_directories(${GL_platform_tools_INCLUDE_DIRS} ${INCLUDE_DIR}GL) 12 | 13 | if (WIN32) 14 | include_directories(${Win32_core_tools_INCLUDE_DIRS}) 15 | endif () 16 | 17 | add_library(GL_core_tools STATIC ${GL_core_tools_SOURCES}) 18 | 19 | set(GL_core_tools_INCLUDE_DIRS ${INCLUDE_DIR} CACHE INTERNAL "GL core tools include directories") 20 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/include/GL/buffer.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_BUFFER 5 | #define INCLUDED_GL_BUFFER 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "unique_name.h" 12 | 13 | 14 | namespace GL 15 | { 16 | struct BufferObjectNamespace 17 | { 18 | static GLuint gen(); 19 | static void del(GLuint name); 20 | }; 21 | 22 | typedef unique_name Buffer; 23 | } 24 | 25 | #endif // INCLUDED_GL_BUFFER 26 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/include/GL/error.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_ERROR 5 | #define INCLUDED_GL_ERROR 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include 12 | 13 | 14 | namespace GL 15 | { 16 | class error : public std::exception 17 | { 18 | private: 19 | GLenum error_code; 20 | public: 21 | error(GLenum error_code); 22 | 23 | #if defined(_MSC_VER) && _MSC_VER <= 1800 24 | const char* what() const; 25 | #else 26 | const char* what() const noexcept; 27 | #endif 28 | }; 29 | 30 | inline void checkError() 31 | { 32 | if (GLenum err = glGetError()) 33 | throw GL::error(err); 34 | } 35 | } 36 | 37 | #endif // INCLUDED_GL_ERROR 38 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/include/GL/event.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_EVENT 5 | #define INCLUDED_GL_EVENT 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "unique_name.h" 12 | 13 | 14 | namespace GL 15 | { 16 | struct QueryObjectNamespace 17 | { 18 | static GLuint gen(); 19 | static void del(GLuint name); 20 | }; 21 | 22 | typedef unique_name Query; 23 | } 24 | 25 | #endif // INCLUDED_GL_EVENT 26 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/include/GL/framebuffer.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_FRAMEBUFFER 5 | #define INCLUDED_GL_FRAMEBUFFER 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "unique_name.h" 12 | 13 | 14 | namespace GL 15 | { 16 | struct FramebufferObjectNamespace 17 | { 18 | static GLuint gen(); 19 | static void del(GLuint name); 20 | }; 21 | 22 | struct RenderbufferObjectNamespace 23 | { 24 | static GLuint gen(); 25 | static void del(GLuint name); 26 | }; 27 | 28 | typedef unique_name Framebuffer; 29 | typedef unique_name Renderbuffer; 30 | 31 | Renderbuffer createRenderbuffer(GLsizei width, GLsizei height, GLenum format); 32 | Renderbuffer createRenderbuffer(GLsizei width, GLsizei height, GLenum format, GLsizei samples); 33 | } 34 | 35 | #endif // INCLUDED_GL_FRAMEBUFFER 36 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/include/GL/scoped_name.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_SCOPED_NAME 5 | #define INCLUDED_GL_SCOPED_NAME 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include 12 | 13 | 14 | namespace GL 15 | { 16 | template 17 | class scoped_name : private Namespace 18 | { 19 | private: 20 | scoped_name(const scoped_name&); 21 | scoped_name& operator =(const scoped_name&); 22 | 23 | GLuint id; 24 | 25 | public: 26 | explicit scoped_name(GLuint id = 0U) 27 | : id(id) 28 | { 29 | } 30 | 31 | ~scoped_name() 32 | { 33 | if (h != 0U) 34 | close(h); 35 | } 36 | 37 | operator GLuint() const { return id; } 38 | 39 | unique_name& operator =(unique_name&& h) 40 | { 41 | swap(*this, h); 42 | return *this; 43 | } 44 | 45 | void reset(T unique_handle = 0U) 46 | { 47 | if (h != 0U) 48 | close(h); 49 | h = unique_handle; 50 | } 51 | 52 | T release() 53 | { 54 | T unique_handle = h; 55 | h = 0U; 56 | return unique_handle; 57 | } 58 | 59 | friend void swap(unique_name& a, unique_name& b) 60 | { 61 | using std::swap; 62 | swap(a.h, b.h); 63 | } 64 | }; 65 | } 66 | 67 | #endif // INCLUDED_GL_SCOPED_NAME 68 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/include/GL/texture.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_TEXTURE 5 | #define INCLUDED_GL_TEXTURE 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "unique_name.h" 12 | 13 | 14 | namespace GL 15 | { 16 | struct TextureObjectNamespace 17 | { 18 | static GLuint gen(); 19 | static void del(GLuint name); 20 | }; 21 | 22 | struct SamplerObjectNamespace 23 | { 24 | static GLuint gen(); 25 | static void del(GLuint name); 26 | }; 27 | 28 | typedef unique_name Texture; 29 | typedef unique_name Sampler; 30 | 31 | Texture createTexture1D(GLsizei width, GLint levels, GLenum format); 32 | 33 | Texture createTexture2D(GLsizei width, GLsizei height, GLint levels, GLenum format); 34 | 35 | Texture createTexture2DArray(GLsizei width, GLsizei height, GLint slices, GLint levels, GLenum format); 36 | 37 | Texture createTexture2DMS(GLsizei width, GLsizei height, GLenum format, GLsizei samples); 38 | 39 | Texture createTexture3D(GLsizei width, GLsizei height, GLsizei depth, GLint levels, GLenum format); 40 | 41 | Texture createTextureCube(GLsizei width, GLint levels, GLenum format); 42 | 43 | } 44 | 45 | #endif // INCLUDED_GL_TEXTURE 46 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/include/GL/transform_feedback.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_TRANSFORM_FEEDBACK 5 | #define INCLUDED_GL_TRANSFORM_FEEDBACK 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "unique_name.h" 12 | 13 | 14 | namespace GL 15 | { 16 | struct TransformFeedbackObjectNamespace 17 | { 18 | static GLuint gen(); 19 | static void del(GLuint name); 20 | }; 21 | 22 | typedef unique_name TransformFeedback; 23 | } 24 | 25 | #endif // INCLUDED_GL_TRANSFORM_FEEDBACK 26 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/include/GL/unique_name.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_UNIQUE_NAME 5 | #define INCLUDED_GL_UNIQUE_NAME 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include 12 | 13 | 14 | namespace GL 15 | { 16 | template 17 | class unique_name 18 | { 19 | private: 20 | GLuint name; 21 | 22 | public: 23 | unique_name(const unique_name&) = delete; 24 | unique_name& operator =(const unique_name&) = delete; 25 | 26 | unique_name() 27 | : name(Namespace::gen()) 28 | { 29 | } 30 | 31 | explicit unique_name(GLuint name) 32 | : name(name) 33 | { 34 | } 35 | 36 | unique_name(unique_name&& n) 37 | : name(n.name) 38 | { 39 | n.name = 0U; 40 | } 41 | 42 | ~unique_name() 43 | { 44 | if (name != 0U) 45 | Namespace::del(name); 46 | } 47 | 48 | operator GLuint() const { return name; } 49 | 50 | unique_name& operator =(unique_name&& n) 51 | { 52 | using std::swap; 53 | swap(this->name, n.name); 54 | return *this; 55 | } 56 | 57 | void reset(GLuint new_name = 0U) 58 | { 59 | if (name != 0U) 60 | Namespace::del(name); 61 | name = new_name; 62 | } 63 | 64 | GLuint release() 65 | { 66 | GLuint name = this->name; 67 | this->name = 0U; 68 | return name; 69 | } 70 | 71 | friend void swap(unique_name& a, unique_name& b) 72 | { 73 | using std::swap; 74 | swap(a.name, b.name); 75 | } 76 | }; 77 | } 78 | 79 | #endif // INCLUDED_GL_UNIQUE_NAME 80 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/include/GL/vertex_array.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_VERTEX_ARRAY 5 | #define INCLUDED_GL_VERTEX_ARRAY 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "unique_name.h" 12 | 13 | 14 | namespace GL 15 | { 16 | struct VertexArrayObjectNamespace 17 | { 18 | static GLuint gen(); 19 | static void del(GLuint name); 20 | }; 21 | 22 | typedef unique_name VertexArray; 23 | } 24 | 25 | #endif // INCLUDED_GL_VERTEX_ARRAY 26 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/source/buffer.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include "error.h" 5 | #include "buffer.h" 6 | 7 | 8 | namespace GL 9 | { 10 | GLuint BufferObjectNamespace::gen() 11 | { 12 | GLuint id; 13 | glGenBuffers(1, &id); 14 | checkError(); 15 | return id; 16 | } 17 | 18 | void BufferObjectNamespace::del(GLuint name) 19 | { 20 | glDeleteBuffers(1, &name); 21 | checkError(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/source/error.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include "error.h" 5 | 6 | 7 | namespace 8 | { 9 | const char* genErrorMessage(GLenum error) 10 | { 11 | switch (error) 12 | { 13 | case GL_INVALID_ENUM: 14 | return "GL_INVALID_ENUM"; 15 | case GL_INVALID_VALUE: 16 | return "GL_INVALID_VALUE"; 17 | case GL_INVALID_OPERATION: 18 | return "GL_INVALID_OPERATION"; 19 | case GL_INVALID_FRAMEBUFFER_OPERATION: 20 | return "GL_INVALID_FRAMEBUFFER_OPERATION"; 21 | 22 | } 23 | 24 | return "unknown error code"; 25 | } 26 | } 27 | 28 | namespace GL 29 | { 30 | error::error(GLenum error_code) 31 | : error_code(error_code) 32 | { 33 | } 34 | 35 | #if defined(_MSC_VER) && _MSC_VER <= 1800 36 | const char* error::what() const 37 | #else 38 | const char* error::what() const noexcept 39 | #endif 40 | { 41 | return genErrorMessage(error_code); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/source/event.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include "error.h" 5 | #include "event.h" 6 | 7 | 8 | namespace GL 9 | { 10 | GLuint QueryObjectNamespace::gen() 11 | { 12 | GLuint name; 13 | glGenQueries(1, &name); 14 | checkError(); 15 | return name; 16 | } 17 | 18 | void QueryObjectNamespace::del(GLuint name) 19 | { 20 | glDeleteQueries(1, &name); 21 | checkError(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/source/framebuffer.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include "error.h" 5 | #include "framebuffer.h" 6 | 7 | 8 | namespace GL 9 | { 10 | GLuint FramebufferObjectNamespace::gen() 11 | { 12 | GLuint id; 13 | glGenFramebuffers(1, &id); 14 | checkError(); 15 | return id; 16 | } 17 | 18 | void FramebufferObjectNamespace::del(GLuint name) 19 | { 20 | glDeleteFramebuffers(1, &name); 21 | checkError(); 22 | } 23 | 24 | 25 | GLuint RenderbufferObjectNamespace::gen() 26 | { 27 | GLuint id; 28 | glGenRenderbuffers(1, &id); 29 | checkError(); 30 | return id; 31 | } 32 | 33 | void RenderbufferObjectNamespace::del(GLuint name) 34 | { 35 | glDeleteRenderbuffers(1, &name); 36 | checkError(); 37 | } 38 | 39 | 40 | Renderbuffer createRenderbuffer(GLsizei width, GLsizei height, GLenum format) 41 | { 42 | Renderbuffer renderbuffer; 43 | glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); 44 | glRenderbufferStorage(GL_RENDERBUFFER, format, width, height); 45 | checkError(); 46 | return renderbuffer; 47 | } 48 | 49 | Renderbuffer createRenderbuffer(GLsizei width, GLsizei height, GLenum format, GLsizei samples) 50 | { 51 | Renderbuffer renderbuffer; 52 | glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); 53 | glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples, format, width, height); 54 | checkError(); 55 | return renderbuffer; 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/source/transform_feedback.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include "error.h" 5 | #include "transform_feedback.h" 6 | 7 | 8 | namespace GL 9 | { 10 | GLuint TransformFeedbackObjectNamespace::gen() 11 | { 12 | GLuint id; 13 | glGenTransformFeedbacks(1, &id); 14 | checkError(); 15 | return id; 16 | } 17 | 18 | void TransformFeedbackObjectNamespace::del(GLuint name) 19 | { 20 | glDeleteTransformFeedbacks(1, &name); 21 | checkError(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_core_tools/source/vertex_array.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include "error.h" 5 | #include "vertex_array.h" 6 | 7 | 8 | namespace GL 9 | { 10 | GLuint VertexArrayObjectNamespace::gen() 11 | { 12 | GLuint id; 13 | glGenVertexArrays(1, &id); 14 | checkError(); 15 | return id; 16 | } 17 | 18 | void VertexArrayObjectNamespace::del(GLuint name) 19 | { 20 | glDeleteVertexArrays(1, &name); 21 | checkError(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/build/cmake/glcore/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8) 2 | 3 | project(glcore) 4 | 5 | set(SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../source/win32/glcore") 6 | 7 | file(GLOB glcore_SOURCES "${SOURCE_DIR}/*.cpp") 8 | 9 | add_library(glcore STATIC ${glcore_SOURCES}) 10 | 11 | set(glcore_INCLUDE_DIRS ${INCLUDE_DIRS} CACHE INTERNAL "glcore include directories") 12 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/build/cmake/test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8) 2 | 3 | project(test) 4 | 5 | find_package(OpenGL REQUIRED) 6 | 7 | if (WIN32) 8 | add_subdirectory(${Win32_core_tools_ROOT}/build/cmake Win32_core_tools) 9 | add_definitions(-DGLCORE_STATIC) 10 | endif () 11 | 12 | add_subdirectory(../ GL_platform_tools) 13 | 14 | include_directories(${GL_platform_tools_INCLUDE_DIRS}) 15 | 16 | set(SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../test") 17 | 18 | add_executable(test ${SOURCE_DIR}/main.cpp) 19 | 20 | if (WIN32) 21 | target_link_libraries(test ${GL_platform_tools_LIBRARIES} Win32_core_tools) 22 | else () 23 | target_link_libraries(test ${GL_platform_tools_LIBRARIES}) 24 | endif () 25 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/include/GL/platform/Application.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_PLATFORM_APPLICATION 5 | #define INCLUDED_GL_PLATFORM_APPLICATION 6 | 7 | #pragma once 8 | 9 | #include "Renderer.h" 10 | 11 | 12 | #if defined(_WIN32) 13 | #include "../../../source/win32/Win32GLApplication.h" 14 | namespace GL 15 | { 16 | namespace platform 17 | { 18 | using Win32::GL::run; 19 | using Win32::GL::quit; 20 | } 21 | } 22 | #elif defined(__gnu_linux__) 23 | #include "../../../source/x11/X11GLApplication.h" 24 | namespace GL 25 | { 26 | namespace platform 27 | { 28 | using X11::GL::run; 29 | using X11::GL::quit; 30 | } 31 | } 32 | #else 33 | #error "platform not supported." 34 | #endif 35 | 36 | #endif // INCLUDED_GL_PLATFORM_APPLICATION 37 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/include/GL/platform/Context.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_PLATFORM_CONTEXT 5 | #define INCLUDED_GL_PLATFORM_CONTEXT 6 | 7 | #pragma once 8 | 9 | 10 | #if defined(_WIN32) 11 | #include "../../../source/win32/Win32GLContext.h" 12 | namespace GL 13 | { 14 | namespace platform 15 | { 16 | using Win32::GL::Context; 17 | using Win32::GL::context_scope; 18 | } 19 | } 20 | #elif defined(__gnu_linux__) 21 | #include "../../../source/x11/X11GLContext.h" 22 | namespace GL 23 | { 24 | namespace platform 25 | { 26 | using X11::GL::Context; 27 | using X11::GL::context_scope; 28 | } 29 | } 30 | #else 31 | #error "platform not supported." 32 | #endif 33 | 34 | #endif // INCLUDED_GL_PLATFORM_CONTEXT 35 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/include/GL/platform/DefaultDisplayHandler.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_PLATFORM_DEFAULT_DISPLAY_HANDLER 5 | #define INCLUDED_GL_PLATFORM_DEFAULT_DISPLAY_HANDLER 6 | 7 | #pragma once 8 | 9 | #include "DisplayHandler.h" 10 | 11 | 12 | namespace GL 13 | { 14 | namespace platform 15 | { 16 | class DefaultDisplayHandler : public virtual DisplayHandler 17 | { 18 | protected: 19 | DefaultDisplayHandler() {} 20 | DefaultDisplayHandler(const DefaultDisplayHandler&) : DisplayHandler() {} 21 | DefaultDisplayHandler& operator =(const DefaultDisplayHandler&) { return *this; } 22 | ~DefaultDisplayHandler() {} 23 | public: 24 | void close(); 25 | void destroy(); 26 | 27 | void move(int x, int y); 28 | void resize(int width, int height); 29 | }; 30 | } 31 | } 32 | 33 | #endif // INCLUDED_GL_PLATFORM_DEFAULT_DISPLAY_HANDLER 34 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/include/GL/platform/DisplayHandler.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_PLATFORM_DISPLAY_HANDLER 5 | #define INCLUDED_GL_PLATFORM_DISPLAY_HANDLER 6 | 7 | #pragma once 8 | 9 | #include "interface.h" 10 | 11 | 12 | namespace GL 13 | { 14 | namespace platform 15 | { 16 | class INTERFACE DisplayHandler 17 | { 18 | protected: 19 | DisplayHandler() {} 20 | DisplayHandler(const DisplayHandler&) {} 21 | DisplayHandler& operator =(const DisplayHandler&) { return *this; } 22 | ~DisplayHandler() {} 23 | public: 24 | virtual void close() = 0; 25 | virtual void destroy() = 0; 26 | 27 | virtual void move(int x, int y) = 0; 28 | virtual void resize(int width, int height) = 0; 29 | }; 30 | } 31 | } 32 | 33 | #endif // INCLUDED_GL_PLATFORM_DISPLAY_HANDLER 34 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/include/GL/platform/Renderer.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_PLATFORM_RENDERER 5 | #define INCLUDED_GL_PLATFORM_RENDERER 6 | 7 | #pragma once 8 | 9 | #include "interface.h" 10 | 11 | 12 | namespace GL 13 | { 14 | namespace platform 15 | { 16 | class INTERFACE Renderer 17 | { 18 | protected: 19 | Renderer() {} 20 | Renderer(const Renderer&) {} 21 | Renderer& operator =(const Renderer&) { return *this; } 22 | ~Renderer() {} 23 | public: 24 | virtual void render() = 0; 25 | }; 26 | } 27 | } 28 | 29 | #endif // INCLUDED_GL_PLATFORM_RENDERER 30 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/include/GL/platform/Window.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_PLATFORM_WINDOW 5 | #define INCLUDED_GL_PLATFORM_WINDOW 6 | 7 | #pragma once 8 | 9 | #include "DisplayHandler.h" 10 | #include "InputHandler.h" 11 | 12 | 13 | #if defined(_WIN32) 14 | #include "../../../source/win32/Win32GLWindow.h" 15 | namespace GL 16 | { 17 | namespace platform 18 | { 19 | using Win32::GL::Window; 20 | } 21 | } 22 | #elif defined(__gnu_linux__) 23 | #include "../../../source/x11/X11GLWindow.h" 24 | namespace GL 25 | { 26 | namespace platform 27 | { 28 | using X11::GL::Window; 29 | } 30 | } 31 | #else 32 | #error "platform not supported." 33 | #endif 34 | 35 | #endif // INCLUDED_GL_PLATFORM_WINDOW 36 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/include/GL/platform/interface.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_GL_PLATFORM_INTERFACE 5 | #define INCLUDED_GL_PLATFORM_INTERFACE 6 | 7 | #pragma once 8 | 9 | 10 | #ifdef _MSC_VER 11 | #define INTERFACE __declspec(novtable) 12 | #else 13 | #define INTERFACE 14 | #endif 15 | 16 | 17 | #endif // INCLUDED_GL_PLATFORM_INTERFACE 18 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/DefaultDisplayHandler.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include 5 | #include 6 | 7 | 8 | namespace GL 9 | { 10 | namespace platform 11 | { 12 | void DefaultDisplayHandler::close() 13 | { 14 | GL::platform::quit(); 15 | } 16 | 17 | void DefaultDisplayHandler::destroy() 18 | { 19 | } 20 | 21 | void DefaultDisplayHandler::move(int x, int y) 22 | { 23 | } 24 | 25 | void DefaultDisplayHandler::resize(int width, int height) 26 | { 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/egl/include/glcore.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_EGL_GLCORE 5 | #define INCLUDED_EGL_GLCORE 6 | 7 | #pragma once 8 | 9 | 10 | #ifdef __cplusplus 11 | extern "C" 12 | { 13 | #endif 14 | 15 | struct glcoreContext; 16 | 17 | const glcoreContext* APIENTRY glcoreContextInit(); 18 | void APIENTRY glcoreContextDestroy(const glcoreContext* ctx); 19 | void APIENTRY glcoreContextMakeCurrent(const glcoreContext* ctx); 20 | const glcoreContext* APIENTRY glcoreContextGetCurrent(); 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | 26 | #endif // INCLUDED_EGL_GLCORE 27 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/win32/Win32GLApplication.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_GL_APPLICATION 5 | #define INCLUDED_WIN32_GL_APPLICATION 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include 12 | #include 13 | 14 | 15 | namespace Win32 16 | { 17 | namespace GL 18 | { 19 | void run(::GL::platform::Renderer& renderer); 20 | void run(::GL::platform::Renderer& renderer, ::GL::platform::ConsoleHandler* console_handler); 21 | 22 | void quit(); 23 | } 24 | } 25 | 26 | #endif // INCLUDED_WIN32_GL_APPLICATION 27 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/win32/glcore/DllMain.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include 5 | 6 | 7 | BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) 8 | { 9 | return TRUE; 10 | } 11 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/win32/include/win32/glcore.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_GLCORE 5 | #define INCLUDED_WIN32_GLCORE 6 | 7 | #pragma once 8 | 9 | 10 | #ifndef GLCOREAPI 11 | #ifdef GLCORE_STATIC 12 | #define GLCOREAPI 13 | #else 14 | #define GLCOREAPI __declspec(dllimport) 15 | #endif 16 | #endif 17 | 18 | #ifdef __cplusplus 19 | extern "C" 20 | { 21 | #endif 22 | 23 | struct glcoreContext; 24 | 25 | GLCOREAPI const glcoreContext* APIENTRY glcoreContextInit(); 26 | GLCOREAPI void APIENTRY glcoreContextDestroy(const glcoreContext* ctx); 27 | GLCOREAPI void APIENTRY glcoreContextMakeCurrent(const glcoreContext* ctx); 28 | GLCOREAPI const glcoreContext* APIENTRY glcoreContextGetCurrent(); 29 | 30 | #ifdef __cplusplus 31 | } 32 | #endif 33 | 34 | #endif // INCLUDED_WIN32_GLCORE 35 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/x11/X11Display.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include "X11Display.h" 5 | 6 | 7 | namespace X11 8 | { 9 | Display openDisplay() 10 | { 11 | return XOpenDisplay(nullptr); 12 | } 13 | 14 | Display::~Display() 15 | { 16 | XCloseDisplay(display); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/x11/X11Display.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_PLATFORM_X11_DISPLAY 5 | #define INCLUDED_PLATFORM_X11_DISPLAY 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "platform.h" 12 | 13 | 14 | namespace X11 15 | { 16 | class Display 17 | { 18 | private: 19 | ::Display* display; 20 | 21 | public: 22 | Display(const Display&) = delete; 23 | Display& operator =(const Display&) = delete; 24 | 25 | Display(::Display* display) 26 | : display(display) 27 | { 28 | } 29 | 30 | Display(Display&& d) 31 | : display(d.display) 32 | { 33 | d.display = 0; 34 | } 35 | 36 | ~Display(); 37 | 38 | Display& operator =(Display&& d) 39 | { 40 | using std::swap; 41 | swap(display, d.display); 42 | return *this; 43 | } 44 | 45 | operator ::Display*() const { return display; } 46 | }; 47 | 48 | Display openDisplay(); 49 | } 50 | 51 | #endif // INCLUDED_PLATFORM_X11_DISPLAY 52 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/x11/X11GLApplication.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include "X11Display.h" 9 | #include "X11GLWindow.h" 10 | #include "X11GLApplication.h" 11 | 12 | 13 | namespace 14 | { 15 | std::atomic run_mainloop; 16 | } 17 | 18 | namespace X11 19 | { 20 | namespace GL 21 | { 22 | X11::Display display = X11::openDisplay(); 23 | extern std::unordered_map< ::Window, X11::GL::Window*> window_map; 24 | 25 | void run(::GL::platform::Renderer& renderer) 26 | { 27 | run(renderer, nullptr); 28 | } 29 | 30 | void run(::GL::platform::Renderer& renderer, ::GL::platform::ConsoleHandler* console_handler) 31 | { 32 | XEvent event; 33 | run_mainloop = true; 34 | 35 | while (run_mainloop) 36 | { 37 | while (XPending(display) > 0) 38 | { 39 | XNextEvent(display, &event); 40 | 41 | if (X11::GL::Window* window = window_map[event.xany.window]) 42 | window->handleEvent(event); 43 | } 44 | 45 | renderer.render(); 46 | } 47 | } 48 | 49 | void quit() 50 | { 51 | run_mainloop = false; 52 | } 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/x11/X11GLApplication.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_X11_GL_APPLICATION 5 | #define INCLUDED_X11_GL_APPLICATION 6 | 7 | #pragma once 8 | 9 | #include "platform.h" 10 | 11 | #include 12 | #include 13 | 14 | 15 | namespace X11 16 | { 17 | namespace GL 18 | { 19 | void run(::GL::platform::Renderer& renderer); 20 | void run(::GL::platform::Renderer& renderer, ::GL::platform::ConsoleHandler* console_handler); 21 | 22 | void quit(); 23 | } 24 | } 25 | 26 | #endif // INCLUDED_X11_GL_APPLICATION 27 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/x11/X11GLContext.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include 5 | #include 6 | 7 | #include "X11GLContext.h" 8 | 9 | 10 | namespace X11 11 | { 12 | namespace GL 13 | { 14 | Context createContext(::Display* display, GLXFBConfig fb_config, int version_major, int version_minor, bool debug) 15 | { 16 | static struct glx_ext_loader 17 | { 18 | PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribs; 19 | 20 | glx_ext_loader() 21 | : glXCreateContextAttribs(reinterpret_cast(glXGetProcAddress(reinterpret_cast("glXCreateContextAttribsARB")))) 22 | { 23 | if (glXCreateContextAttribs == nullptr) 24 | throw std::runtime_error("glXCreateContextAttribsARB() not supported."); 25 | } 26 | } glx_ext; 27 | 28 | static const int attribs[] = { 29 | GLX_CONTEXT_MAJOR_VERSION_ARB, version_major, 30 | GLX_CONTEXT_MINOR_VERSION_ARB, version_minor, 31 | GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB, 32 | GLX_CONTEXT_FLAGS_ARB, debug ? GLX_CONTEXT_DEBUG_BIT_ARB : 0, 33 | None 34 | }; 35 | 36 | GLXContext context = glx_ext.glXCreateContextAttribs(display, fb_config, 0, True, attribs); 37 | 38 | if (context == 0) 39 | throw std::runtime_error("glXCreateContextAttribs() failed"); 40 | 41 | return Context(display, context); 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/x11/platform.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_PLATFORM_X11 5 | #define INCLUDED_PLATFORM_X11 6 | 7 | #pragma once 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #define GLX_GLXEXT_LEGACY 15 | #include 16 | 17 | #endif // INCLUDED_PLATFORM_X11 18 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/GL_platform_tools/source/x11/x11_ptr.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_PLATFORM_X11_PTR 5 | #define INCLUDED_PLATFORM_X11_PTR 6 | 7 | #pragma once 8 | 9 | #include "platform.h" 10 | 11 | 12 | namespace X11 13 | { 14 | struct deleter 15 | { 16 | void operator ()(void* ptr) const 17 | { 18 | XFree(ptr); 19 | } 20 | }; 21 | } 22 | 23 | #endif // INCLUDED_PLATFORM_X11_PTR 24 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/build/cmake/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.16) 2 | 3 | project(Win32_core_tools) 4 | 5 | set(INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../include/") 6 | set(SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../source/") 7 | 8 | 9 | file(GLOB Win32_core_tools_SOURCES "${SOURCE_DIR}/*.cpp") 10 | 11 | include_directories(${GL_platform_tools_INCLUDE_DIRS} ${INCLUDE_DIR}Win32) 12 | 13 | add_library(Win32_core_tools STATIC ${Win32_core_tools_SOURCES}) 14 | 15 | set(Win32_core_tools_INCLUDE_DIRS ${INCLUDE_DIR} CACHE INTERNAL "Win32 core tools include directories") 16 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/com_error.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_COM_ERROR 5 | #define INCLUDED_WIN32_COM_ERROR 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "platform.h" 12 | 13 | 14 | namespace COM 15 | { 16 | class error 17 | { 18 | private: 19 | HRESULT hresult; 20 | public: 21 | explicit error(HRESULT hresult) 22 | : hresult(hresult) 23 | { 24 | } 25 | 26 | std::string message() const; 27 | }; 28 | 29 | inline void checkError(HRESULT hresult) 30 | { 31 | if (FAILED(hresult)) 32 | throw error(hresult); 33 | } 34 | } 35 | 36 | using COM::checkError; 37 | 38 | #endif // INCLUDED_WIN32_COM_ERROR 39 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/com_utility.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_COM_UTILITY 5 | #define INCLUDED_WIN32_COM_UTILITY 6 | 7 | #pragma once 8 | 9 | #include "platform.h" 10 | #include "com_error.h" 11 | #include "com_ptr.h" 12 | 13 | 14 | namespace COM 15 | { 16 | template 17 | inline com_ptr QueryInterface(IUnknown* obj) 18 | { 19 | void* p; 20 | checkError(obj->GetParent(getIID(), &p)); 21 | return make_com_ptr(static_cast(p)); 22 | } 23 | } 24 | 25 | #endif // INCLUDED_WIN32_COM_UTILITY 26 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/error.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_ERROR 5 | #define INCLUDED_WIN32_ERROR 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "platform.h" 12 | 13 | 14 | namespace Win32 15 | { 16 | class error 17 | { 18 | private: 19 | DWORD error_code; 20 | public: 21 | explicit error(DWORD error_code) 22 | : error_code(error_code) 23 | { 24 | } 25 | 26 | std::string message() const; 27 | }; 28 | 29 | inline void checkError(bool condition) 30 | { 31 | if (condition) 32 | throw error(GetLastError()); 33 | } 34 | } 35 | 36 | #endif // INCLUDED_WIN32_ERROR 37 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/event.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_EVENT_HANDLE 5 | #define INCLUDED_WIN32_EVENT_HANDLE 6 | 7 | #pragma once 8 | 9 | #include "unique_handle.h" 10 | #include "scoped_handle.h" 11 | 12 | 13 | namespace Win32 14 | { 15 | typedef scoped_handle scoped_hevent; 16 | typedef unique_handle unique_hevent; 17 | 18 | unique_hevent createEvent(); 19 | } 20 | 21 | #endif // INCLUDED_WIN32_EVENT_HANDLE 22 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/handle_deleter.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_HANDLE_DELETER 5 | #define INCLUDED_WIN32_HANDLE_DELETER 6 | 7 | #pragma once 8 | 9 | #include "platform.h" 10 | 11 | 12 | namespace Win32 13 | { 14 | struct CloseHandleDeleter 15 | { 16 | void operator ()(HANDLE h) const 17 | { 18 | CloseHandle(h); 19 | } 20 | }; 21 | } 22 | 23 | #endif // INCLUDED_WIN32_HANDLE_DELETER 24 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/memory.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_MEMORY 5 | #define INCLUDED_WIN32_MEMORY 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "unique_handle.h" 12 | #include "scoped_handle.h" 13 | 14 | 15 | namespace Win32 16 | { 17 | struct DefaultHeapDeleter 18 | { 19 | void operator ()(void* p) const 20 | { 21 | HeapFree(GetProcessHeap(), 0U, p); 22 | } 23 | }; 24 | 25 | template 26 | using unique_heap_ptr = std::unique_ptr; 27 | 28 | 29 | struct GlobalFreeDeleter 30 | { 31 | void operator ()(HGLOBAL hmem) const 32 | { 33 | GlobalFree(hmem); 34 | } 35 | }; 36 | 37 | using scoped_hglobal = scoped_handle; 38 | using unique_hglobal = unique_handle; 39 | 40 | 41 | struct LocalFreeDeleter 42 | { 43 | void operator ()(HLOCAL hmem) const 44 | { 45 | LocalFree(hmem); 46 | } 47 | }; 48 | 49 | using scoped_hlocal = scoped_handle; 50 | using unique_hlocal = unique_handle; 51 | } 52 | 53 | #endif // INCLUDED_WIN32_MODULE_HANDLE 54 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/module_handle.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_MODULE_HANDLE 5 | #define INCLUDED_WIN32_MODULE_HANDLE 6 | 7 | #pragma once 8 | 9 | #include "unique_handle.h" 10 | #include "scoped_handle.h" 11 | 12 | 13 | namespace Win32 14 | { 15 | struct FreeLibraryDeleter 16 | { 17 | void operator ()(HMODULE module) const 18 | { 19 | FreeLibrary(module); 20 | } 21 | }; 22 | 23 | typedef scoped_handle scoped_hmodule; 24 | typedef unique_handle unique_hmodule; 25 | } 26 | 27 | #endif // INCLUDED_WIN32_MODULE_HANDLE 28 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/platform.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_PLATFORM 5 | #define INCLUDED_WIN32_PLATFORM 6 | 7 | #pragma once 8 | 9 | #ifndef WIN32_LEAN_AND_MEAN 10 | #define WIN32_LEAN_AND_MEAN 11 | #endif 12 | #ifndef NOMINMAX 13 | #define NOMINMAX 14 | #endif 15 | #include 16 | 17 | #endif // INCLUDED_WIN32_PLATFORM 18 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/unicode.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_UNICODE 5 | #define INCLUDED_WIN32_UNICODE 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | #include "platform.h" 12 | 13 | 14 | namespace Win32 15 | { 16 | std::basic_string widen(const char* string, size_t length); 17 | std::basic_string widen(const char* string); 18 | std::basic_string widen(const std::string& string); 19 | 20 | std::string narrow(const WCHAR* string, size_t length); 21 | std::string narrow(const WCHAR* string); 22 | std::string narrow(const std::basic_string& string); 23 | } 24 | 25 | using Win32::widen; 26 | using Win32::narrow; 27 | 28 | #endif // INCLUDED_WIN32_UNICODE 29 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/include/win32/window_handle.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #ifndef INCLUDED_WIN32_WINDOW_HANDLE 5 | #define INCLUDED_WIN32_WINDOW_HANDLE 6 | 7 | #pragma once 8 | 9 | #include "unique_handle.h" 10 | #include "scoped_handle.h" 11 | 12 | 13 | namespace Win32 14 | { 15 | struct DestroyWindowDeleter 16 | { 17 | void operator ()(HWND hwnd) const 18 | { 19 | DestroyWindow(hwnd); 20 | } 21 | }; 22 | 23 | typedef scoped_handle scoped_hwnd; 24 | typedef unique_handle unique_hwnd; 25 | } 26 | 27 | #endif // INCLUDED_WIN32_WINDOW_HANDLE 28 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/source/error.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include "memory.h" 5 | 6 | #include "unicode.h" 7 | 8 | #include "error.h" 9 | #include "com_error.h" 10 | 11 | 12 | namespace 13 | { 14 | std::wstring formatMessage(DWORD error) 15 | { 16 | WCHAR* buffer; 17 | FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, nullptr, error, 0, reinterpret_cast(&buffer), 0, nullptr); 18 | Win32::unique_heap_ptr msg(buffer); 19 | return msg.get(); 20 | } 21 | } 22 | 23 | namespace Win32 24 | { 25 | std::string error::message() const 26 | { 27 | return narrow(formatMessage(error_code)); 28 | } 29 | } 30 | 31 | namespace COM 32 | { 33 | std::string error::message() const 34 | { 35 | return narrow(formatMessage(hresult)); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/Win32_core_tools/source/event.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | #include "error.h" 5 | #include "event.h" 6 | 7 | 8 | namespace Win32 9 | { 10 | unique_hevent createEvent() 11 | { 12 | HANDLE h = CreateEventW(nullptr, FALSE, FALSE, nullptr); 13 | if (h == 0) 14 | throw error(GetLastError()); 15 | return unique_hevent(h); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_real_time_viewer/dependencies/glm/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | T const a = asin(sqrt(x.x * x.x + x.y * x.y + x.z * x.z)) * static_cast(2); 11 | if(x.w < static_cast(0)) 12 | return pi() * static_cast(2) - a; 13 | return a; 14 | } 15 | 16 | return acos(x.w) * static_cast(2); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER vec<3, T, Q> axis(qua const& x) 21 | { 22 | T const tmp1 = static_cast(1) - x.w * x.w; 23 | if(tmp1 <= static_cast(0)) 24 | return vec<3, T, Q>(0, 0, 1); 25 | T const tmp2 = static_cast(1) / sqrt(tmp1); 26 | return vec<3, T, Q>(x.x * tmp2, x.y * tmp2, x.z * tmp2); 27 | } 28 | 29 | template 30 | GLM_FUNC_QUALIFIER qua angleAxis(T const& angle, vec<3, T, Q> const& v) 31 | { 32 | T const a(angle); 33 | T const s = glm::sin(a * static_cast(0.5)); 34 | 35 | return qua(glm::cos(a * static_cast(0.5)), v * s); 36 | } 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/ext/scalar_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_real_time_viewer/dependencies/glm/glm/ext/scalar_packing.inl -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/ext/vector_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_real_time_viewer/dependencies/glm/glm/ext/vector_packing.inl -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtc/integer.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_integer 2 | /// @file glm/gtc/integer.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_integer (dependence) 6 | /// 7 | /// @defgroup gtc_integer GLM_GTC_integer 8 | /// @ingroup gtc 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 | #include "../common.hpp" 20 | #include "../integer.hpp" 21 | #include "../exponential.hpp" 22 | #include "../ext/scalar_common.hpp" 23 | #include "../ext/vector_common.hpp" 24 | #include 25 | 26 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 27 | # pragma message("GLM: GLM_GTC_integer extension included") 28 | #endif 29 | 30 | namespace glm 31 | { 32 | /// @addtogroup gtc_integer 33 | /// @{ 34 | 35 | /// Returns the log2 of x for integer values. Usefull to compute mipmap count from the texture size. 36 | /// @see gtc_integer 37 | template 38 | GLM_FUNC_DECL genIUType log2(genIUType x); 39 | 40 | /// @} 41 | } //namespace glm 42 | 43 | #include "integer.inl" 44 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtc/integer.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_integer 2 | 3 | namespace glm{ 4 | namespace detail 5 | { 6 | template 7 | struct compute_log2 8 | { 9 | GLM_FUNC_QUALIFIER static vec call(vec const& v) 10 | { 11 | //Equivalent to return findMSB(vec); but save one function call in ASM with VC 12 | //return findMSB(vec); 13 | return vec(detail::compute_findMSB_vec::call(v)); 14 | } 15 | }; 16 | 17 | # if GLM_HAS_BITSCAN_WINDOWS 18 | template 19 | struct compute_log2<4, int, Q, false, Aligned> 20 | { 21 | GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v) 22 | { 23 | vec<4, int, Q> Result; 24 | _BitScanReverse(reinterpret_cast(&Result.x), v.x); 25 | _BitScanReverse(reinterpret_cast(&Result.y), v.y); 26 | _BitScanReverse(reinterpret_cast(&Result.z), v.z); 27 | _BitScanReverse(reinterpret_cast(&Result.w), v.w); 28 | return Result; 29 | } 30 | }; 31 | # endif//GLM_HAS_BITSCAN_WINDOWS 32 | }//namespace detail 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtc/matrix_transform.inl: -------------------------------------------------------------------------------- 1 | #include "../geometric.hpp" 2 | #include "../trigonometric.hpp" 3 | #include "../matrix.hpp" 4 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_real_time_viewer/dependencies/glm/glm/gtc/quaternion_simd.inl -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtc/reciprocal.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_reciprocal 2 | /// @file glm/gtc/reciprocal.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_reciprocal GLM_GTC_reciprocal 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Define secant, cosecant and cotangent functions. 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_GTC_reciprocal extension included") 20 | #endif 21 | 22 | #include "../ext/scalar_reciprocal.hpp" 23 | #include "../ext/vector_reciprocal.hpp" 24 | 25 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_real_time_viewer/dependencies/glm/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | 3 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtx/string_cast.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_string_cast 2 | /// @file glm/gtx/string_cast.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_integer (dependence) 6 | /// @see gtx_quaternion (dependence) 7 | /// 8 | /// @defgroup gtx_string_cast GLM_GTX_string_cast 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Setup strings for GLM type values 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/type_precision.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | #include "../gtx/dual_quaternion.hpp" 22 | #include 23 | #include 24 | 25 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 26 | # ifndef GLM_ENABLE_EXPERIMENTAL 27 | # pragma message("GLM: GLM_GTX_string_cast is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 28 | # else 29 | # pragma message("GLM: GLM_GTX_string_cast extension included") 30 | # endif 31 | #endif 32 | 33 | namespace glm 34 | { 35 | /// @addtogroup gtx_string_cast 36 | /// @{ 37 | 38 | /// Create a string from a GLM vector or matrix typed variable. 39 | /// @see gtx_string_cast extension. 40 | template 41 | GLM_FUNC_DECL std::string to_string(genType const& x); 42 | 43 | /// @} 44 | }//namespace glm 45 | 46 | #include "string_cast.inl" 47 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/glm/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/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 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/tensorrt/NOTICE: -------------------------------------------------------------------------------- 1 | TensorRT Open Source Software 2 | Copyright (c) 2021, NVIDIA CORPORATION. 3 | 4 | This product includes software developed at 5 | NVIDIA CORPORATION (https://www.nvidia.com/). 6 | 7 | This software contains code derived by Soumith Chintala. 8 | BSD 3-Clause License (https://github.com/pytorch/vision/blob/master/LICENSE) 9 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/tensorrt/VERSION: -------------------------------------------------------------------------------- 1 | 8.0.1.6 2 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/dependencies/tensorrt/samples/common/logger.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | #ifndef LOGGER_H 18 | #define LOGGER_H 19 | 20 | #include "logging.h" 21 | 22 | class SampleErrorRecorder; 23 | extern SampleErrorRecorder gRecorder; 24 | namespace sample 25 | { 26 | extern Logger gLogger; 27 | extern LogStreamConsumer gLogVerbose; 28 | extern LogStreamConsumer gLogInfo; 29 | extern LogStreamConsumer gLogWarning; 30 | extern LogStreamConsumer gLogError; 31 | extern LogStreamConsumer gLogFatal; 32 | 33 | void setReportableSeverity(Logger::Severity severity); 34 | } // namespace sample 35 | 36 | #endif // LOGGER_H 37 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/include/basicbuffermanager.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef NRREALTIME_BASICBUFFERMANAGER_H 3 | #define NRREALTIME_BASICBUFFERMANAGER_H 4 | 5 | #pragma once 6 | 7 | #include "buffermanager.h" 8 | 9 | /** 10 | * @brief Simple BufferManager with a single array and surface as buffer. 11 | * Used for profiling and debugging (because of NSight profiling issues with cuda_gl_interop) 12 | */ 13 | class BasicBufferManager : public BufferManager 14 | { 15 | private: 16 | bool initialized = false; 17 | 18 | public: 19 | BasicBufferManager() {}; 20 | ~BasicBufferManager(); 21 | 22 | bool init(unsigned int width, unsigned int height) override; 23 | void resize(unsigned int width, unsigned int height) override; 24 | 25 | void clear() override; 26 | }; 27 | 28 | #endif -------------------------------------------------------------------------------- /adanerf_real_time_viewer/include/buffermanager.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef NRREALTIME_BUFFERMANAGER_H 3 | #define NRREALTIME_BUFFERMANAGER_H 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include 10 | 11 | class BufferManager 12 | { 13 | protected: 14 | cudaArray* d_curr_buffer = nullptr; 15 | cudaSurfaceObject_t d_curr_buffer_surf = 0; 16 | 17 | unsigned int width = 0; 18 | unsigned int height = 0; 19 | 20 | public: 21 | BufferManager() {}; 22 | virtual ~BufferManager() {}; 23 | 24 | virtual bool init(unsigned int width, unsigned int height) = 0; 25 | virtual void resize(unsigned int width, unsigned int height) = 0; 26 | 27 | virtual unsigned int swap() { return 0; }; 28 | virtual void blit(unsigned int, unsigned int) {}; 29 | virtual void clear() {}; 30 | virtual void map() {}; 31 | virtual void unmap() {}; 32 | 33 | cudaArray* getCurrentBuffer() { return d_curr_buffer; } 34 | cudaSurfaceObject_t getCurrentBufferSurface() { return d_curr_buffer_surf; } 35 | }; 36 | 37 | #endif -------------------------------------------------------------------------------- /adanerf_real_time_viewer/include/encoding.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef NRREALTIME_ENCODING_H 3 | #define NRREALTIME_ENCODING_H 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | class Encoding 11 | { 12 | private: 13 | std::vector pos_freq_bands; 14 | std::vector dir_freq_bands; 15 | std::vector b; 16 | 17 | int num_pos_freqs; 18 | int num_dir_freqs; 19 | 20 | int additional_samples = 0; 21 | 22 | public: 23 | std::string type; 24 | float* d_pos_freq_bands; 25 | float* d_dir_freq_bands; 26 | 27 | 28 | Encoding(); 29 | ~Encoding(); 30 | 31 | bool load(std::string type_, int num_pos_freqs_, int num_dir_freqs_, int add_samples=0); 32 | 33 | int getNumPosFreqs() { return (type != "none") * num_pos_freqs; } 34 | int getNumDirFreqs() { return (type != "none") * num_dir_freqs; } 35 | int getNumFeatures() { return 3 + 3 * getNumPosFreqs() * 2 + 3 + 3 * getNumDirFreqs() * 2 + additional_samples * ( 3 + 3 * getNumPosFreqs() * 2); } 36 | 37 | 38 | }; 39 | 40 | #endif 41 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/include/helper.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef NRREALTIME_HELPER_H 3 | #define NRREALTIME_HELPER_H 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | #ifndef PATH_SEPARATOR 11 | #if defined(WIN32) || defined(_WIN32) 12 | #define PATH_SEPARATOR "\\" 13 | #else 14 | #define PATH_SEPARATOR "/" 15 | #endif 16 | #endif 17 | 18 | struct InferDeleter 19 | { 20 | template 21 | void operator()(T* obj) const 22 | { 23 | if (obj) 24 | { 25 | obj->destroy(); 26 | } 27 | } 28 | }; 29 | 30 | template 31 | using IGUniquePtr = std::unique_ptr; 32 | 33 | #endif -------------------------------------------------------------------------------- /adanerf_real_time_viewer/include/inputhandler.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef NRREALTIME_INPUTHANDLER_H 3 | #define NRREALTIME_INPUTHANDLER_H 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include "GL/platform/InputHandler.h" 10 | 11 | 12 | class NeuralRenderer; 13 | class Camera; 14 | 15 | class InputHandler : public virtual GL::platform::KeyboardInputHandler, public virtual GL::platform::MouseInputHandler 16 | { 17 | public: 18 | InputHandler(NeuralRenderer& renderer, Camera& camera); 19 | InputHandler() = default; 20 | 21 | InputHandler(const InputHandler&) = delete; 22 | InputHandler& operator=(const InputHandler&) = delete; 23 | 24 | void keyDown(GL::platform::Key key); 25 | void keyUp(GL::platform::Key key); 26 | void buttonDown(GL::platform::Button button, int x, int y); 27 | void buttonUp(GL::platform::Button button, int x, int y); 28 | void mouseMove(int x, int y); 29 | void mouseWheel(int delta); 30 | 31 | private: 32 | NeuralRenderer& renderer; 33 | Camera& camera; 34 | 35 | bool mouse_left; 36 | glm::ivec2 last_mouse_pos; 37 | }; 38 | 39 | 40 | #endif -------------------------------------------------------------------------------- /adanerf_real_time_viewer/include/interoprenderbuffer.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef NRREALTIME_INTEROPRENDERBUFFER_H 3 | #define NRREALTIME_INTEROPRENDERBUFFER_H 4 | 5 | #pragma once 6 | 7 | #include "buffermanager.h" 8 | 9 | #include 10 | #include 11 | 12 | #include 13 | 14 | class InteropRenderbuffer : public BufferManager 15 | { 16 | private: 17 | GLuint fb[2]; 18 | GLuint rb[2]; 19 | 20 | cudaGraphicsResource* d_fb_res[2]; 21 | cudaArray* d_fb_ar[2]; 22 | cudaSurfaceObject_t d_fb_surf[2]; 23 | 24 | unsigned int idx; 25 | 26 | std::vector > inference_mappings; 27 | 28 | public: 29 | InteropRenderbuffer(); 30 | ~InteropRenderbuffer(); 31 | 32 | bool init(unsigned int width, unsigned int height) override; 33 | void resize(unsigned int width, unsigned int height) override; 34 | unsigned int swap() override; 35 | void blit(unsigned int target_width, unsigned int target_height) override; 36 | void clear() override; 37 | void map() override; 38 | void unmap() override; 39 | }; 40 | 41 | #endif -------------------------------------------------------------------------------- /adanerf_real_time_viewer/include/settings.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef NRREALTIME_SETTINGS_H 3 | #define NRREALTIME_SETTINGS_H 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | #include "argparse/argparse.hpp" 11 | 12 | class Settings 13 | { 14 | private: 15 | 16 | public: 17 | Settings(); 18 | ~Settings(); 19 | 20 | void init(argparse::ArgumentParser& program); 21 | 22 | // Config properties 23 | std::string model_path; 24 | 25 | unsigned int width; 26 | unsigned int height; 27 | unsigned int total_size; 28 | unsigned int window_width; 29 | unsigned int window_height; 30 | unsigned int batch_size; 31 | 32 | bool write_images; 33 | bool is_debug; 34 | }; 35 | 36 | #endif -------------------------------------------------------------------------------- /adanerf_real_time_viewer/sample/dataset_info.txt: -------------------------------------------------------------------------------- 1 | view_cell_center = [2.25, 7.75, 1.5] 2 | view_cell_size = [1.5, 1.5, 0.4] 3 | depth_range = [-0.42766728550195693, 7.07244257926941] 4 | fov = 1.5271797180175781 5 | focal = 417.8384990266475 6 | camera_scale = 1.0 7 | max_depth = 8.704841423034669 8 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/sample/model0.onnx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_real_time_viewer/sample/model0.onnx -------------------------------------------------------------------------------- /adanerf_real_time_viewer/sample/model1.onnx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_real_time_viewer/sample/model1.onnx -------------------------------------------------------------------------------- /adanerf_real_time_viewer/sample_pavillon_16/config.ini: -------------------------------------------------------------------------------- 1 | posEnc = [nerf, nerf] 2 | posEncArgs = [10-4, 10-4] 3 | inFeatures = [SpherePosDir, RayMarchFromPoses] 4 | outFeatures = [Raw, RGBARayMarch] 5 | inferenceChunkSize = 8192 6 | 7 | rayMarchSampler = [none, FromClassifiedDepthAdaptive] 8 | rayMarchNormalization = [InverseSqrtDistCentered, InverseSqrtDistCentered] 9 | numRaymarchSamples = [16, 16] 10 | rayMarchSamplingStep = [0.0078125, 0.0078125] 11 | rayMarchSamplingNoise = [0.0, 0.0] 12 | raySampleInput = [0, 0] 13 | depthTransform = log 14 | zNear = [0.001, 0.001] 15 | zFar = [1.0, 1.0] 16 | adaptiveSamplingThreshold = 0.15 17 | multiDepthFeatures = [128, 128] 18 | multiDepthIgnoreValue = [1.01, 1.01] 19 | accumulationMult = alpha 20 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/sample_pavillon_16/dataset_info.txt: -------------------------------------------------------------------------------- 1 | view_cell_center = [0.783, -3.19, 1.39] 2 | view_cell_size = [0.7, 0.7, 0.2] 3 | depth_range = [0.1542200982570648, 8.358194804191589] 4 | fov = 1.1386263370513916 5 | focal = 625.0000310758528 6 | camera_scale = 1.0 7 | max_depth = 8.79825210571289 8 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/sample_pavillon_16/model0.onnx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_real_time_viewer/sample_pavillon_16/model0.onnx -------------------------------------------------------------------------------- /adanerf_real_time_viewer/sample_pavillon_16/model1.onnx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_real_time_viewer/sample_pavillon_16/model1.onnx -------------------------------------------------------------------------------- /adanerf_real_time_viewer/src/basicbuffermanager.cpp: -------------------------------------------------------------------------------- 1 | #include "../include/basicbuffermanager.h" 2 | 3 | #include "../include/cuda/adanerf_cuda_kernels.cuh" 4 | 5 | #include 6 | 7 | 8 | BasicBufferManager::~BasicBufferManager() 9 | { 10 | if (initialized) 11 | { 12 | cudaDestroySurfaceObject(d_curr_buffer_surf); 13 | CUDA_CHECK; 14 | 15 | cudaFreeArray(d_curr_buffer); 16 | CUDA_CHECK; 17 | } 18 | } 19 | 20 | bool BasicBufferManager::init(unsigned int w, unsigned int h) 21 | { 22 | width = w; 23 | height = h; 24 | 25 | cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc(); 26 | cudaMallocArray(&d_curr_buffer, &channelDesc, width, height, cudaArraySurfaceLoadStore); 27 | CUDA_CHECK; 28 | 29 | cudaResourceDesc surfRes; 30 | memset(&surfRes, 0, sizeof(cudaResourceDesc)); 31 | surfRes.resType = cudaResourceTypeArray; 32 | surfRes.res.array.array = d_curr_buffer; 33 | 34 | cudaCreateSurfaceObject(&d_curr_buffer_surf, &surfRes); 35 | CUDA_CHECK; 36 | 37 | this->resize(w, h); 38 | initialized = true; 39 | 40 | return true; 41 | } 42 | 43 | void BasicBufferManager::resize(unsigned int w, unsigned int h) 44 | { 45 | width = w; 46 | height = h; 47 | } 48 | 49 | void BasicBufferManager::clear() 50 | { 51 | } 52 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/src/encoding.cpp: -------------------------------------------------------------------------------- 1 | #include "../include/encoding.h" 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | Encoding::Encoding() 8 | { 9 | } 10 | 11 | Encoding::~Encoding() 12 | { 13 | } 14 | 15 | void genPosEncFreqs(std::vector& bands, int num_freqs) 16 | { 17 | for (int x = 0; x < num_freqs; x++) 18 | { 19 | float val = 0; 20 | val = (float)x; 21 | bands.push_back((float)pow(2, val)); 22 | } 23 | } 24 | 25 | 26 | bool Encoding::load(std::string type_, int num_pos_freqs_, int num_dir_freqs_, int add_samples) 27 | { 28 | type = type_; 29 | 30 | num_pos_freqs = 0; 31 | num_dir_freqs = 0; 32 | 33 | additional_samples = add_samples; 34 | 35 | 36 | if (type == "nerf") 37 | { 38 | num_pos_freqs = num_pos_freqs_; 39 | num_dir_freqs = num_dir_freqs_; 40 | genPosEncFreqs(pos_freq_bands, num_pos_freqs); 41 | genPosEncFreqs(dir_freq_bands, num_dir_freqs); 42 | 43 | cudaMalloc((void**)&(d_pos_freq_bands), num_pos_freqs * sizeof(float)); 44 | cudaMalloc((void**)&(d_dir_freq_bands), num_dir_freqs * sizeof(float)); 45 | 46 | cudaMemcpy(d_pos_freq_bands, &pos_freq_bands[0], num_pos_freqs * sizeof(float), cudaMemcpyHostToDevice); 47 | cudaMemcpy(d_dir_freq_bands, &dir_freq_bands[0], num_dir_freqs * sizeof(float), cudaMemcpyHostToDevice); 48 | } 49 | if (type == "fourier") 50 | { 51 | } 52 | 53 | return true; 54 | } 55 | 56 | 57 | 58 | -------------------------------------------------------------------------------- /adanerf_real_time_viewer/src/settings.cpp: -------------------------------------------------------------------------------- 1 | #include "../include/settings.h" 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | Settings::Settings() 8 | { 9 | } 10 | Settings::~Settings() 11 | { 12 | } 13 | 14 | 15 | void Settings::init(argparse::ArgumentParser& program) 16 | { 17 | model_path = program.get("modelPath"); 18 | 19 | auto size = program.get>("--size"); 20 | width = size[0]; 21 | height = size[1]; 22 | total_size = width * height; 23 | 24 | if (program.is_used("--windowSize")) 25 | { 26 | auto window_size = program.get>("--windowSize"); 27 | window_width = window_size[0]; 28 | window_height = window_size[1]; 29 | } 30 | else 31 | { 32 | window_width = width; 33 | window_height = height; 34 | } 35 | 36 | 37 | unsigned int n_batches = program.get("--numberOfBatches"); 38 | batch_size = std::ceil(total_size / (float) n_batches); 39 | 40 | if (program.is_used("--batchSize")) 41 | { 42 | int batch_size_arg = program.get("--batchSize"); 43 | batch_size = batch_size_arg <= 0 ? total_size : std::min((unsigned int) batch_size_arg, total_size); 44 | } 45 | 46 | write_images = program.get("--writeImages"); 47 | is_debug = program.get("--debug"); 48 | } 49 | -------------------------------------------------------------------------------- /adanerf_teaser.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/thomasneff/AdaNeRF/b68e30fd2718436bda4cfc11530506cad0841a86/adanerf_teaser.png -------------------------------------------------------------------------------- /blender_export_per_scene_stub.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import os 3 | import bpy 4 | 5 | import_dir = bpy.path.abspath('//../../..') 6 | 7 | if import_dir not in sys.path: 8 | sys.path.append(import_dir) 9 | 10 | import importlib 11 | 12 | blender_export = importlib.import_module('blender_export') 13 | importlib.reload(blender_export) 14 | 15 | 16 | VIEW_CELL_CENTER = [ -18.0, -45.0, 5.0] 17 | VIEW_CELL_SIZE = [2.0, 2.0, 2.0] 18 | VIEW_ROT_START = [90.0,0,0] 19 | VIEW_ROT_RESTR = [20,0,30] 20 | VIEWS = 100 21 | SCENE_NAME = 'forest_4k' 22 | RESOLUTION_X = 3840 23 | RESOLUTION_Y = 2160 24 | 25 | CAM_NAME = "renderCam" 26 | 27 | blender_export.export_view_cells(VIEWS=VIEWS, VIEW_CELL_CENTER=VIEW_CELL_CENTER, VIEW_CELL_SIZE=VIEW_CELL_SIZE, 28 | VIEW_ROT_START=VIEW_ROT_START, VIEW_ROT_RESTR=VIEW_ROT_RESTR, SCENE_NAME=SCENE_NAME, CAM_NAME=CAM_NAME, RESOLUTION_X=RESOLUTION_X, RESOLUTION_Y=RESOLUTION_Y) 29 | 30 | -------------------------------------------------------------------------------- /configs/dense_training.ini: -------------------------------------------------------------------------------- 1 | [Data] 2 | depthTransform = log 3 | 4 | [Features] 5 | inFeatures = [SpherePosDir, RayMarchFromPoses] 6 | outFeatures = [RawSigmoid, RGBARayMarch] 7 | posEnc = [nerf, nerf] 8 | posEncArgs = [10-4, 10-4] 9 | 10 | raySampleInput = [0, 0] 11 | multiDepthFeatures = [128, 128] 12 | multiDepthIgnoreValue = [1.01, 1.01] 13 | 14 | [Network] 15 | activation = [relu, nerf] 16 | layers = [8, 8] 17 | layerWidth = [256, 256] 18 | skips = [ , auto] 19 | 20 | [Training] 21 | epochs = 300001 22 | scale = 1 23 | samples = 2048 24 | batchImages = 2 25 | lrate = 5e-4 26 | losses = [NeRFWeightMultiplicationLoss, MSE] 27 | lossWeights = [0.025, 1.0] 28 | epochsPretrain = [-1, -1] 29 | epochsLockWeightsBefore = [-1, 1001] 30 | epochsLockWeightsAfter = [80000, -1] 31 | inferenceChunkSize = 8192 32 | epochsRender = 10000 33 | epochsValidate = 50000 34 | 35 | [Raymarching-Params] 36 | numRaymarchSamples = [128, 128] 37 | rayMarchSampler = [none, FromClassifiedDepthAdaptive] 38 | ; ray march sampling step size (currently 1.0 / 128) 39 | rayMarchSamplingStep = [0.0078125, 0.0078125] 40 | rayMarchNormalization = [InverseSqrtDistCentered, InverseSqrtDistCentered] 41 | performEvaluation = True 42 | 43 | adaptiveSamplingThreshold = 0.0 44 | 45 | accumulationMult = alpha 46 | lossComponents = [One, Zero, NerfA] 47 | lossComponentBlending = [-1.0, -1.0, -1.0] 48 | 49 | lossBlendingStart = 25000 50 | lossBlendingDuration = 50000 51 | -------------------------------------------------------------------------------- /configs/dense_training_ndc.ini: -------------------------------------------------------------------------------- 1 | [Data] 2 | depthTransform = linear 3 | 4 | [Features] 5 | inFeatures = [SpherePosDir, RayMarchFromPoses] 6 | outFeatures = [RawSigmoid, RGBARayMarch] 7 | posEnc = [nerf, nerf] 8 | posEncArgs = [2-2, 10-4] 9 | 10 | raySampleInput = [0, 0] 11 | multiDepthFeatures = [128, 128] 12 | multiDepthIgnoreValue = [1.01, 1.01] 13 | 14 | [Network] 15 | activation = [relu, nerf] 16 | layers = [8, 8] 17 | layerWidth = [256, 256] 18 | skips = [ , auto] 19 | 20 | [Training] 21 | epochs = 300001 22 | scale = 1 23 | samples = 2048 24 | batchImages = 2 25 | lrate = 5e-4 26 | losses = [NeRFWeightMultiplicationLoss, MSE] 27 | lossWeights = [0.025, 1.0] 28 | epochsPretrain = [-1, -1] 29 | epochsLockWeightsBefore = [-1, 1001] 30 | epochsLockWeightsAfter = [80000, -1] 31 | inferenceChunkSize = 8192 32 | epochsRender = 10000 33 | epochsValidate = 50000 34 | 35 | [Raymarching-Params] 36 | numRaymarchSamples = [128, 128] 37 | rayMarchSampler = [none, FromClassifiedDepthAdaptiveNoDepthRange] 38 | ; ray march sampling step size (currently 1.0 / 128) 39 | rayMarchSamplingStep = [0.0078125, 0.0078125] 40 | rayMarchNormalization = [InverseSqrtDistCentered, None] 41 | performEvaluation = True 42 | 43 | adaptiveSamplingThreshold = 0.0 44 | 45 | accumulationMult = alpha 46 | lossComponents = [One, Zero, NerfA] 47 | lossComponentBlending = [-1.0, -1.0, -1.0] 48 | 49 | lossBlendingStart = 25000 50 | lossBlendingDuration = 50000 51 | 52 | useNDC = True 53 | -------------------------------------------------------------------------------- /configs/fine_training.ini: -------------------------------------------------------------------------------- 1 | [Data] 2 | depthTransform = log 3 | 4 | [Features] 5 | inFeatures = [SpherePosDir, RayMarchFromPoses] 6 | outFeatures = [RawSigmoid, RGBARayMarch] 7 | posEnc = [nerf, nerf] 8 | posEncArgs = [10-4, 10-4] 9 | 10 | raySampleInput = [0, 0] 11 | multiDepthFeatures = [128, 128] 12 | multiDepthIgnoreValue = [1.01, 1.01] 13 | 14 | [Network] 15 | activation = [relu, nerf] 16 | layers = [8, 8] 17 | layerWidth = [256, 256] 18 | skips = [ , auto] 19 | 20 | [Training] 21 | epochs = 300001 22 | scale = 1 23 | samples = 2048 24 | batchImages = 2 25 | lrate = 5e-4 26 | losses = [NeRFWeightMultiplicationLoss, MSE] 27 | lossWeights = [0.025, 1.0] 28 | epochsPretrain = [-1, -1] 29 | epochsLockWeightsBefore = [-1, -1] 30 | epochsLockWeightsAfter = [0, -1] 31 | inferenceChunkSize = 8192 32 | epochsRender = 10000 33 | epochsValidate = 50000 34 | preTrainedSuffix = opt 35 | 36 | [Raymarching-Params] 37 | numRaymarchSamples = [16, 16] 38 | rayMarchSampler = [none, FromClassifiedDepthAdaptive] 39 | ; ray march sampling step size (currently 1.0 / 128) 40 | rayMarchSamplingStep = [0.0078125, 0.0078125] 41 | rayMarchNormalization = [InverseSqrtDistCentered, InverseSqrtDistCentered] 42 | performEvaluation = True 43 | 44 | adaptiveSamplingThreshold = 0.15 45 | 46 | accumulationMult = alpha 47 | lossComponents = [One, Zero, NerfA] 48 | lossComponentBlending = [-1.0, -1.0, -1.0] 49 | 50 | lossBlendingStart = 25000 51 | lossBlendingDuration = 50000 52 | -------------------------------------------------------------------------------- /configs/fine_training_ndc.ini: -------------------------------------------------------------------------------- 1 | [Data] 2 | depthTransform = linear 3 | 4 | [Features] 5 | inFeatures = [SpherePosDir, RayMarchFromPoses] 6 | outFeatures = [RawSigmoid, RGBARayMarch] 7 | posEnc = [nerf, nerf] 8 | posEncArgs = [2-2, 10-4] 9 | 10 | raySampleInput = [0, 0] 11 | multiDepthFeatures = [128, 128] 12 | multiDepthIgnoreValue = [1.01, 1.01] 13 | 14 | [Network] 15 | activation = [relu, nerf] 16 | layers = [8, 8] 17 | layerWidth = [256, 256] 18 | skips = [ , auto] 19 | 20 | [Training] 21 | epochs = 300001 22 | scale = 1 23 | samples = 2048 24 | batchImages = 2 25 | lrate = 5e-4 26 | losses = [NeRFWeightMultiplicationLoss, MSE] 27 | lossWeights = [0.025, 1.0] 28 | epochsPretrain = [-1, -1] 29 | epochsLockWeightsBefore = [-1, -1] 30 | epochsLockWeightsAfter = [0, -1] 31 | inferenceChunkSize = 8192 32 | epochsRender = 10000 33 | epochsValidate = 50000 34 | preTrainedSuffix = opt 35 | 36 | [Raymarching-Params] 37 | numRaymarchSamples = [16, 16] 38 | rayMarchSampler = [none, FromClassifiedDepthAdaptiveNoDepthRange] 39 | ; ray march sampling step size (currently 1.0 / 128) 40 | rayMarchSamplingStep = [0.0078125, 0.0078125] 41 | rayMarchNormalization = [InverseSqrtDistCentered, None] 42 | performEvaluation = True 43 | 44 | adaptiveSamplingThreshold = 0.15 45 | 46 | accumulationMult = alpha 47 | lossComponents = [One, Zero, NerfA] 48 | lossComponentBlending = [-1.0, -1.0, -1.0] 49 | 50 | lossBlendingStart = 25000 51 | lossBlendingDuration = 50000 52 | 53 | useNDC = True 54 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | numpy 2 | pandas 3 | torch 4 | matplotlib 5 | transforms3d 6 | opencv-python 7 | imageio 8 | imageio-ffmpeg 9 | configargparse 10 | pillow 11 | pyrtools 12 | ptflops<=0.6.7 13 | tqdm 14 | -------------------------------------------------------------------------------- /src/native_extensions.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Facebook, Inc. and its affiliates. 2 | # All rights reserved. 3 | # 4 | # This source code is licensed under the CC-BY-NC license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from setuptools import setup 8 | from torch.utils import cpp_extension 9 | 10 | setup(name='disc_depth_multiclass', 11 | ext_modules=[cpp_extension.CUDAExtension('disc_depth_multiclass', [ 12 | './src/native/disc_depth_multiclass.cpp', 13 | './src/native/disc_depth_multiclass_cuda.cu'])], 14 | version="0.0.2", 15 | cmdclass={'build_ext': cpp_extension.BuildExtension}) 16 | -------------------------------------------------------------------------------- /src/test.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Facebook, Inc. and its affiliates. 2 | # All rights reserved. 3 | # 4 | # This source code is licensed under the CC-BY-NC license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from datasets import create_sample_wrapper 8 | from util.config import Config 9 | from train_data import TrainConfig 10 | from plots import render_img, render_all_imgs, render_video 11 | 12 | 13 | def main(): 14 | config = Config.init(only_known_args=True) 15 | train_config = TrainConfig() 16 | train_config.initialize(config) 17 | 18 | train_config.load_latest_weights() 19 | 20 | if config.checkPointName is not None and config.checkPointName != "": 21 | train_config.load_specific_weights(config.checkPointName) 22 | 23 | # NOTE: if using another dataset to render_img (valid, train), need to "dataset.full_images" to True first 24 | # (see render_all_imgs in plots.py) 25 | #img_samples = create_sample_wrapper(train_config.test_dataset[0], train_config, True) 26 | #render_img(train_config, img_samples, img_name=f"test_0") 27 | 28 | render_all_imgs(train_config, "test_images/", dataset_name="train") 29 | render_all_imgs(train_config, "test_images/", dataset_name="val") 30 | render_all_imgs(train_config, "test_images/", dataset_name="test") 31 | 32 | #render_video(train_config, vid_name=config.outputVideoName) 33 | 34 | 35 | if __name__ == '__main__': 36 | main() 37 | -------------------------------------------------------------------------------- /src/util/raygeneration.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Facebook, Inc. and its affiliates. 2 | # All rights reserved. 3 | # 4 | # This source code is licensed under the CC-BY-NC license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import numpy as np 8 | 9 | 10 | def generate_ray_directions(w, h, fov, focal): 11 | x_dist = np.tan(fov / 2) * focal 12 | y_dist = x_dist * (h / w) 13 | x_dist_pp = x_dist / (w / 2) 14 | y_dist_pp = y_dist / (h / 2) 15 | 16 | start = np.array([-(x_dist - x_dist_pp/2), -(y_dist - y_dist_pp/2), focal]) 17 | ray_d = np.repeat(start[None], repeats=w * h, axis=0).reshape((h, w, -1)) 18 | w_range = np.repeat(np.arange(0, w)[None], repeats=h, axis=0) 19 | h_range = np.repeat(np.arange(0, h)[None], repeats=w, axis=0).T 20 | ray_d[:, :, 0] += x_dist_pp * w_range 21 | ray_d[:, :, 1] += y_dist_pp * h_range 22 | 23 | dirs = ray_d / np.tile(np.linalg.norm(ray_d, axis=2)[:, :, None], (1, 1, 3)) 24 | dirs[:, :, 1] *= -1. 25 | dirs[:, :, 2] *= -1. 26 | return dirs 27 | --------------------------------------------------------------------------------