├── .gitignore ├── Framework ├── Externals │ ├── Assimp │ │ ├── CREDITS │ │ ├── LICENSE │ │ ├── README │ │ ├── WEB │ │ ├── doc │ │ │ ├── AssimpCmdDoc.chm │ │ │ ├── AssimpDoc.chm │ │ │ └── datastructure.xml │ │ ├── include │ │ │ └── assimp │ │ │ │ ├── .editorconfig │ │ │ │ ├── BaseImporter.h │ │ │ │ ├── Bitmap.h │ │ │ │ ├── BlobIOSystem.h │ │ │ │ ├── ByteSwapper.h │ │ │ │ ├── Compiler │ │ │ │ ├── poppack1.h │ │ │ │ ├── pstdint.h │ │ │ │ └── pushpack1.h │ │ │ │ ├── CreateAnimMesh.h │ │ │ │ ├── DefaultIOStream.h │ │ │ │ ├── DefaultIOSystem.h │ │ │ │ ├── DefaultLogger.hpp │ │ │ │ ├── Defines.h │ │ │ │ ├── Exceptional.h │ │ │ │ ├── Exporter.hpp │ │ │ │ ├── GenericProperty.h │ │ │ │ ├── Hash.h │ │ │ │ ├── IOStream.hpp │ │ │ │ ├── IOStreamBuffer.h │ │ │ │ ├── IOSystem.hpp │ │ │ │ ├── Importer.hpp │ │ │ │ ├── LineSplitter.h │ │ │ │ ├── LogAux.h │ │ │ │ ├── LogStream.hpp │ │ │ │ ├── Logger.hpp │ │ │ │ ├── Macros.h │ │ │ │ ├── MathFunctions.h │ │ │ │ ├── MemoryIOWrapper.h │ │ │ │ ├── NullLogger.hpp │ │ │ │ ├── ParsingUtils.h │ │ │ │ ├── Profiler.h │ │ │ │ ├── ProgressHandler.hpp │ │ │ │ ├── RemoveComments.h │ │ │ │ ├── SGSpatialSort.h │ │ │ │ ├── SceneCombiner.h │ │ │ │ ├── SkeletonMeshBuilder.h │ │ │ │ ├── SmoothingGroups.h │ │ │ │ ├── SmoothingGroups.inl │ │ │ │ ├── SpatialSort.h │ │ │ │ ├── StandardShapes.h │ │ │ │ ├── StreamReader.h │ │ │ │ ├── StreamWriter.h │ │ │ │ ├── StringComparison.h │ │ │ │ ├── StringUtils.h │ │ │ │ ├── Subdivision.h │ │ │ │ ├── TinyFormatter.h │ │ │ │ ├── Vertex.h │ │ │ │ ├── XMLTools.h │ │ │ │ ├── ai_assert.h │ │ │ │ ├── anim.h │ │ │ │ ├── camera.h │ │ │ │ ├── cexport.h │ │ │ │ ├── cfileio.h │ │ │ │ ├── cimport.h │ │ │ │ ├── color4.h │ │ │ │ ├── color4.inl │ │ │ │ ├── config.h │ │ │ │ ├── config.h.in │ │ │ │ ├── defs.h │ │ │ │ ├── fast_atof.h │ │ │ │ ├── importerdesc.h │ │ │ │ ├── irrXMLWrapper.h │ │ │ │ ├── light.h │ │ │ │ ├── material.h │ │ │ │ ├── material.inl │ │ │ │ ├── matrix3x3.h │ │ │ │ ├── matrix3x3.inl │ │ │ │ ├── matrix4x4.h │ │ │ │ ├── matrix4x4.inl │ │ │ │ ├── mesh.h │ │ │ │ ├── metadata.h │ │ │ │ ├── pbrmaterial.h │ │ │ │ ├── port │ │ │ │ └── AndroidJNI │ │ │ │ │ └── AndroidJNIIOSystem.h │ │ │ │ ├── postprocess.h │ │ │ │ ├── qnan.h │ │ │ │ ├── quaternion.h │ │ │ │ ├── quaternion.inl │ │ │ │ ├── scene.h │ │ │ │ ├── texture.h │ │ │ │ ├── types.h │ │ │ │ ├── vector2.h │ │ │ │ ├── vector2.inl │ │ │ │ ├── vector3.h │ │ │ │ ├── vector3.inl │ │ │ │ └── version.h │ │ ├── port │ │ │ └── D │ │ │ │ ├── README │ │ │ │ └── assimp │ │ │ │ ├── animation.d │ │ │ │ ├── api.d │ │ │ │ ├── assimp.d │ │ │ │ ├── camera.d │ │ │ │ ├── config.d │ │ │ │ ├── fileIO.d │ │ │ │ ├── light.d │ │ │ │ ├── loader.d │ │ │ │ ├── material.d │ │ │ │ ├── math.d │ │ │ │ ├── mesh.d │ │ │ │ ├── postprocess.d │ │ │ │ ├── scene.d │ │ │ │ ├── texture.d │ │ │ │ ├── types.d │ │ │ │ └── versionInfo.d │ │ ├── readme_installer.txt │ │ ├── samples │ │ │ ├── DevIL │ │ │ │ ├── AUTHORS │ │ │ │ ├── COPYING │ │ │ │ ├── CREDITS │ │ │ │ ├── ChangeLog │ │ │ │ ├── DevIL Website.url │ │ │ │ ├── Libraries.txt │ │ │ │ ├── README │ │ │ │ ├── README.win │ │ │ │ ├── include │ │ │ │ │ └── IL │ │ │ │ │ │ ├── config.h │ │ │ │ │ │ ├── config.h.win │ │ │ │ │ │ ├── devil_internal_exports.h │ │ │ │ │ │ ├── il.h │ │ │ │ │ │ ├── il_wrap.h │ │ │ │ │ │ ├── ilu.h │ │ │ │ │ │ ├── ilu_region.h │ │ │ │ │ │ ├── ilut.h │ │ │ │ │ │ └── ilut_config.h │ │ │ │ └── lib │ │ │ │ │ ├── DevIL.lib │ │ │ │ │ ├── ILU.lib │ │ │ │ │ └── ILUT.lib │ │ │ ├── README │ │ │ ├── SimpleAssimpViewX │ │ │ │ ├── English.lproj │ │ │ │ │ ├── Credits.rtf │ │ │ │ │ ├── InfoPlist.strings │ │ │ │ │ ├── MainMenu.xib │ │ │ │ │ └── MyDocument.xib │ │ │ │ ├── ModelLoaderHelperClasses.h │ │ │ │ ├── ModelLoaderHelperClasses.mm │ │ │ │ ├── MyDocument.h │ │ │ │ ├── MyDocument.mm │ │ │ │ ├── MyDocument.xcdatamodel │ │ │ │ │ ├── elements │ │ │ │ │ └── layout │ │ │ │ ├── README │ │ │ │ ├── SimpleAssimpViewX-Info.plist │ │ │ │ ├── SimpleAssimpViewX.xcodeproj │ │ │ │ │ ├── project.pbxproj │ │ │ │ │ ├── vade.mode1v3 │ │ │ │ │ └── vade.pbxuser │ │ │ │ ├── include │ │ │ │ │ └── copy_assimp_headers_here.txt │ │ │ │ └── main.m │ │ │ ├── SimpleOpenGL │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Sample_SimpleOpenGL.c │ │ │ │ ├── SimpleOpenGL.sln │ │ │ │ └── SimpleOpenGL.vcproj │ │ │ ├── SimpleTexturedDirectx11 │ │ │ │ ├── SimpleTexturedDirectx11.sln │ │ │ │ └── SimpleTexturedDirectx11 │ │ │ │ │ ├── Mesh.h │ │ │ │ │ ├── ModelLoader.cpp │ │ │ │ │ ├── ModelLoader.h │ │ │ │ │ ├── PixelShader.hlsl │ │ │ │ │ ├── SimpleTexturedDirectx11.vcxproj │ │ │ │ │ ├── SimpleTexturedDirectx11.vcxproj.filters │ │ │ │ │ ├── TextureLoader.cpp │ │ │ │ │ ├── TextureLoader.h │ │ │ │ │ ├── VertexShader.hlsl │ │ │ │ │ └── main.cpp │ │ │ ├── SimpleTexturedOpenGL │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── SimpleTexturedOpenGL.sln │ │ │ │ └── SimpleTexturedOpenGL │ │ │ │ │ ├── SimpleTexturedOpenGL.vcproj │ │ │ │ │ ├── include │ │ │ │ │ └── boost_includes.h │ │ │ │ │ └── src │ │ │ │ │ └── model_loading.cpp │ │ │ └── glut │ │ │ │ ├── GL │ │ │ │ └── glut.h │ │ │ │ ├── README-win32.txt │ │ │ │ ├── glut.def │ │ │ │ └── glut32.lib │ │ ├── scripts │ │ │ ├── AppVeyor │ │ │ │ ├── cacheglobs.txt │ │ │ │ └── mtime_cache │ │ │ ├── BlenderImporter │ │ │ │ ├── BlenderScene.cpp.template │ │ │ │ ├── BlenderSceneGen.h.template │ │ │ │ └── genblenddna.py │ │ │ ├── IFCImporter │ │ │ │ ├── CppGenerator.py │ │ │ │ ├── ExpressReader.py │ │ │ │ ├── IFCReaderGen.cpp.template │ │ │ │ ├── IFCReaderGen.h.template │ │ │ │ ├── entitylist.txt │ │ │ │ ├── genentitylist.sh │ │ │ │ ├── schema_ifc2x3.exp │ │ │ │ └── schema_ifc4.exp │ │ │ ├── OgreImporter │ │ │ │ └── assimp.tpl │ │ │ ├── adjust_header_paths.sh │ │ │ └── android_crosscompile │ │ │ │ └── make_android.bat │ │ ├── stub │ │ │ └── vc_redist.x64.exe │ │ ├── unins000.dat │ │ └── unins000.exe │ ├── DXCAPI │ │ └── dxcapi.use.h │ ├── DirectXTex │ │ ├── BC.cpp │ │ ├── BC.h │ │ ├── BC4BC5.cpp │ │ ├── BC6HBC7.cpp │ │ ├── BCDirectCompute.cpp │ │ ├── BCDirectCompute.h │ │ ├── DDS.h │ │ ├── DirectXTex.h │ │ ├── DirectXTex.inl │ │ ├── DirectXTexCompress.cpp │ │ ├── DirectXTexCompressGPU.cpp │ │ ├── DirectXTexConvert.cpp │ │ ├── DirectXTexD3D11.cpp │ │ ├── DirectXTexD3D12.cpp │ │ ├── DirectXTexDDS.cpp │ │ ├── DirectXTexFlipRotate.cpp │ │ ├── DirectXTexHDR.cpp │ │ ├── DirectXTexImage.cpp │ │ ├── DirectXTexMipmaps.cpp │ │ ├── DirectXTexMisc.cpp │ │ ├── DirectXTexNormalMaps.cpp │ │ ├── DirectXTexP.h │ │ ├── DirectXTexPMAlpha.cpp │ │ ├── DirectXTexResize.cpp │ │ ├── DirectXTexTGA.cpp │ │ ├── DirectXTexUtil.cpp │ │ ├── DirectXTexWIC.cpp │ │ ├── DirectXTex_Desktop_2015.vcxproj │ │ ├── DirectXTex_Desktop_2015.vcxproj.filters │ │ ├── DirectXTex_Desktop_2015_Win10.vcxproj │ │ ├── DirectXTex_Desktop_2015_Win10.vcxproj.filters │ │ ├── DirectXTex_Desktop_2017.vcxproj │ │ ├── DirectXTex_Desktop_2017.vcxproj.filters │ │ ├── DirectXTex_Desktop_2017_Win10.vcxproj │ │ ├── DirectXTex_Desktop_2017_Win10.vcxproj.filters │ │ ├── DirectXTex_Windows10.vcxproj │ │ ├── DirectXTex_Windows10.vcxproj.filters │ │ ├── DirectXTex_Windows10_2015.vcxproj │ │ ├── DirectXTex_Windows10_2015.vcxproj.filters │ │ ├── DirectXTex_XboxOneXDK_2015.vcxproj │ │ ├── DirectXTex_XboxOneXDK_2015.vcxproj.filters │ │ ├── DirectXTex_XboxOneXDK_2017.vcxproj │ │ ├── DirectXTex_XboxOneXDK_2017.vcxproj.filters │ │ ├── Filters.h │ │ ├── Shaders │ │ │ ├── BC6HEncode.hlsl │ │ │ ├── BC7Encode.hlsl │ │ │ ├── CompileShaders.cmd │ │ │ └── Compiled │ │ │ │ ├── BC6HEncode_EncodeBlockCS.inc │ │ │ │ ├── BC6HEncode_TryModeG10CS.inc │ │ │ │ ├── BC6HEncode_TryModeLE10CS.inc │ │ │ │ ├── BC7Encode_EncodeBlockCS.inc │ │ │ │ ├── BC7Encode_TryMode02CS.inc │ │ │ │ ├── BC7Encode_TryMode137CS.inc │ │ │ │ └── BC7Encode_TryMode456CS.inc │ │ ├── d3dx12.h │ │ └── scoped.h │ ├── GLM │ │ ├── .packman.sha1 │ │ ├── glm │ │ │ ├── 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_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_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_projection.hpp │ │ │ │ ├── matrix_projection.inl │ │ │ │ ├── matrix_relational.hpp │ │ │ │ ├── matrix_relational.inl │ │ │ │ ├── matrix_transform.hpp │ │ │ │ ├── matrix_transform.inl │ │ │ │ ├── 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_float_sized.hpp │ │ │ │ ├── scalar_int_sized.hpp │ │ │ │ ├── scalar_relational.hpp │ │ │ │ ├── scalar_relational.inl │ │ │ │ ├── scalar_uint_sized.hpp │ │ │ │ ├── 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_precision.hpp │ │ │ │ ├── vector_int2.hpp │ │ │ │ ├── vector_int2_precision.hpp │ │ │ │ ├── vector_int3.hpp │ │ │ │ ├── vector_int3_precision.hpp │ │ │ │ ├── vector_int4.hpp │ │ │ │ ├── vector_int4_precision.hpp │ │ │ │ ├── vector_relational.hpp │ │ │ │ ├── vector_relational.inl │ │ │ │ ├── vector_uint1.hpp │ │ │ │ ├── vector_uint1_precision.hpp │ │ │ │ ├── vector_uint2.hpp │ │ │ │ ├── vector_uint2_precision.hpp │ │ │ │ ├── vector_uint3.hpp │ │ │ │ ├── vector_uint3_precision.hpp │ │ │ │ ├── vector_uint4.hpp │ │ │ │ └── vector_uint4_precision.hpp │ │ │ ├── fwd.hpp │ │ │ ├── geometric.hpp │ │ │ ├── glm.hpp │ │ │ ├── gtc │ │ │ │ ├── bitfield.hpp │ │ │ │ ├── bitfield.inl │ │ │ │ ├── color_space.hpp │ │ │ │ ├── color_space.inl │ │ │ │ ├── constants.hpp │ │ │ │ ├── constants.inl │ │ │ │ ├── epsilon.hpp │ │ │ │ ├── epsilon.inl │ │ │ │ ├── integer.hpp │ │ │ │ ├── integer.inl │ │ │ │ ├── matrix_access.hpp │ │ │ │ ├── matrix_access.inl │ │ │ │ ├── matrix_integer.hpp │ │ │ │ ├── matrix_inverse.hpp │ │ │ │ ├── matrix_inverse.inl │ │ │ │ ├── matrix_transform.hpp │ │ │ │ ├── matrix_transform.inl │ │ │ │ ├── noise.hpp │ │ │ │ ├── noise.inl │ │ │ │ ├── packing.hpp │ │ │ │ ├── packing.inl │ │ │ │ ├── quaternion.hpp │ │ │ │ ├── quaternion.inl │ │ │ │ ├── quaternion_simd.inl │ │ │ │ ├── random.hpp │ │ │ │ ├── random.inl │ │ │ │ ├── reciprocal.hpp │ │ │ │ ├── reciprocal.inl │ │ │ │ ├── round.hpp │ │ │ │ ├── round.inl │ │ │ │ ├── type_aligned.hpp │ │ │ │ ├── type_precision.hpp │ │ │ │ ├── type_precision.inl │ │ │ │ ├── type_ptr.hpp │ │ │ │ ├── type_ptr.inl │ │ │ │ ├── ulp.hpp │ │ │ │ ├── ulp.inl │ │ │ │ └── vec1.hpp │ │ │ ├── gtx │ │ │ │ ├── associated_min_max.hpp │ │ │ │ ├── associated_min_max.inl │ │ │ │ ├── bit.hpp │ │ │ │ ├── bit.inl │ │ │ │ ├── closest_point.hpp │ │ │ │ ├── closest_point.inl │ │ │ │ ├── color_encoding.hpp │ │ │ │ ├── color_encoding.inl │ │ │ │ ├── color_space.hpp │ │ │ │ ├── color_space.inl │ │ │ │ ├── color_space_YCoCg.hpp │ │ │ │ ├── color_space_YCoCg.inl │ │ │ │ ├── common.hpp │ │ │ │ ├── common.inl │ │ │ │ ├── compatibility.hpp │ │ │ │ ├── compatibility.inl │ │ │ │ ├── component_wise.hpp │ │ │ │ ├── component_wise.inl │ │ │ │ ├── dual_quaternion.hpp │ │ │ │ ├── dual_quaternion.inl │ │ │ │ ├── easing.hpp │ │ │ │ ├── easing.inl │ │ │ │ ├── euler_angles.hpp │ │ │ │ ├── euler_angles.inl │ │ │ │ ├── extend.hpp │ │ │ │ ├── extend.inl │ │ │ │ ├── extended_min_max.hpp │ │ │ │ ├── extended_min_max.inl │ │ │ │ ├── exterior_product.hpp │ │ │ │ ├── exterior_product.inl │ │ │ │ ├── fast_exponential.hpp │ │ │ │ ├── fast_exponential.inl │ │ │ │ ├── fast_square_root.hpp │ │ │ │ ├── fast_square_root.inl │ │ │ │ ├── fast_trigonometry.hpp │ │ │ │ ├── fast_trigonometry.inl │ │ │ │ ├── float_notmalize.inl │ │ │ │ ├── functions.hpp │ │ │ │ ├── functions.inl │ │ │ │ ├── gradient_paint.hpp │ │ │ │ ├── gradient_paint.inl │ │ │ │ ├── handed_coordinate_space.hpp │ │ │ │ ├── handed_coordinate_space.inl │ │ │ │ ├── hash.hpp │ │ │ │ ├── hash.inl │ │ │ │ ├── integer.hpp │ │ │ │ ├── integer.inl │ │ │ │ ├── intersect.hpp │ │ │ │ ├── intersect.inl │ │ │ │ ├── io.hpp │ │ │ │ ├── io.inl │ │ │ │ ├── log_base.hpp │ │ │ │ ├── log_base.inl │ │ │ │ ├── matrix_cross_product.hpp │ │ │ │ ├── matrix_cross_product.inl │ │ │ │ ├── matrix_decompose.hpp │ │ │ │ ├── matrix_decompose.inl │ │ │ │ ├── matrix_factorisation.hpp │ │ │ │ ├── matrix_factorisation.inl │ │ │ │ ├── matrix_interpolation.hpp │ │ │ │ ├── matrix_interpolation.inl │ │ │ │ ├── matrix_major_storage.hpp │ │ │ │ ├── matrix_major_storage.inl │ │ │ │ ├── matrix_operation.hpp │ │ │ │ ├── matrix_operation.inl │ │ │ │ ├── matrix_query.hpp │ │ │ │ ├── matrix_query.inl │ │ │ │ ├── matrix_transform_2d.hpp │ │ │ │ ├── matrix_transform_2d.inl │ │ │ │ ├── mixed_product.hpp │ │ │ │ ├── mixed_product.inl │ │ │ │ ├── norm.hpp │ │ │ │ ├── norm.inl │ │ │ │ ├── normal.hpp │ │ │ │ ├── normal.inl │ │ │ │ ├── normalize_dot.hpp │ │ │ │ ├── normalize_dot.inl │ │ │ │ ├── number_precision.hpp │ │ │ │ ├── number_precision.inl │ │ │ │ ├── optimum_pow.hpp │ │ │ │ ├── optimum_pow.inl │ │ │ │ ├── orthonormalize.hpp │ │ │ │ ├── orthonormalize.inl │ │ │ │ ├── perpendicular.hpp │ │ │ │ ├── perpendicular.inl │ │ │ │ ├── polar_coordinates.hpp │ │ │ │ ├── polar_coordinates.inl │ │ │ │ ├── projection.hpp │ │ │ │ ├── projection.inl │ │ │ │ ├── quaternion.hpp │ │ │ │ ├── quaternion.inl │ │ │ │ ├── range.hpp │ │ │ │ ├── raw_data.hpp │ │ │ │ ├── raw_data.inl │ │ │ │ ├── rotate_normalized_axis.hpp │ │ │ │ ├── rotate_normalized_axis.inl │ │ │ │ ├── rotate_vector.hpp │ │ │ │ ├── rotate_vector.inl │ │ │ │ ├── scalar_multiplication.hpp │ │ │ │ ├── scalar_relational.hpp │ │ │ │ ├── scalar_relational.inl │ │ │ │ ├── spline.hpp │ │ │ │ ├── spline.inl │ │ │ │ ├── std_based_type.hpp │ │ │ │ ├── std_based_type.inl │ │ │ │ ├── string_cast.hpp │ │ │ │ ├── string_cast.inl │ │ │ │ ├── texture.hpp │ │ │ │ ├── texture.inl │ │ │ │ ├── transform.hpp │ │ │ │ ├── transform.inl │ │ │ │ ├── transform2.hpp │ │ │ │ ├── transform2.inl │ │ │ │ ├── type_aligned.hpp │ │ │ │ ├── type_aligned.inl │ │ │ │ ├── type_trait.hpp │ │ │ │ ├── type_trait.inl │ │ │ │ ├── vec_swizzle.hpp │ │ │ │ ├── vector_angle.hpp │ │ │ │ ├── vector_angle.inl │ │ │ │ ├── vector_query.hpp │ │ │ │ ├── vector_query.inl │ │ │ │ ├── wrap.hpp │ │ │ │ └── wrap.inl │ │ │ ├── integer.hpp │ │ │ ├── mat2x2.hpp │ │ │ ├── mat2x3.hpp │ │ │ ├── mat2x4.hpp │ │ │ ├── mat3x2.hpp │ │ │ ├── mat3x3.hpp │ │ │ ├── mat3x4.hpp │ │ │ ├── mat4x2.hpp │ │ │ ├── mat4x3.hpp │ │ │ ├── mat4x4.hpp │ │ │ ├── matrix.hpp │ │ │ ├── packing.hpp │ │ │ ├── simd │ │ │ │ ├── common.h │ │ │ │ ├── exponential.h │ │ │ │ ├── geometric.h │ │ │ │ ├── integer.h │ │ │ │ ├── matrix.h │ │ │ │ ├── packing.h │ │ │ │ ├── platform.h │ │ │ │ ├── trigonometric.h │ │ │ │ └── vector_relational.h │ │ │ ├── trigonometric.hpp │ │ │ ├── vec2.hpp │ │ │ ├── vec3.hpp │ │ │ ├── vec4.hpp │ │ │ └── vector_relational.hpp │ │ └── readme.md │ ├── PresentationCore.dll │ └── dxcompiler │ │ ├── dxcompiler.dll │ │ ├── dxil.dll │ │ └── version.txt ├── Framework.cpp ├── Framework.h ├── Framework.props ├── Framework.vcxproj ├── Nvidia.ico ├── d3dx12.h └── packages.config ├── Images ├── room.png ├── sponza.png ├── sunTemple.png └── sunTemple2.png ├── LICENSE ├── Pipeline visualization ├── configuration.zargo ├── pipeline.png └── pipeline.zargo ├── README.md ├── RT-RSM.sln └── RT-RSM ├── Data ├── Common.hlsli ├── GBuffer.hlsl ├── HDR_maps │ ├── eucalyptus_probe.hdr │ ├── grace_probe.hdr │ ├── stpeters_probe.hdr │ └── uffizi_probe.hdr ├── Hit.hlsl ├── Miss.hlsl ├── Models │ ├── LICENSE.txt │ ├── README.txt │ ├── SunTemple │ │ ├── LICENSE.txt │ │ ├── README.txt │ │ ├── SunTempleMerged.fbx │ │ └── sunTemple2.fbx │ ├── bistro_interior_with_street.fbx │ ├── bistro_interior_with_street2.fbx │ ├── robot.fbx │ ├── room │ │ ├── back_wall.fbx │ │ ├── back_wall2.fbx │ │ ├── back_wall_extended2.fbx │ │ ├── ceiling.fbx │ │ ├── ceiling2.fbx │ │ ├── ceiling_extended2.fbx │ │ ├── floor.fbx │ │ ├── floor2.fbx │ │ ├── floor_extended2.fbx │ │ ├── front_wall_extended2.fbx │ │ ├── left_wall_extended2.fbx │ │ ├── left_wall_inside.fbx │ │ ├── left_wall_outside.fbx │ │ ├── left_wall_outside2.fbx │ │ ├── right_wall_inside.fbx │ │ ├── right_wall_inside2.fbx │ │ ├── right_wall_outside.fbx │ │ ├── right_wall_outside2.fbx │ │ ├── wall_window.fbx │ │ └── wall_window2.fbx │ ├── room_complete.fbx │ ├── room_with_window.fbx │ ├── sphere.fbx │ ├── sponza.fbx │ ├── sponza2.fbx │ └── teapot.fbx ├── MotionVectors.hlsl ├── MotionVectors.hlsli ├── RayGeneration.hlsl ├── ShadowMap.hlsl ├── ShadowRay.hlsl ├── SpatialFilter.hlsl ├── TemporalFilter.hlsl ├── ToneMapping.hlsl ├── ToneMapping.hlsli ├── hlslUtils.hlsli └── offline shaders │ ├── offline_Hit.hlsl │ ├── offline_Miss.hlsl │ └── offline_RayGeneration.hlsl ├── Model.cpp ├── Model.h ├── RT-RSM.cpp ├── RT-RSM.h ├── RT-RSM.vcxproj ├── RT-RSM.vcxproj.filters ├── nsight_profiler.cfg └── packages.config /Framework/Externals/Assimp/README: -------------------------------------------------------------------------------- 1 | See Readme.md 2 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/WEB: -------------------------------------------------------------------------------- 1 | 2 | Project home page: 3 | http://assimp.sourceforge.net 4 | 5 | Sourceforge.net project page: 6 | http://www.sourceforge.net/projects/assimp 7 | 8 | 9 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/doc/AssimpCmdDoc.chm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/doc/AssimpCmdDoc.chm -------------------------------------------------------------------------------- /Framework/Externals/Assimp/doc/AssimpDoc.chm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/doc/AssimpDoc.chm -------------------------------------------------------------------------------- /Framework/Externals/Assimp/include/assimp/.editorconfig: -------------------------------------------------------------------------------- 1 | # See for details 2 | 3 | [*.{h,hpp,inl}] 4 | end_of_line = lf 5 | insert_final_newline = true 6 | trim_trailing_whitespace = true 7 | indent_size = 4 8 | indent_style = space 9 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/include/assimp/Compiler/poppack1.h: -------------------------------------------------------------------------------- 1 | 2 | // =============================================================================== 3 | // May be included multiple times - resets structure packing to the defaults 4 | // for all supported compilers. Reverts the changes made by #include 5 | // 6 | // Currently this works on the following compilers: 7 | // MSVC 7,8,9 8 | // GCC 9 | // BORLAND (complains about 'pack state changed but not reverted', but works) 10 | // =============================================================================== 11 | 12 | #ifndef AI_PUSHPACK_IS_DEFINED 13 | # error pushpack1.h must be included after poppack1.h 14 | #endif 15 | 16 | // reset packing to the original value 17 | #if defined(_MSC_VER) || defined(__BORLANDC__) || defined (__BCPLUSPLUS__) 18 | # pragma pack( pop ) 19 | #endif 20 | #undef PACK_STRUCT 21 | 22 | #undef AI_PUSHPACK_IS_DEFINED 23 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/include/assimp/Compiler/pushpack1.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | // =============================================================================== 4 | // May be included multiple times - sets structure packing to 1 5 | // for all supported compilers. #include reverts the changes. 6 | // 7 | // Currently this works on the following compilers: 8 | // MSVC 7,8,9 9 | // GCC 10 | // BORLAND (complains about 'pack state changed but not reverted', but works) 11 | // Clang 12 | // 13 | // 14 | // USAGE: 15 | // 16 | // struct StructToBePacked { 17 | // } PACK_STRUCT; 18 | // 19 | // =============================================================================== 20 | 21 | #ifdef AI_PUSHPACK_IS_DEFINED 22 | # error poppack1.h must be included after pushpack1.h 23 | #endif 24 | 25 | #if defined(_MSC_VER) || defined(__BORLANDC__) || defined (__BCPLUSPLUS__) 26 | # pragma pack(push,1) 27 | # define PACK_STRUCT 28 | #elif defined( __GNUC__ ) 29 | # if !defined(HOST_MINGW) 30 | # define PACK_STRUCT __attribute__((__packed__)) 31 | # else 32 | # define PACK_STRUCT __attribute__((gcc_struct, __packed__)) 33 | # endif 34 | #else 35 | # error Compiler not supported 36 | #endif 37 | 38 | #if defined(_MSC_VER) 39 | // C4103: Packing was changed after the inclusion of the header, probably missing #pragma pop 40 | # pragma warning (disable : 4103) 41 | #endif 42 | 43 | #define AI_PUSHPACK_IS_DEFINED 44 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/port/D/README: -------------------------------------------------------------------------------- 1 | D bindings for the Assimp library (http://assimp.sf.net). 2 | --- 3 | 4 | These bindings provide access to Assimp's C API. They were directly created 5 | from the C header files. 6 | 7 | You should be able to create sufficient DDoc documentation for the bindings 8 | using your favourite build tool (such as Rebuild). Please refer to the main 9 | (Doxygen-generated) documentation for general topics. 10 | 11 | Please note that the bindings have only been tested on 32 bit systems, they have 12 | yet to be adapted for the different size of the integer types in 64 bit builds 13 | of Assimp. 14 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/readme_installer.txt: -------------------------------------------------------------------------------- 1 | 2 | ------------------------------------------------------------------------------------ 3 | Open Asset Import Library (Assimp) SDK Installer 4 | Release Notes 5 | ------------------------------------------------------------------------------------ 6 | 7 | http://assimp.sf.net 8 | 9 | 10 | Troubleshooting 11 | =============== 12 | 13 | 1. Missing d3dx9_(some-number).dll? 14 | Install the latest DirectX runtime or grab the file from somewhere (that's evil but mostly fine). 15 | 16 | 2. Application configuration not correct / missing msvcr***.dll? 17 | Reinstall Microsoft Visual C++ 2005 SP1 Redistributable (x86 or x64, depending on your system) 18 | 19 | 3. assimp.exe not in PATH 20 | Add it to PATH. That's not a bug, the installer does not alter the PATH. 21 | 22 | 4. Crashes immediately 23 | You CPU lacks SSE2 support. Build Assimp from scratch to suit your CPU, sorry. 24 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/DevIL/AUTHORS: -------------------------------------------------------------------------------- 1 | The main programmer is Denton Woods, but this could not have been possible 2 | without contributions and some pieces of code from other projects. 3 | 4 | For contributors and credits, read the CREDITS file. 5 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/DevIL/CREDITS: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/samples/DevIL/CREDITS -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/DevIL/DevIL Website.url: -------------------------------------------------------------------------------- 1 | [InternetShortcut] 2 | URL=http://openil.sf.net/ 3 | IDList= 4 | [{000214A0-0000-0000-C000-000000000046}] 5 | Prop3=19,2 6 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/DevIL/README.win: -------------------------------------------------------------------------------- 1 | Where do I find the project files ? 2 | ----------------------------------------- 3 | 4 | MSVC++ projects are in DevIL\projects\vc8 and DevIL\projects\vc9. 5 | If compiling with Cygwin or MinGW, use the instructions in README.unix. 6 | 7 | 8 | The IL_NO_XXX #define's: 9 | ------------------------ 10 | 11 | A user can recompile this library without complete image support in it. For 12 | example, if your project does not use .jpg files, you can uncomment 13 | #define IL_NO_JPG at the top of il/il.h, recompile the library, and no .jpg 14 | support will be added, meaning quicker compiles and a smaller library. 15 | 16 | 17 | The ILUT_USE_XXX #define's: 18 | --------------------------- 19 | 20 | To disable support for a specific API, edit IL/ilut.h and comment the 21 | corresponding #define. Per example, to disable OpenGL functions support, 22 | add // in front of the line that reads: 23 | 24 | #define ILUT_USE_OPENGL 25 | 26 | 27 | Libraries needed to compile DevIL* : 28 | ----------------------------------- 29 | 30 | Libraries.txt (included with the DevIL distribution) lists all libraries needed 31 | to properly compile DevIL. 32 | 33 | Precompiled versions and sources of all libraries needed to compile DevIL are 34 | available at http://openil.sourceforge.net/libs/LibCompiled.zip and 35 | http://openil.sourceforge.net/libs/LibSrc.zip , respectively. 36 | 37 | 38 | Installation: 39 | ------------- 40 | 41 | Just unzip and compile other libs included if needed. 42 | 43 | Please also refer to MSVC++.txt for further instructions if you are using 44 | Microsoft Visual C++. 45 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/DevIL/include/IL/ilu_region.h: -------------------------------------------------------------------------------- 1 | //----------------------------------------------------------------------------- 2 | // 3 | // ImageLib Utility Sources 4 | // Copyright (C) 2000-2002 by Denton Woods 5 | // Last modified: 07/09/2002 <--Y2K Compliant! =] 6 | // 7 | // Filename: src-ILU/src/ilu_region.h 8 | // 9 | // Description: Creates an image region. 10 | // 11 | //----------------------------------------------------------------------------- 12 | 13 | #ifndef ILU_REGION_H 14 | #define ILU_REGION_H 15 | 16 | typedef struct Edge 17 | { 18 | ILint yUpper; 19 | ILfloat xIntersect, dxPerScan; 20 | struct Edge *next; 21 | } Edge; 22 | 23 | 24 | #endif//ILU_REGION_H 25 | 26 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/DevIL/include/IL/ilut_config.h: -------------------------------------------------------------------------------- 1 | #ifndef __ILUT_CONFIG_H__ 2 | #define __ILUT_CONFIG_H__ 3 | 4 | #define IL_USE_PRAGMA_LIBS 5 | 6 | // Supported APIs (ILUT) 7 | 8 | // 9 | // sorry just 10 | // can't get this one to work under windows 11 | // have disabled for the now 12 | // 13 | // will look at it some more later 14 | // 15 | // Kriss 16 | // 17 | #undef ILUT_USE_ALLEGRO 18 | 19 | #undef ILUT_USE_DIRECTX8 20 | //#define ILUT_USE_DIRECTX9 21 | //#define ILUT_USE_DIRECTX10 22 | #define ILUT_USE_OPENGL 23 | //#define ILUT_USE_SDL 24 | #define ILUT_USE_WIN32 25 | 26 | #endif//__ILUT_CONFIG_H__ 27 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/DevIL/lib/DevIL.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/samples/DevIL/lib/DevIL.lib -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/DevIL/lib/ILU.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/samples/DevIL/lib/ILU.lib -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/DevIL/lib/ILUT.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/samples/DevIL/lib/ILUT.lib -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleAssimpViewX/English.lproj/Credits.rtf: -------------------------------------------------------------------------------- 1 | {\rtf0\ansi{\fonttbl\f0\fswiss Helvetica;} 2 | {\colortbl;\red255\green255\blue255;} 3 | \paperw9840\paperh8400 4 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural 5 | 6 | \f0\b\fs24 \cf0 Engineering: 7 | \b0 \ 8 | Some people\ 9 | \ 10 | 11 | \b Human Interface Design: 12 | \b0 \ 13 | Some other people\ 14 | \ 15 | 16 | \b Testing: 17 | \b0 \ 18 | Hopefully not nobody\ 19 | \ 20 | 21 | \b Documentation: 22 | \b0 \ 23 | Whoever\ 24 | \ 25 | 26 | \b With special thanks to: 27 | \b0 \ 28 | Mom\ 29 | } 30 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleAssimpViewX/English.lproj/InfoPlist.strings: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/samples/SimpleAssimpViewX/English.lproj/InfoPlist.strings -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleAssimpViewX/MyDocument.xcdatamodel/elements: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/samples/SimpleAssimpViewX/MyDocument.xcdatamodel/elements -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleAssimpViewX/MyDocument.xcdatamodel/layout: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/samples/SimpleAssimpViewX/MyDocument.xcdatamodel/layout -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleAssimpViewX/README: -------------------------------------------------------------------------------- 1 | Mac OSX Assimp Sample, using OpenGL with VBOs 2 | ============================================= 3 | 4 | Written & donated by drparallax. 5 | See http://sourceforge.net/projects/assimp/forums/forum/817654/topic/3917829 6 | 7 | 8 | How to build: 9 | ------------- 10 | 11 | - compile Assimp as static library, copy the generated libassimp.a right here. 12 | - copy the Assimp headers from ./../../include to ./include 13 | - open the XCode project file and build it 14 | 15 | 16 | Troubleshooting: 17 | ---------------- 18 | 19 | - OSX workspaces are not updated too frequently, so same files may be missing. 20 | 21 | If you have any problems which you can't solve on your own, 22 | please report them on the thread above. -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleAssimpViewX/include/copy_assimp_headers_here.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/samples/SimpleAssimpViewX/include/copy_assimp_headers_here.txt -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleAssimpViewX/main.m: -------------------------------------------------------------------------------- 1 | // 2 | // main.m 3 | // DisplayLinkAsyncMoviePlayer 4 | // 5 | // Created by vade on 10/26/10. 6 | // Copyright __MyCompanyName__ 2010 . All rights reserved. 7 | // 8 | 9 | #import 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | return NSApplicationMain(argc, (const char **) argv); 14 | } 15 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleOpenGL/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FIND_PACKAGE(OpenGL) 2 | FIND_PACKAGE(GLUT) 3 | IF ( MSVC ) 4 | SET(M_LIB) 5 | ELSE ( MSVC ) 6 | find_library(M_LIB m) 7 | ENDIF ( MSVC ) 8 | 9 | IF ( NOT GLUT_FOUND ) 10 | IF ( MSVC ) 11 | SET ( GLUT_FOUND 1 ) 12 | SET ( GLUT_INCLUDE_DIR ${Assimp_SOURCE_DIR}/samples/glut/ ) 13 | SET ( GLUT_LIBRARIES ${Assimp_SOURCE_DIR}/samples/glut/glut32.lib ) 14 | ELSE ( MSVC ) 15 | MESSAGE( WARNING "Please install glut." ) 16 | ENDIF ( MSVC ) 17 | ENDIF ( NOT GLUT_FOUND ) 18 | 19 | if ( MSVC ) 20 | ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS ) 21 | ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS ) 22 | endif ( MSVC ) 23 | 24 | INCLUDE_DIRECTORIES( 25 | ${Assimp_SOURCE_DIR}/include 26 | ${Assimp_SOURCE_DIR}/code 27 | ${OPENGL_INCLUDE_DIR} 28 | ${GLUT_INCLUDE_DIR} 29 | ) 30 | 31 | LINK_DIRECTORIES( 32 | ${Assimp_BINARY_DIR} 33 | ${Assimp_BINARY_DIR}/lib 34 | ) 35 | 36 | ADD_EXECUTABLE( assimp_simpleogl 37 | Sample_SimpleOpenGL.c 38 | ) 39 | 40 | SET_PROPERTY(TARGET assimp_simpleogl PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX}) 41 | 42 | TARGET_LINK_LIBRARIES( assimp_simpleogl assimp ${OPENGL_LIBRARIES} ${GLUT_LIBRARIES} ${M_LIB} ) 43 | SET_TARGET_PROPERTIES( assimp_simpleogl PROPERTIES 44 | OUTPUT_NAME assimp_simpleogl 45 | ) 46 | 47 | INSTALL( TARGETS assimp_simpleogl 48 | DESTINATION "${ASSIMP_BIN_INSTALL_DIR}" COMPONENT assimp-dev 49 | ) 50 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleOpenGL/SimpleOpenGL.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 10.00 3 | # Visual Studio 2008 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimpleOpenGL", "SimpleOpenGL.vcproj", "{A53D047C-2C35-44FB-B7DB-2066FE520950}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Win32 = Debug|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {A53D047C-2C35-44FB-B7DB-2066FE520950}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {A53D047C-2C35-44FB-B7DB-2066FE520950}.Debug|Win32.Build.0 = Debug|Win32 14 | {A53D047C-2C35-44FB-B7DB-2066FE520950}.Release|Win32.ActiveCfg = Release|Win32 15 | {A53D047C-2C35-44FB-B7DB-2066FE520950}.Release|Win32.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(SolutionProperties) = preSolution 18 | HideSolutionNode = FALSE 19 | EndGlobalSection 20 | EndGlobal 21 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 15 4 | VisualStudioVersion = 15.0.26228.9 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimpleTexturedDirectx11", "SimpleTexturedDirectx11\SimpleTexturedDirectx11.vcxproj", "{E3B160B5-E71F-4F3F-9310-B8F156F736D8}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {E3B160B5-E71F-4F3F-9310-B8F156F736D8}.Debug|x64.ActiveCfg = Debug|x64 17 | {E3B160B5-E71F-4F3F-9310-B8F156F736D8}.Debug|x64.Build.0 = Debug|x64 18 | {E3B160B5-E71F-4F3F-9310-B8F156F736D8}.Debug|x86.ActiveCfg = Debug|Win32 19 | {E3B160B5-E71F-4F3F-9310-B8F156F736D8}.Debug|x86.Build.0 = Debug|Win32 20 | {E3B160B5-E71F-4F3F-9310-B8F156F736D8}.Release|x64.ActiveCfg = Release|x64 21 | {E3B160B5-E71F-4F3F-9310-B8F156F736D8}.Release|x64.Build.0 = Release|x64 22 | {E3B160B5-E71F-4F3F-9310-B8F156F736D8}.Release|x86.ActiveCfg = Release|Win32 23 | {E3B160B5-E71F-4F3F-9310-B8F156F736D8}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | EndGlobal 29 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef MODEL_LOADER_H 2 | #define MODEL_LOADER_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | #include "Mesh.h" 13 | #include "TextureLoader.h" 14 | 15 | using namespace DirectX; 16 | 17 | class ModelLoader 18 | { 19 | public: 20 | ModelLoader(); 21 | ~ModelLoader(); 22 | 23 | bool Load(HWND hwnd, ID3D11Device* dev, ID3D11DeviceContext* devcon, std::string filename); 24 | void Draw(ID3D11DeviceContext* devcon); 25 | 26 | void Close(); 27 | private: 28 | ID3D11Device *dev; 29 | ID3D11DeviceContext *devcon; 30 | std::vector meshes; 31 | string directory; 32 | vector textures_loaded; 33 | HWND hwnd; 34 | 35 | void processNode(aiNode* node, const aiScene* scene); 36 | Mesh processMesh(aiMesh* mesh, const aiScene* scene); 37 | vector loadMaterialTextures(aiMaterial* mat, aiTextureType type, string typeName, const aiScene* scene); 38 | string determineTextureType(const aiScene* scene, aiMaterial* mat); 39 | int getTextureIndex(aiString* str); 40 | ID3D11ShaderResourceView* getTextureFromModel(const aiScene* scene, int textureindex); 41 | }; 42 | 43 | #endif // !MODEL_LOADER_H 44 | 45 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/PixelShader.hlsl: -------------------------------------------------------------------------------- 1 | Texture2D diffTexture; 2 | SamplerState SampleType; 3 | 4 | float4 main(float4 pos : SV_POSITION, float2 texcoord : TEXCOORD) : SV_TARGET 5 | { 6 | float4 textureColor = diffTexture.Sample(SampleType, texcoord); 7 | 8 | return textureColor; 9 | } -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/VertexShader.hlsl: -------------------------------------------------------------------------------- 1 | cbuffer ConstantBuffer : register(b0) 2 | { 3 | matrix World; 4 | matrix View; 5 | matrix Projection; 6 | } 7 | 8 | struct VOut { 9 | float4 pos : SV_POSITION; 10 | float2 texcoord : TEXCOORD; 11 | }; 12 | 13 | VOut main(float4 pos : POSITION, float2 texcoord : TEXCOORD) 14 | { 15 | VOut output; 16 | 17 | output.pos = mul(pos, World); 18 | output.pos = mul(output.pos, View); 19 | output.pos = mul(output.pos, Projection); 20 | output.texcoord = texcoord; 21 | 22 | return output; 23 | } -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleTexturedOpenGL/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FIND_PACKAGE(OpenGL) 2 | FIND_PACKAGE(GLUT) 3 | 4 | IF ( NOT GLUT_FOUND ) 5 | IF ( MSVC ) 6 | SET ( GLUT_FOUND 1 ) 7 | SET ( GLUT_INCLUDE_DIR ${Assimp_SOURCE_DIR}/samples/glut/ ) 8 | SET ( GLUT_LIBRARIES ${Assimp_SOURCE_DIR}/samples/glut/glut32.lib ) 9 | ELSE ( MSVC ) 10 | MESSAGE( WARNING "Please install glut." ) 11 | ENDIF ( MSVC ) 12 | ENDIF ( NOT GLUT_FOUND ) 13 | 14 | if ( MSVC ) 15 | ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS ) 16 | ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS ) 17 | endif ( MSVC ) 18 | 19 | INCLUDE_DIRECTORIES( 20 | ${Assimp_SOURCE_DIR}/include 21 | ${Assimp_SOURCE_DIR}/code 22 | ${OPENGL_INCLUDE_DIR} 23 | ${GLUT_INCLUDE_DIR} 24 | ${Assimp_SOURCE_DIR}/samples/DevIL/include/ 25 | ) 26 | 27 | LINK_DIRECTORIES( 28 | ${Assimp_BINARY_DIR} 29 | ${Assimp_BINARY_DIR}/lib/ 30 | ${Assimp_SOURCE_DIR}/samples/DevIL/lib/ 31 | ) 32 | 33 | ADD_EXECUTABLE( assimp_simpletexturedogl WIN32 34 | SimpleTexturedOpenGL/include/boost_includes.h 35 | SimpleTexturedOpenGL/src/model_loading.cpp 36 | ) 37 | 38 | SET_PROPERTY(TARGET assimp_simpletexturedogl PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX}) 39 | 40 | TARGET_LINK_LIBRARIES( assimp_simpletexturedogl assimp ${OPENGL_LIBRARIES} ${GLUT_LIBRARIES} DevIL.lib ) 41 | 42 | SET_TARGET_PROPERTIES( assimp_simpletexturedogl PROPERTIES 43 | OUTPUT_NAME assimp_simpletexturedogl 44 | ) 45 | 46 | INSTALL( TARGETS assimp_simpletexturedogl 47 | DESTINATION "${ASSIMP_BIN_INSTALL_DIR}" COMPONENT assimp-dev 48 | ) 49 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 10.00 3 | # Visual Studio 2008 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimpleTexturedOpenGL", "SimpleTexturedOpenGL\SimpleTexturedOpenGL.vcproj", "{A03DCB69-BBC5-4F55-A7D1-B9100E821BBE}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Win32 = Debug|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {A03DCB69-BBC5-4F55-A7D1-B9100E821BBE}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {A03DCB69-BBC5-4F55-A7D1-B9100E821BBE}.Debug|Win32.Build.0 = Debug|Win32 14 | {A03DCB69-BBC5-4F55-A7D1-B9100E821BBE}.Release|Win32.ActiveCfg = Release|Win32 15 | {A03DCB69-BBC5-4F55-A7D1-B9100E821BBE}.Release|Win32.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(SolutionProperties) = preSolution 18 | HideSolutionNode = FALSE 19 | EndGlobalSection 20 | EndGlobal 21 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/include/boost_includes.h: -------------------------------------------------------------------------------- 1 | #include -------------------------------------------------------------------------------- /Framework/Externals/Assimp/samples/glut/glut32.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/samples/glut/glut32.lib -------------------------------------------------------------------------------- /Framework/Externals/Assimp/scripts/AppVeyor/cacheglobs.txt: -------------------------------------------------------------------------------- 1 | code/*.{%{cpp}} 2 | contrib/**/*.{%{cpp}} 3 | include/**/*.{%{cpp}} 4 | test/**/*.{%{cpp}} 5 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/scripts/IFCImporter/genentitylist.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cd ../../code 3 | grep -E 'Ifc([A-Z][a-z]*)+' -o IFCLoader.cpp IFCGeometry.cpp IFCCurve.cpp IFCProfile.cpp IFCMaterial.cpp | uniq | sed s/.*:// > ../scripts/IFCImporter/output.txt 4 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/scripts/OgreImporter/assimp.tpl: -------------------------------------------------------------------------------- 1 | 2 | material %_materialName 3 | { 4 | set $specular %_specular 5 | set $diffuse %_diffuse 6 | set $ambient %_ambient 7 | 8 | set $colormap %color._texture 9 | set $normalmap %normal._texture 10 | } 11 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/scripts/adjust_header_paths.sh: -------------------------------------------------------------------------------- 1 | declare -a headers=("fast_atof.h" 2 | "qnan.h" 3 | "BaseImporter.h" 4 | "Hash.h" 5 | "MemoryIOWrapper.h" 6 | "ParsingUtils.h" 7 | "StreamReader.h" 8 | "StreamWriter.h" 9 | "StringComparison.h" 10 | "StringUtils.h" 11 | "SGSpatialSort.h" 12 | "GenericProperty.h" 13 | "SpatialSort.h" 14 | "SkeletonMeshBuilder.h" 15 | "SmoothingGroups.h" 16 | "StandardShapes.h" 17 | "RemoveComments.h" 18 | "Subdivision.h" 19 | "Vertex.h" 20 | "LineSplitter.h" 21 | "TinyFormatter.h" 22 | "Profiler.h" 23 | "LogAux.h" 24 | "Bitmap.h" 25 | "XMLTools.h" 26 | "IOStreamBuffer.h" 27 | "CreateAnimMesh.h" 28 | "irrXMLWrapper.h" 29 | "BlobIOSystem.h" 30 | "MathFunctions.h" 31 | "Macros.h" 32 | "Exceptional.h" 33 | "ByteSwapper.h") 34 | 35 | for i in "${headers[@]}" 36 | do 37 | find . -type f -exec sed -i "s,<../code/$i>,,g" {} \; 38 | done 39 | -------------------------------------------------------------------------------- /Framework/Externals/Assimp/scripts/android_crosscompile/make_android.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | 3 | set ASSIMP_PATH=D:\projects\asset-importer-lib\assimp 4 | set CMAKE_PATH="C:\Program Files\CMake\bin\cmake.exe" 5 | set ANDROID_NDK_PATH=C:\Users\kimkulling\AppData\Local\Android\Sdk\ndk-bundle 6 | set ANDROID_CMAKE_PATH=contrib\android-cmake 7 | 8 | pushd %ASSIMP_PATH% 9 | 10 | rmdir /s /q build 11 | mkdir build 12 | cd build 13 | 14 | %CMAKE_PATH% .. ^ 15 | -G"MinGW Makefiles" ^ 16 | -DCMAKE_BUILD_TYPE=Release ^ 17 | -DCMAKE_TOOLCHAIN_FILE=%ANDROID_CMAKE_PATH%\android.toolchain.cmake ^ 18 | -DCMAKE_MAKE_PROGRAM=%ANDROID_NDK_PATH%\prebuilt\windows-x86_64\bin\make.exe ^ 19 | -DANDROID_NDK=%ANDROID_NDK_PATH% ^ 20 | -DANDROID_NATIVE_API_LEVEL=android-9 ^ 21 | -DASSIMP_ANDROID_JNIIOSYSTEM=ON ^ 22 | -DANDROID_ABI=arm64-v8a ^ 23 | -DASSIMP_BUILD_ZLIB=ON ^ 24 | -DASSIMP_BUILD_TESTS=OFF 25 | 26 | %CMAKE_PATH% --build . 27 | 28 | popd -------------------------------------------------------------------------------- /Framework/Externals/Assimp/stub/vc_redist.x64.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/stub/vc_redist.x64.exe -------------------------------------------------------------------------------- /Framework/Externals/Assimp/unins000.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/unins000.dat -------------------------------------------------------------------------------- /Framework/Externals/Assimp/unins000.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/Assimp/unins000.exe -------------------------------------------------------------------------------- /Framework/Externals/DirectXTex/Shaders/CompileShaders.cmd: -------------------------------------------------------------------------------- 1 | @echo off 2 | rem Copyright (c) Microsoft Corporation. All rights reserved. 3 | rem Licensed under the MIT License. 4 | 5 | setlocal 6 | set error=0 7 | 8 | set FXCOPTS=/nologo /WX /Ges /Zi /Zpc /Qstrip_reflect /Qstrip_debug 9 | 10 | set PCFXC="%WindowsSdkBinPath%%WindowsSDKVersion%\x86\fxc.exe" 11 | if exist %PCFXC% goto continue 12 | set PCFXC="%WindowsSdkDir%bin\%WindowsSDKVersion%\x86\fxc.exe" 13 | if exist %PCFXC% goto continue 14 | set PCFXC="%WindowsSdkDir%bin\x86\fxc.exe" 15 | if exist %PCFXC% goto continue 16 | 17 | set PCFXC=fxc.exe 18 | 19 | :continue 20 | @if not exist Compiled mkdir Compiled 21 | call :CompileShader BC7Encode TryMode456CS 22 | call :CompileShader BC7Encode TryMode137CS 23 | call :CompileShader BC7Encode TryMode02CS 24 | call :CompileShader BC7Encode EncodeBlockCS 25 | 26 | call :CompileShader BC6HEncode TryModeG10CS 27 | call :CompileShader BC6HEncode TryModeLE10CS 28 | call :CompileShader BC6HEncode EncodeBlockCS 29 | 30 | echo. 31 | 32 | if %error% == 0 ( 33 | echo Shaders compiled ok 34 | ) else ( 35 | echo There were shader compilation errors! 36 | ) 37 | 38 | endlocal 39 | exit /b 40 | 41 | :CompileShader 42 | set fxc=%PCFXC% %1.hlsl %FXCOPTS% /Tcs_4_0 /E%2 /FhCompiled\%1_%2.inc /FdCompiled\%1_%2.pdb /Vn%1_%2 43 | echo. 44 | echo %fxc% 45 | %fxc% || set error=1 46 | exit /b 47 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/.packman.sha1: -------------------------------------------------------------------------------- 1 | d7cdd0c33147e789695afda1608cf2bcb04ceb62 -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/GLM/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/matrix_float2x3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix_precision 10 | /// @{ 11 | 12 | /// 2 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef mat<2, 3, float, lowp> lowp_mat2x3; 17 | 18 | /// 2 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<2, 3, float, mediump> mediump_mat2x3; 23 | 24 | /// 2 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef mat<2, 3, float, highp> highp_mat2x3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/matrix_float2x4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x4_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix_precision 10 | /// @{ 11 | 12 | /// 2 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef mat<2, 4, float, lowp> lowp_mat2x4; 17 | 18 | /// 2 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<2, 4, float, mediump> mediump_mat2x4; 23 | 24 | /// 2 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef mat<2, 4, float, highp> highp_mat2x4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/matrix_float3x2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix_precision 10 | /// @{ 11 | 12 | /// 3 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef mat<3, 2, float, lowp> lowp_mat3x2; 17 | 18 | /// 3 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<3, 2, float, mediump> mediump_mat3x2; 23 | 24 | /// 3 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef mat<3, 2, float, highp> highp_mat3x2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/matrix_float3x4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x4_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix_precision 10 | /// @{ 11 | 12 | /// 3 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef mat<3, 4, float, lowp> lowp_mat3x4; 17 | 18 | /// 3 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<3, 4, float, mediump> mediump_mat3x4; 23 | 24 | /// 3 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef mat<3, 4, float, highp> highp_mat3x4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/matrix_float4x2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix_precision 10 | /// @{ 11 | 12 | /// 4 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef mat<4, 2, float, lowp> lowp_mat4x2; 17 | 18 | /// 4 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef mat<4, 2, float, mediump> mediump_mat4x2; 23 | 24 | /// 4 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef mat<4, 2, float, highp> highp_mat4x2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/quaternion_double_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_quaternion_double_precision 2 | /// @file glm/ext/quaternion_double_precision.hpp 3 | /// 4 | /// @defgroup ext_quaternion_double_precision GLM_EXT_quaternion_double_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes double-precision floating point quaternion type with various precision in term of ULPs. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | // Dependency: 14 | #include "../detail/type_quat.hpp" 15 | 16 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 17 | # pragma message("GLM: GLM_EXT_quaternion_double_precision extension included") 18 | #endif 19 | 20 | namespace glm 21 | { 22 | /// @addtogroup ext_quaternion_double_precision 23 | /// @{ 24 | 25 | /// Quaternion of double-precision floating-point numbers using high precision arithmetic in term of ULPs. 26 | /// 27 | /// @see ext_quaternion_double_precision 28 | typedef qua lowp_dquat; 29 | 30 | /// Quaternion of medium double-qualifier floating-point numbers using high precision arithmetic in term of ULPs. 31 | /// 32 | /// @see ext_quaternion_double_precision 33 | typedef qua mediump_dquat; 34 | 35 | /// Quaternion of high double-qualifier floating-point numbers using high precision arithmetic in term of ULPs. 36 | /// 37 | /// @see ext_quaternion_double_precision 38 | typedef qua highp_dquat; 39 | 40 | /// @} 41 | } //namespace glm 42 | 43 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/quaternion_transform.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_quaternion_transform 2 | /// @file glm/ext/quaternion_transform.hpp 3 | /// 4 | /// @defgroup ext_quaternion_transform GLM_EXT_quaternion_transform 5 | /// @ingroup ext 6 | /// 7 | /// Provides transformation functions for quaternion types 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_quaternion_float 12 | /// @see ext_quaternion_double 13 | /// @see ext_quaternion_exponential 14 | /// @see ext_quaternion_geometric 15 | /// @see ext_quaternion_relational 16 | /// @see ext_quaternion_trigonometric 17 | 18 | #pragma once 19 | 20 | // Dependency: 21 | #include "../common.hpp" 22 | #include "../trigonometric.hpp" 23 | #include "../geometric.hpp" 24 | 25 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_EXT_quaternion_transform extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup ext_quaternion_transform 32 | /// @{ 33 | 34 | /// Rotates a quaternion from a vector of 3 components axis and an angle. 35 | /// 36 | /// @param q Source orientation 37 | /// @param angle Angle expressed in radians. 38 | /// @param axis Axis of the rotation 39 | /// 40 | /// @tparam T Floating-point scalar types 41 | /// @tparam Q Value from qualifier enum 42 | template 43 | GLM_FUNC_DECL qua rotate(qua const& q, T const& angle, vec<3, T, Q> const& axis); 44 | /// @} 45 | } //namespace glm 46 | 47 | #include "quaternion_transform.inl" 48 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/quaternion_trigonometric.inl: -------------------------------------------------------------------------------- 1 | namespace glm 2 | { 3 | template 4 | GLM_FUNC_QUALIFIER T angle(qua const& x) 5 | { 6 | return acos(x.w) * static_cast(2); 7 | } 8 | 9 | template 10 | GLM_FUNC_QUALIFIER vec<3, T, Q> axis(qua const& x) 11 | { 12 | T const tmp1 = static_cast(1) - x.w * x.w; 13 | if(tmp1 <= static_cast(0)) 14 | return vec<3, T, Q>(0, 0, 1); 15 | T const tmp2 = static_cast(1) / sqrt(tmp1); 16 | return vec<3, T, Q>(x.x * tmp2, x.y * tmp2, x.z * tmp2); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER qua angleAxis(T const& angle, vec<3, T, Q> const& v) 21 | { 22 | T const a(angle); 23 | T const s = glm::sin(a * static_cast(0.5)); 24 | 25 | return qua(glm::cos(a * static_cast(0.5)), v * s); 26 | } 27 | }//namespace glm 28 | -------------------------------------------------------------------------------- /Framework/Externals/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 | /// @} 34 | } //namespace glm 35 | 36 | #include "scalar_constants.inl" 37 | -------------------------------------------------------------------------------- /Framework/Externals/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, "'epsilon' only accepts floating-point inputs"); 16 | return static_cast(3.14159265358979323846264338327950288); 17 | } 18 | } //namespace glm 19 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/scalar_float_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_float_sized 2 | /// @file glm/ext/scalar_float_sized.hpp 3 | /// 4 | /// @defgroup ext_scalar_float_sized GLM_EXT_scalar_float_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized float scalar types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_scalar_uint_sized 13 | 14 | #pragma once 15 | 16 | #include "../detail/setup.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_scalar_float_sized extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_scalar_float_sized 25 | /// @{ 26 | 27 | /// Single precision floating-point numbers. 28 | typedef float float32; 29 | 30 | 31 | # ifndef GLM_FORCE_SINGLE_ONLY 32 | 33 | /// Double precision floating-point numbers. 34 | typedef double float64; 35 | 36 | # endif//GLM_FORCE_SINGLE_ONLY 37 | 38 | /// @} 39 | }//namespace glm 40 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/scalar_int_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_int_sized 2 | /// @file glm/ext/scalar_int_sized.hpp 3 | /// 4 | /// @defgroup ext_scalar_int_sized GLM_EXT_scalar_int_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer scalar types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | 13 | #pragma once 14 | 15 | #include "../detail/setup.hpp" 16 | 17 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 18 | # pragma message("GLM: GLM_EXT_scalar_int_sized extension included") 19 | #endif 20 | 21 | namespace glm{ 22 | namespace detail 23 | { 24 | # if GLM_HAS_EXTENDED_INTEGER_TYPE 25 | typedef std::int8_t int8; 26 | typedef std::int16_t int16; 27 | typedef std::int32_t int32; 28 | # else 29 | typedef char int8; 30 | typedef short int16; 31 | typedef int int32; 32 | #endif// 33 | 34 | template<> 35 | struct is_int 36 | { 37 | enum test {value = ~0}; 38 | }; 39 | 40 | template<> 41 | struct is_int 42 | { 43 | enum test {value = ~0}; 44 | }; 45 | 46 | template<> 47 | struct is_int 48 | { 49 | enum test {value = ~0}; 50 | }; 51 | }//namespace detail 52 | 53 | 54 | /// @addtogroup ext_scalar_int_sized 55 | /// @{ 56 | 57 | /// 8 bit signed integer type. 58 | typedef detail::int8 int8; 59 | 60 | /// 16 bit signed integer type. 61 | typedef detail::int16 int16; 62 | 63 | /// 32 bit signed integer type. 64 | typedef detail::int32 int32; 65 | 66 | /// 64 bit signed integer type. 67 | typedef detail::int64 int64; 68 | 69 | /// @} 70 | }//namespace glm 71 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/scalar_relational.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_relational 2 | /// @file glm/ext/scalar_relational.hpp 3 | /// 4 | /// @defgroup ext_scalar_relational GLM_EXT_scalar_relational 5 | /// @ingroup ext 6 | /// 7 | /// Exposes comparison functions for scalar types that take a user defined epsilon values. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see core_vector_relational 12 | /// @see ext_vector_relational 13 | /// @see ext_matrix_relational 14 | 15 | #pragma once 16 | 17 | // Dependencies 18 | #include "../detail/qualifier.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_EXT_scalar_relational extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// Returns the component-wise comparison of |x - y| < epsilon. 27 | /// True if this expression is satisfied. 28 | /// 29 | /// @tparam genType Floating-point or integer scalar types 30 | template 31 | GLM_FUNC_DECL GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon); 32 | 33 | /// Returns the component-wise comparison of |x - y| >= epsilon. 34 | /// True if this expression is not satisfied. 35 | /// 36 | /// @tparam genType Floating-point or integer scalar types 37 | template 38 | GLM_FUNC_DECL GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon); 39 | 40 | /// @} 41 | }//namespace glm 42 | 43 | #include "scalar_relational.inl" 44 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/scalar_relational.inl: -------------------------------------------------------------------------------- 1 | #include "../common.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon) 7 | { 8 | return abs(x - y) <= epsilon; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon) 13 | { 14 | return abs(x - y) > epsilon; 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/scalar_uint_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_uint_sized 2 | /// @file glm/ext/scalar_uint_sized.hpp 3 | /// 4 | /// @defgroup ext_scalar_uint_sized GLM_EXT_scalar_uint_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer scalar types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | 13 | #pragma once 14 | 15 | #include "../detail/setup.hpp" 16 | 17 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 18 | # pragma message("GLM: GLM_EXT_scalar_uint_sized extension included") 19 | #endif 20 | 21 | namespace glm{ 22 | namespace detail 23 | { 24 | # if GLM_HAS_EXTENDED_INTEGER_TYPE 25 | typedef std::uint8_t uint8; 26 | typedef std::uint16_t uint16; 27 | typedef std::uint32_t uint32; 28 | # else 29 | typedef unsigned char uint8; 30 | typedef unsigned short uint16; 31 | typedef unsigned int uint32; 32 | #endif 33 | 34 | template<> 35 | struct is_int 36 | { 37 | enum test {value = ~0}; 38 | }; 39 | 40 | template<> 41 | struct is_int 42 | { 43 | enum test {value = ~0}; 44 | }; 45 | 46 | template<> 47 | struct is_int 48 | { 49 | enum test {value = ~0}; 50 | }; 51 | }//namespace detail 52 | 53 | 54 | /// @addtogroup ext_scalar_uint_sized 55 | /// @{ 56 | 57 | /// 8 bit unsigned integer type. 58 | typedef detail::uint8 uint8; 59 | 60 | /// 16 bit unsigned integer type. 61 | typedef detail::uint16 uint16; 62 | 63 | /// 32 bit unsigned integer type. 64 | typedef detail::uint32 uint32; 65 | 66 | /// 64 bit unsigned integer type. 67 | typedef detail::uint64 uint64; 68 | 69 | /// @} 70 | }//namespace glm 71 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_bool2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 2 components vector of high qualifier bool numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<2, bool, highp> highp_bvec2; 17 | 18 | /// 2 components vector of medium qualifier bool numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<2, bool, mediump> mediump_bvec2; 23 | 24 | /// 2 components vector of low qualifier bool numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<2, bool, lowp> lowp_bvec2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_bool3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 3 components vector of high qualifier bool numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<3, bool, highp> highp_bvec3; 17 | 18 | /// 3 components vector of medium qualifier bool numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<3, bool, mediump> mediump_bvec3; 23 | 24 | /// 3 components vector of low qualifier bool numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<3, bool, lowp> lowp_bvec3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_bool4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool4_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 4 components vector of high qualifier bool numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<4, bool, highp> highp_bvec4; 17 | 18 | /// 4 components vector of medium qualifier bool numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<4, bool, mediump> mediump_bvec4; 23 | 24 | /// 4 components vector of low qualifier bool numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<4, bool, lowp> lowp_bvec4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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_dvec1 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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_double2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 2 components vector of high double-qualifier floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<2, double, highp> highp_dvec2; 17 | 18 | /// 2 components vector of medium double-qualifier floating-point numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<2, double, mediump> mediump_dvec2; 23 | 24 | /// 2 components vector of low double-qualifier floating-point numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<2, double, lowp> lowp_dvec2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_double3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 3 components vector of high double-qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef vec<3, double, highp> highp_dvec3; 18 | 19 | /// 3 components vector of medium double-qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef vec<3, double, mediump> mediump_dvec3; 25 | 26 | /// 3 components vector of low double-qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef vec<3, double, lowp> lowp_dvec3; 32 | 33 | /// @} 34 | }//namespace glm 35 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_float2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 2 components vector of high single-qualifier floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<2, float, highp> highp_vec2; 17 | 18 | /// 2 components vector of medium single-qualifier floating-point numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<2, float, mediump> mediump_vec2; 23 | 24 | /// 2 components vector of low single-qualifier floating-point numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<2, float, lowp> lowp_vec2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_float3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 3 components vector of high single-qualifier floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<3, float, highp> highp_vec3; 17 | 18 | /// 3 components vector of medium single-qualifier floating-point numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<3, float, mediump> mediump_vec3; 23 | 24 | /// 3 components vector of low single-qualifier floating-point numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<3, float, lowp> lowp_vec3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_float4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float4_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 4 components vector of high single-qualifier floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<4, float, highp> highp_vec4; 17 | 18 | /// 4 components vector of medium single-qualifier floating-point numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<4, float, mediump> mediump_vec4; 23 | 24 | /// 4 components vector of low single-qualifier floating-point numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<4, float, lowp> lowp_vec4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_int1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int1_precision 2 | /// @file glm/ext/vector_int1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_int1_precision GLM_EXT_vector_int1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_ivec1, mediump_ivec1 and lowp_ivec1 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_int1_precision extension included") 17 | #endif 18 | 19 | namespace glm 20 | { 21 | /// @addtogroup ext_vector_int1_precision 22 | /// @{ 23 | 24 | /// 1 component vector of signed integer values. 25 | typedef vec<1, int, highp> highp_ivec1; 26 | 27 | /// 1 component vector of signed integer values. 28 | typedef vec<1, int, mediump> mediump_ivec1; 29 | 30 | /// 1 component vector of signed integer values. 31 | typedef vec<1, int, lowp> lowp_ivec1; 32 | 33 | /// @} 34 | }//namespace glm 35 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_int2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 2 components vector of high qualifier signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<2, int, highp> highp_ivec2; 17 | 18 | /// 2 components vector of medium qualifier signed integer numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<2, int, mediump> mediump_ivec2; 23 | 24 | /// 2 components vector of low qualifier signed integer numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<2, int, lowp> lowp_ivec2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_int3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 3 components vector of high qualifier signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<3, int, highp> highp_ivec3; 17 | 18 | /// 3 components vector of medium qualifier signed integer numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<3, int, mediump> mediump_ivec3; 23 | 24 | /// 3 components vector of low qualifier signed integer numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<3, int, lowp> lowp_ivec3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_int4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int4_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 4 components vector of high qualifier signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<4, int, highp> highp_ivec4; 17 | 18 | /// 4 components vector of medium qualifier signed integer numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<4, int, mediump> mediump_ivec4; 23 | 24 | /// 4 components vector of low qualifier signed integer numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<4, int, lowp> lowp_ivec4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_relational.inl: -------------------------------------------------------------------------------- 1 | #include "../vector_relational.hpp" 2 | #include "../common.hpp" 3 | #include "../detail/qualifier.hpp" 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(vec const& x, vec const& y, T Epsilon) 9 | { 10 | return equal(x, y, vec(Epsilon)); 11 | } 12 | 13 | template 14 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(vec const& x, vec const& y, vec const& Epsilon) 15 | { 16 | return lessThanEqual(abs(x - y), Epsilon); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, T Epsilon) 21 | { 22 | return notEqual(x, y, vec(Epsilon)); 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, vec const& Epsilon) 27 | { 28 | return greaterThan(abs(x - y), Epsilon); 29 | } 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_uint1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint1_precision 2 | /// @file glm/ext/vector_uint1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_uint1_precision GLM_EXT_vector_uint1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_uvec1, mediump_uvec1 and lowp_uvec1 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_uint1_precision extension included") 17 | #endif 18 | 19 | namespace glm 20 | { 21 | /// @addtogroup ext_vector_uint1_precision 22 | /// @{ 23 | 24 | /// 1 component vector of unsigned integer values. 25 | /// 26 | /// @see ext_vector_uint1_precision 27 | typedef vec<1, unsigned int, highp> highp_uvec1; 28 | 29 | /// 1 component vector of unsigned integer values. 30 | /// 31 | /// @see ext_vector_uint1_precision 32 | typedef vec<1, unsigned int, mediump> mediump_uvec1; 33 | 34 | /// 1 component vector of unsigned integer values. 35 | /// 36 | /// @see ext_vector_uint1_precision 37 | typedef vec<1, unsigned int, lowp> lowp_uvec1; 38 | 39 | /// @} 40 | }//namespace glm 41 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_uint2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 2 components vector of high qualifier unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<2, unsigned int, highp> highp_uvec2; 17 | 18 | /// 2 components vector of medium qualifier unsigned integer numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<2, unsigned int, mediump> mediump_uvec2; 23 | 24 | /// 2 components vector of low qualifier unsigned integer numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<2, unsigned int, lowp> lowp_uvec2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_uint3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 3 components vector of high qualifier unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<3, unsigned int, highp> highp_uvec3; 17 | 18 | /// 3 components vector of medium qualifier unsigned integer numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<3, unsigned int, mediump> mediump_uvec3; 23 | 24 | /// 3 components vector of low qualifier unsigned integer numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<3, unsigned int, lowp> lowp_uvec3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/ext/vector_uint4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint4_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 4 components vector of high qualifier unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<4, unsigned int, highp> highp_uvec4; 17 | 18 | /// 4 components vector of medium qualifier unsigned integer numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<4, unsigned int, mediump> mediump_uvec4; 23 | 24 | /// 4 components vector of low qualifier unsigned integer numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<4, unsigned int, lowp> lowp_uvec4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtc/matrix_access.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_access 2 | /// @file glm/gtc/matrix_access.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_matrix_access GLM_GTC_matrix_access 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines functions to access rows or columns of a matrix easily. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../detail/setup.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_GTC_matrix_access extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup gtc_matrix_access 25 | /// @{ 26 | 27 | /// Get a specific row of a matrix. 28 | /// @see gtc_matrix_access 29 | template 30 | GLM_FUNC_DECL typename genType::row_type row( 31 | genType const& m, 32 | length_t index); 33 | 34 | /// Set a specific row to a matrix. 35 | /// @see gtc_matrix_access 36 | template 37 | GLM_FUNC_DECL genType row( 38 | genType const& m, 39 | length_t index, 40 | typename genType::row_type const& x); 41 | 42 | /// Get a specific column of a matrix. 43 | /// @see gtc_matrix_access 44 | template 45 | GLM_FUNC_DECL typename genType::col_type column( 46 | genType const& m, 47 | length_t index); 48 | 49 | /// Set a specific column to a matrix. 50 | /// @see gtc_matrix_access 51 | template 52 | GLM_FUNC_DECL genType column( 53 | genType const& m, 54 | length_t index, 55 | typename genType::col_type const& x); 56 | 57 | /// @} 58 | }//namespace glm 59 | 60 | #include "matrix_access.inl" 61 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtc/matrix_inverse.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_inverse 2 | /// @file glm/gtc/matrix_inverse.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines additional matrix inverting functions. 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | #include "../matrix.hpp" 18 | #include "../mat2x2.hpp" 19 | #include "../mat3x3.hpp" 20 | #include "../mat4x4.hpp" 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTC_matrix_inverse extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtc_matrix_inverse 29 | /// @{ 30 | 31 | /// Fast matrix inverse for affine matrix. 32 | /// 33 | /// @param m Input matrix to invert. 34 | /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. 35 | /// @see gtc_matrix_inverse 36 | template 37 | GLM_FUNC_DECL genType affineInverse(genType const& m); 38 | 39 | /// Compute the inverse transpose of a matrix. 40 | /// 41 | /// @param m Input matrix to invert transpose. 42 | /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. 43 | /// @see gtc_matrix_inverse 44 | template 45 | GLM_FUNC_DECL genType inverseTranspose(genType const& m); 46 | 47 | /// @} 48 | }//namespace glm 49 | 50 | #include "matrix_inverse.inl" 51 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtc/matrix_transform.inl: -------------------------------------------------------------------------------- 1 | #include "../geometric.hpp" 2 | #include "../trigonometric.hpp" 3 | #include "../matrix.hpp" 4 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/GLM/glm/gtc/quaternion_simd.inl -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /Framework/Externals/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_precision.hpp" 24 | #include "../ext/vector_uint1.hpp" 25 | #include "../ext/vector_uint1_precision.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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/closest_point.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_closest_point 2 | /// @file glm/gtx/closest_point.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_closest_point GLM_GTX_closest_point 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Find the point on a straight line which is the closet of a point. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_closest_point extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_closest_point 29 | /// @{ 30 | 31 | /// Find the point on a straight line which is the closet of a point. 32 | /// @see gtx_closest_point 33 | template 34 | GLM_FUNC_DECL vec<3, T, Q> closestPointOnLine( 35 | vec<3, T, Q> const& point, 36 | vec<3, T, Q> const& a, 37 | vec<3, T, Q> const& b); 38 | 39 | /// 2d lines work as well 40 | template 41 | GLM_FUNC_DECL vec<2, T, Q> closestPointOnLine( 42 | vec<2, T, Q> const& point, 43 | vec<2, T, Q> const& a, 44 | vec<2, T, Q> const& b); 45 | 46 | /// @} 47 | }// namespace glm 48 | 49 | #include "closest_point.inl" 50 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/color_encoding.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_encoding 2 | /// @file glm/gtx/color_encoding.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_color_encoding (dependence) 6 | /// 7 | /// @defgroup gtx_color_encoding GLM_GTX_color_encoding 8 | /// @ingroup gtx 9 | /// 10 | /// 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 "../vec3.hpp" 20 | #include 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTC_color_encoding extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_encoding 29 | /// @{ 30 | 31 | /// Convert a linear sRGB color to D65 YUV. 32 | template 33 | GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB); 34 | 35 | /// Convert a linear sRGB color to D50 YUV. 36 | template 37 | GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB); 38 | 39 | /// Convert a D65 YUV color to linear sRGB. 40 | template 41 | GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ); 42 | 43 | /// Convert a D65 YUV color to D50 YUV. 44 | template 45 | GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ); 46 | 47 | /// @} 48 | } //namespace glm 49 | 50 | #include "color_encoding.inl" 51 | -------------------------------------------------------------------------------- /Framework/Externals/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_extend extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_extend 29 | /// @{ 30 | 31 | /// Extends of Length the Origin position using the (Source - Origin) direction. 32 | /// @see gtx_extend 33 | template 34 | GLM_FUNC_DECL genType extend( 35 | genType const& Origin, 36 | genType const& Source, 37 | typename genType::value_type const Length); 38 | 39 | /// @} 40 | }//namespace glm 41 | 42 | #include "extend.inl" 43 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/exterior_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_exterior_product 2 | /// @file glm/gtx/exterior_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_exterior_product (dependence) 6 | /// 7 | /// @defgroup gtx_exterior_product GLM_GTX_exterior_product 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// @brief Allow to perform bit operations on integer values 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTX_exterior_product extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtx_exterior_product 27 | /// @{ 28 | 29 | /// Returns the cross product of x and y. 30 | /// 31 | /// @tparam T Floating-point scalar types 32 | /// @tparam Q Value from qualifier enum 33 | /// 34 | /// @see Exterior product 35 | template 36 | GLM_FUNC_DECL T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u); 37 | 38 | /// @} 39 | } //namespace glm 40 | 41 | #include "exterior_product.inl" 42 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/functions.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_functions 2 | /// @file glm/gtx/functions.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_quaternion (dependence) 6 | /// 7 | /// @defgroup gtx_functions GLM_GTX_functions 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// List of useful common functions. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | #include "../detail/type_vec2.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # pragma message("GLM: GLM_GTX_functions extension included") 23 | #endif 24 | 25 | namespace glm 26 | { 27 | /// @addtogroup gtx_functions 28 | /// @{ 29 | 30 | /// 1D gauss function 31 | /// 32 | /// @see gtc_epsilon 33 | template 34 | GLM_FUNC_DECL T gauss( 35 | T x, 36 | T ExpectedValue, 37 | T StandardDeviation); 38 | 39 | /// 2D gauss function 40 | /// 41 | /// @see gtc_epsilon 42 | template 43 | GLM_FUNC_DECL T gauss( 44 | vec<2, T, Q> const& Coord, 45 | vec<2, T, Q> const& ExpectedValue, 46 | vec<2, T, Q> const& StandardDeviation); 47 | 48 | /// @} 49 | }//namespace glm 50 | 51 | #include "functions.inl" 52 | 53 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/gradient_paint.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | /// @file glm/gtx/gradient_paint.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_optimum_pow (dependence) 6 | /// 7 | /// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Functions that return the color of procedural gradient for specific coordinates. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include "../gtx/optimum_pow.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_gradient_paint is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 22 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_gradient_paint extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_gradient_paint 31 | /// @{ 32 | 33 | /// Return a color from a radial gradient. 34 | /// @see - gtx_gradient_paint 35 | template 36 | GLM_FUNC_DECL T radialGradient( 37 | vec<2, T, Q> const& Center, 38 | T const& Radius, 39 | vec<2, T, Q> const& Focal, 40 | vec<2, T, Q> const& Position); 41 | 42 | /// Return a color from a linear gradient. 43 | /// @see - gtx_gradient_paint 44 | template 45 | GLM_FUNC_DECL T linearGradient( 46 | vec<2, T, Q> const& Point0, 47 | vec<2, T, Q> const& Point1, 48 | vec<2, T, Q> const& Position); 49 | 50 | /// @} 51 | }// namespace glm 52 | 53 | #include "gradient_paint.inl" 54 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_log_base is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_log_base extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_log_base 29 | /// @{ 30 | 31 | /// Logarithm for any base. 32 | /// From GLM_GTX_log_base. 33 | template 34 | GLM_FUNC_DECL genType log( 35 | genType const& x, 36 | genType const& base); 37 | 38 | /// Logarithm for any base. 39 | /// From GLM_GTX_log_base. 40 | template 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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/matrix_cross_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | /// @file glm/gtx/matrix_cross_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Build cross product matrices 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_matrix_cross_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_matrix_cross_product extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_matrix_cross_product 30 | /// @{ 31 | 32 | //! Build a cross product matrix. 33 | //! From GLM_GTX_matrix_cross_product extension. 34 | template 35 | GLM_FUNC_DECL mat<3, 3, T, Q> matrixCross3( 36 | vec<3, T, Q> const& x); 37 | 38 | //! Build a cross product matrix. 39 | //! From GLM_GTX_matrix_cross_product extension. 40 | template 41 | GLM_FUNC_DECL mat<4, 4, T, Q> matrixCross4( 42 | vec<3, T, Q> const& x); 43 | 44 | /// @} 45 | }//namespace glm 46 | 47 | #include "matrix_cross_product.inl" 48 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/matrix_decompose.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_decompose 2 | /// @file glm/gtx/matrix_decompose.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Decomposes a model matrix to translations, rotation and scale components 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../mat4x4.hpp" 17 | #include "../vec3.hpp" 18 | #include "../vec4.hpp" 19 | #include "../geometric.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | #include "../gtc/matrix_transform.hpp" 22 | 23 | #ifndef GLM_ENABLE_EXPERIMENTAL 24 | # error "GLM: GLM_GTX_matrix_decompose is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 25 | #endif 26 | 27 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTX_matrix_decompose extension included") 29 | #endif 30 | 31 | namespace glm 32 | { 33 | /// @addtogroup gtx_matrix_decompose 34 | /// @{ 35 | 36 | /// Decomposes a model matrix to translations, rotation and scale components 37 | /// @see gtx_matrix_decompose 38 | template 39 | GLM_FUNC_DECL bool decompose( 40 | mat<4, 4, T, Q> const& modelMatrix, 41 | vec<3, T, Q> & scale, qua & orientation, vec<3, T, Q> & translation, vec<3, T, Q> & skew, vec<4, T, Q> & perspective); 42 | 43 | /// @} 44 | }//namespace glm 45 | 46 | #include "matrix_decompose.inl" 47 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/GLM/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/matrix_transform_2d.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_transform_2d 2 | /// @author Miguel Ángel Pérez Martínez 3 | 4 | #include "../trigonometric.hpp" 5 | 6 | namespace glm 7 | { 8 | 9 | template 10 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate( 11 | mat<3, 3, T, Q> const& m, 12 | vec<2, T, Q> const& v) 13 | { 14 | mat<3, 3, T, Q> Result(m); 15 | Result[2] = m[0] * v[0] + m[1] * v[1] + m[2]; 16 | return Result; 17 | } 18 | 19 | 20 | template 21 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate( 22 | mat<3, 3, T, Q> const& m, 23 | T angle) 24 | { 25 | T const a = angle; 26 | T const c = cos(a); 27 | T const s = sin(a); 28 | 29 | mat<3, 3, T, Q> Result; 30 | Result[0] = m[0] * c + m[1] * s; 31 | Result[1] = m[0] * -s + m[1] * c; 32 | Result[2] = m[2]; 33 | return Result; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale( 38 | mat<3, 3, T, Q> const& m, 39 | vec<2, T, Q> const& v) 40 | { 41 | mat<3, 3, T, Q> Result; 42 | Result[0] = m[0] * v[0]; 43 | Result[1] = m[1] * v[1]; 44 | Result[2] = m[2]; 45 | return Result; 46 | } 47 | 48 | template 49 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX( 50 | mat<3, 3, T, Q> const& m, 51 | T y) 52 | { 53 | mat<3, 3, T, Q> Result(1); 54 | Result[0][1] = y; 55 | return m * Result; 56 | } 57 | 58 | template 59 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY( 60 | mat<3, 3, T, Q> const& m, 61 | T x) 62 | { 63 | mat<3, 3, T, Q> Result(1); 64 | Result[1][0] = x; 65 | return m * Result; 66 | } 67 | 68 | }//namespace glm 69 | -------------------------------------------------------------------------------- /Framework/Externals/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_mixed_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_mixed_product extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_mixed_product 29 | /// @{ 30 | 31 | /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) 32 | template 33 | GLM_FUNC_DECL T mixedProduct( 34 | vec<3, T, 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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_normal is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_normal extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normal 30 | /// @{ 31 | 32 | /// Computes triangle normal from triangle points. 33 | /// 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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/optimum_pow.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | /// @file glm/gtx/optimum_pow.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_optimum_pow GLM_GTX_optimum_pow 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Integer exponentiation of power functions. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_optimum_pow is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_optimum_pow extension included") 24 | #endif 25 | 26 | namespace glm{ 27 | namespace gtx 28 | { 29 | /// @addtogroup gtx_optimum_pow 30 | /// @{ 31 | 32 | /// Returns x raised to the power of 2. 33 | /// 34 | /// @see gtx_optimum_pow 35 | template 36 | GLM_FUNC_DECL genType pow2(genType const& x); 37 | 38 | /// Returns x raised to the power of 3. 39 | /// 40 | /// @see gtx_optimum_pow 41 | template 42 | GLM_FUNC_DECL genType pow3(genType const& x); 43 | 44 | /// Returns x raised to the power of 4. 45 | /// 46 | /// @see gtx_optimum_pow 47 | template 48 | GLM_FUNC_DECL genType pow4(genType const& x); 49 | 50 | /// @} 51 | }//namespace gtx 52 | }//namespace glm 53 | 54 | #include "optimum_pow.inl" 55 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/orthonormalize.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | /// @file glm/gtx/orthonormalize.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_orthonormalize GLM_GTX_orthonormalize 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Orthonormalize matrices. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../vec3.hpp" 18 | #include "../mat3x3.hpp" 19 | #include "../geometric.hpp" 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "GLM: GLM_GTX_orthonormalize is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 23 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_orthonormalize extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_orthonormalize 32 | /// @{ 33 | 34 | /// Returns the orthonormalized matrix of m. 35 | /// 36 | /// @see gtx_orthonormalize 37 | template 38 | GLM_FUNC_DECL mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m); 39 | 40 | /// Orthonormalizes x according y. 41 | /// 42 | /// @see gtx_orthonormalize 43 | template 44 | GLM_FUNC_DECL vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y); 45 | 46 | /// @} 47 | }//namespace glm 48 | 49 | #include "orthonormalize.inl" 50 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_perpendicular is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 22 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_perpendicular extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_perpendicular 31 | /// @{ 32 | 33 | //! Projects x a perpendicular axis of Normal. 34 | //! From GLM_GTX_perpendicular extension. 35 | template 36 | GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "perpendicular.inl" 42 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/polar_coordinates.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | /// @file glm/gtx/polar_coordinates.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Conversion from Euclidean space to polar space and revert. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_polar_coordinates is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_polar_coordinates extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_polar_coordinates 29 | /// @{ 30 | 31 | /// Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude. 32 | /// 33 | /// @see gtx_polar_coordinates 34 | template 35 | GLM_FUNC_DECL vec<3, T, Q> polar( 36 | vec<3, T, Q> const& euclidean); 37 | 38 | /// Convert Polar to Euclidean coordinates. 39 | /// 40 | /// @see gtx_polar_coordinates 41 | template 42 | GLM_FUNC_DECL vec<3, T, Q> euclidean( 43 | vec<2, T, Q> const& polar); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "polar_coordinates.inl" 49 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_projection is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_projection extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_projection 29 | /// @{ 30 | 31 | /// Projects x on Normal. 32 | /// 33 | /// @see gtx_projection 34 | template 35 | GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); 36 | 37 | /// @} 38 | }//namespace glm 39 | 40 | #include "projection.inl" 41 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_raw_data is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_raw_data extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_raw_data 30 | /// @{ 31 | 32 | //! Type for byte numbers. 33 | //! From GLM_GTX_raw_data extension. 34 | typedef detail::uint8 byte; 35 | 36 | //! Type for word numbers. 37 | //! From GLM_GTX_raw_data extension. 38 | typedef detail::uint16 word; 39 | 40 | //! Type for dword numbers. 41 | //! From GLM_GTX_raw_data extension. 42 | typedef detail::uint32 dword; 43 | 44 | //! Type for qword numbers. 45 | //! From GLM_GTX_raw_data extension. 46 | typedef detail::uint64 qword; 47 | 48 | /// @} 49 | }// namespace glm 50 | 51 | #include "raw_data.inl" 52 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | 3 | -------------------------------------------------------------------------------- /Framework/Externals/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_extend extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_scalar_relational 29 | /// @{ 30 | 31 | 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "scalar_relational.inl" 37 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/scalar_relational.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER bool lessThan 7 | ( 8 | T const& x, 9 | T const& y 10 | ) 11 | { 12 | return x < y; 13 | } 14 | 15 | template 16 | GLM_FUNC_QUALIFIER bool lessThanEqual 17 | ( 18 | T const& x, 19 | T const& y 20 | ) 21 | { 22 | return x <= y; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER bool greaterThan 27 | ( 28 | T const& x, 29 | T const& y 30 | ) 31 | { 32 | return x > y; 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER bool greaterThanEqual 37 | ( 38 | T const& x, 39 | T const& y 40 | ) 41 | { 42 | return x >= y; 43 | } 44 | 45 | template 46 | GLM_FUNC_QUALIFIER bool equal 47 | ( 48 | T const& x, 49 | T const& y 50 | ) 51 | { 52 | return detail::compute_equal::is_iec559>::call(x, y); 53 | } 54 | 55 | template 56 | GLM_FUNC_QUALIFIER bool notEqual 57 | ( 58 | T const& x, 59 | T const& y 60 | ) 61 | { 62 | return !detail::compute_equal::is_iec559>::call(x, y); 63 | } 64 | 65 | GLM_FUNC_QUALIFIER bool any 66 | ( 67 | bool const& x 68 | ) 69 | { 70 | return x; 71 | } 72 | 73 | GLM_FUNC_QUALIFIER bool all 74 | ( 75 | bool const& x 76 | ) 77 | { 78 | return x; 79 | } 80 | 81 | GLM_FUNC_QUALIFIER bool not_ 82 | ( 83 | bool const& x 84 | ) 85 | { 86 | return !x; 87 | } 88 | }//namespace glm 89 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /Framework/Externals/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 | /// This extension is not supported with CUDA 16 | 17 | #pragma once 18 | 19 | // Dependency: 20 | #include "../glm.hpp" 21 | #include "../gtc/type_precision.hpp" 22 | #include "../gtc/quaternion.hpp" 23 | #include "../gtx/dual_quaternion.hpp" 24 | #include 25 | #include 26 | 27 | #ifndef GLM_ENABLE_EXPERIMENTAL 28 | # error "GLM: GLM_GTX_string_cast is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 29 | #endif 30 | 31 | #if(GLM_COMPILER & GLM_COMPILER_CUDA) 32 | # error "GLM_GTX_string_cast is not supported on CUDA compiler" 33 | #endif 34 | 35 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 36 | # pragma message("GLM: GLM_GTX_string_cast extension included") 37 | #endif 38 | 39 | namespace glm 40 | { 41 | /// @addtogroup gtx_string_cast 42 | /// @{ 43 | 44 | /// Create a string from a GLM vector or matrix typed variable. 45 | /// @see gtx_string_cast extension. 46 | template 47 | GLM_FUNC_DECL std::string to_string(genType const& x); 48 | 49 | /// @} 50 | }//namespace glm 51 | 52 | #include "string_cast.inl" 53 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/texture.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | /// @file glm/gtx/texture.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_texture GLM_GTX_texture 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Wrapping mode of texture coordinates. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtc/integer.hpp" 18 | #include "../gtx/component_wise.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_texture is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 22 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_texture extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_texture 31 | /// @{ 32 | 33 | /// Compute the number of mipmaps levels necessary to create a mipmap complete texture 34 | /// 35 | /// @param Extent Extent of the texture base level mipmap 36 | /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector 37 | /// @tparam T Floating-point or signed integer scalar types 38 | /// @tparam Q Value from qualifier enum 39 | template 40 | T levels(vec const& Extent); 41 | 42 | /// @} 43 | }// namespace glm 44 | 45 | #include "texture.inl" 46 | 47 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /Framework/Externals/GLM/glm/gtx/vector_angle.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_vector_angle 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType angle 7 | ( 8 | genType const& x, 9 | genType const& y 10 | ) 11 | { 12 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); 13 | return acos(clamp(dot(x, y), genType(-1), genType(1))); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER T angle(vec const& x, vec const& y) 18 | { 19 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); 20 | return acos(clamp(dot(x, y), T(-1), T(1))); 21 | } 22 | 23 | //! \todo epsilon is hard coded to 0.01 24 | template 25 | GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y) 26 | { 27 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); 28 | T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); 29 | 30 | if(all(epsilonEqual(y, glm::rotate(x, Angle), T(0.0001)))) 31 | return Angle; 32 | else 33 | return -Angle; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref) 38 | { 39 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); 40 | 41 | T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); 42 | return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0)); 43 | } 44 | }//namespace glm 45 | -------------------------------------------------------------------------------- /Framework/Externals/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 "../gtc/vec1.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_wrap extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_wrap 30 | /// @{ 31 | 32 | /// Simulate GL_CLAMP OpenGL wrap mode 33 | /// @see gtx_wrap extension. 34 | template 35 | GLM_FUNC_DECL genType clamp(genType const& Texcoord); 36 | 37 | /// Simulate GL_REPEAT OpenGL wrap mode 38 | /// @see gtx_wrap extension. 39 | template 40 | GLM_FUNC_DECL genType repeat(genType const& Texcoord); 41 | 42 | /// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode 43 | /// @see gtx_wrap extension. 44 | template 45 | GLM_FUNC_DECL genType mirrorClamp(genType const& Texcoord); 46 | 47 | /// Simulate GL_MIRROR_REPEAT OpenGL wrap mode 48 | /// @see gtx_wrap extension. 49 | template 50 | GLM_FUNC_DECL genType mirrorRepeat(genType const& Texcoord); 51 | 52 | /// @} 53 | }// namespace glm 54 | 55 | #include "wrap.inl" 56 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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 | -------------------------------------------------------------------------------- /Framework/Externals/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_precision.hpp" 13 | #include "./ext/vector_uint2.hpp" 14 | #include "./ext/vector_uint2_precision.hpp" 15 | -------------------------------------------------------------------------------- /Framework/Externals/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_precision.hpp" 13 | #include "./ext/vector_uint3.hpp" 14 | #include "./ext/vector_uint3_precision.hpp" 15 | -------------------------------------------------------------------------------- /Framework/Externals/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_precision.hpp" 13 | #include "./ext/vector_uint4.hpp" 14 | #include "./ext/vector_uint4_precision.hpp" 15 | 16 | -------------------------------------------------------------------------------- /Framework/Externals/PresentationCore.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/PresentationCore.dll -------------------------------------------------------------------------------- /Framework/Externals/dxcompiler/dxcompiler.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/dxcompiler/dxcompiler.dll -------------------------------------------------------------------------------- /Framework/Externals/dxcompiler/dxil.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Externals/dxcompiler/dxil.dll -------------------------------------------------------------------------------- /Framework/Externals/dxcompiler/version.txt: -------------------------------------------------------------------------------- 1 | 10.0.17763.0 -------------------------------------------------------------------------------- /Framework/Framework.props: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | $(SolutionDir)Bin\$(PlatformShortName)\$(Configuration)\ 6 | $(SolutionDir)Bin\Int\$(PlatformShortName)\$(Configuration)\$(ProjectName)\ 7 | 8 | 9 | 10 | Level3 11 | true 12 | $(SolutionDir)\Framework\ 13 | _CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;GLM_FORCE_DEPTH_ZERO_TO_ONE;_UNICODE;UNICODE;%(PreprocessorDefinitions) 14 | 15 | 16 | 17 | 18 | D3D12.lib;DXGI.lib;%(AdditionalDependencies) 19 | 20 | 21 | copy /y $(SolutionDir)\Framework\Externals\dxcompiler\*.dll $(OutDir) >nul 22 | IF not exist $(ProjectDir)\Data\ (exit /b 0) 23 | IF not exist $(OutDir)\Data\ ( mkdir $(OutDir)\Data >nul ) 24 | copy /y $(ProjectDir)\Data\*.* $(OutDir)\Data >nul 25 | 26 | 27 | -------------------------------------------------------------------------------- /Framework/Nvidia.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Framework/Nvidia.ico -------------------------------------------------------------------------------- /Framework/packages.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | -------------------------------------------------------------------------------- /Images/room.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Images/room.png -------------------------------------------------------------------------------- /Images/sponza.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Images/sponza.png -------------------------------------------------------------------------------- /Images/sunTemple.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Images/sunTemple.png -------------------------------------------------------------------------------- /Images/sunTemple2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Images/sunTemple2.png -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Niklas Lundström 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Pipeline visualization/configuration.zargo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Pipeline visualization/configuration.zargo -------------------------------------------------------------------------------- /Pipeline visualization/pipeline.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Pipeline visualization/pipeline.png -------------------------------------------------------------------------------- /Pipeline visualization/pipeline.zargo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/Pipeline visualization/pipeline.zargo -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Ray Traced Reflective Shadow Maps (RT-RSM) 2 | This project shows a way to use ray tracing to simulate global illumination in real-time using DXR. 3 | 4 | My approach is inspired by [Reflective Shadow Maps](http://www.klayge.org/material/3_12/GI/rsm.pdf), but with ray tracing to determine occlusion. So, instead of shooting a diffuse ray from the hit point, I sample a texture containing all points being hit by direct light, and shoot a shadow ray to some of these points. This simplifies the ray tracing pass in the sense that it first of all only needs shadow rays to create colour bleeding, and also that it moves the unique shader resources for each mesh (textures etc.) to the rasterization instead. 5 | 6 | To reduce the noise I use a temporal filter (separately for direct and indirect light) and then a bilateral spatial filter. I also have some adaptive sampling in the sense that I shoot some extra rays where there just have been a disocclusion to compensate for the discarded colour history. 7 | 8 | The result is more or less noise free images with high quality lighting in real-time. 9 | 10 | See some results in Images folder and in the youtube videos: [Part 1](https://youtu.be/Dbwxm-EEsRI) and [Part 2 (final results)](https://youtu.be/EPt_8N6pm3o) 11 | 12 |

13 | 14 |

15 | -------------------------------------------------------------------------------- /RT-RSM/Data/Common.hlsli: -------------------------------------------------------------------------------- 1 | ///// Ray-tracing ///////////////// 2 | struct RayPayload 3 | { 4 | float4 color; //packed as [float3(indirect), float(direct)] 5 | //float numRays; 6 | uint seed; 7 | //int depth; 8 | }; 9 | 10 | struct ShadowPayload 11 | { 12 | bool hit; 13 | }; 14 | 15 | struct OfflineRayPayload 16 | { 17 | float3 color; 18 | uint seed; 19 | int depth; 20 | }; 21 | 22 | //// constants //// 23 | static const float PI = 3.14159265f; 24 | 25 | //// Post processing /////////////// 26 | float makeDepthLinear(float oldDepth) 27 | { 28 | float zPrim = oldDepth; 29 | float f = 100.0f; // Sync this value to the C++ code! 30 | float n = 0.1f; 31 | // Transform to linear view space 32 | float z = f * n / (f - zPrim * (f - n)); 33 | zPrim = z * zPrim; 34 | zPrim /= f; // z <- 0..1 35 | return zPrim; 36 | }; 37 | 38 | static const float2 gTexCoords[6] = 39 | { 40 | float2(0.0f, 1.0f), 41 | float2(0.0f, 0.0f), 42 | float2(1.0f, 0.0f), 43 | float2(0.0f, 1.0f), 44 | float2(1.0f, 0.0f), 45 | float2(1.0f, 1.0f) 46 | }; 47 | 48 | // pack/unpack normals 49 | uint dirToOct(float3 normal) 50 | { 51 | float2 p = normal.xy * (1.0 / dot(abs(normal), 1.0.xxx /*float3(1.0f, 1.0f, 1.0f)*/)); 52 | float2 e = normal.z > 0.0 ? p : (1.0 - abs(p.yx)) * (step(0.0, p) * 2.0 - (float2) (1.0)); 53 | return (asuint(f32tof16(e.y)) << 16) + (asuint(f32tof16(e.x))); 54 | } 55 | float3 oct_to_dir(uint octo) 56 | { 57 | float2 e = float2(f16tof32((octo) & 0xffff), f16tof32((octo >> 16) & 0xffff)); 58 | float3 v = float3(e, 1.0 - abs(e.x) - abs(e.y)); 59 | if (v.z < 0.0) 60 | v.xy = (1.0 - abs(v.yx)) * (step(0.0, v.xy) * 2.0 - (float2) (1.0)); 61 | return normalize(v); 62 | } -------------------------------------------------------------------------------- /RT-RSM/Data/HDR_maps/eucalyptus_probe.hdr: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/HDR_maps/eucalyptus_probe.hdr -------------------------------------------------------------------------------- /RT-RSM/Data/HDR_maps/grace_probe.hdr: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/HDR_maps/grace_probe.hdr -------------------------------------------------------------------------------- /RT-RSM/Data/HDR_maps/stpeters_probe.hdr: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/HDR_maps/stpeters_probe.hdr -------------------------------------------------------------------------------- /RT-RSM/Data/HDR_maps/uffizi_probe.hdr: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/HDR_maps/uffizi_probe.hdr -------------------------------------------------------------------------------- /RT-RSM/Data/Miss.hlsl: -------------------------------------------------------------------------------- 1 | #include "Common.hlsli" 2 | 3 | Texture2D gHDRTexture : register(t0); 4 | SamplerState gSampler : register(s0); 5 | 6 | 7 | [shader("miss")] 8 | void miss(inout RayPayload payload) 9 | { 10 | //uint width, height; 11 | //gHDRTexture.GetDimensions(width, height); 12 | 13 | //float3 dir = WorldRayDirection(); 14 | //dir.y = -dir.y; 15 | 16 | //float r = (1 / PI) * acos(dir.z) / length(dir.xy); 17 | //float2 coord = float2(((dir.xy * r) * 0.5 + 0.5));// * float2(width, height)); 18 | //float4 c = gHDRTexture.SampleLevel(gSampler, coord, 0).rgba; 19 | 20 | //payload.color = c.rgb; 21 | 22 | payload.color = float4(0.0, 0.0, 0.0, 0.0); 23 | } 24 | -------------------------------------------------------------------------------- /RT-RSM/Data/Models/LICENSE.txt: -------------------------------------------------------------------------------- 1 | This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/4.0/ or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. -------------------------------------------------------------------------------- /RT-RSM/Data/Models/README.txt: -------------------------------------------------------------------------------- 1 | Bistro: 2 | Amazon Lumberyard Bistro, Open Research Content Archive (ORCA) 3 | http://developer.nvidia.com/orca/amazon-lumberyard-bistro 4 | 5 | Sponza: 6 | Morgan McGuire, Computer Graphics Archive 7 | https://casual-effects.com/data 8 | 9 | Sun Temple: 10 | Epic Games, Unreal Engine Sun Temple, Open Research Content Archive (ORCA) 11 | http://developer.nvidia.com/orca/epic-games-sun-temple -------------------------------------------------------------------------------- /RT-RSM/Data/Models/SunTemple/LICENSE.txt: -------------------------------------------------------------------------------- 1 | This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/4.0/ or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. -------------------------------------------------------------------------------- /RT-RSM/Data/Models/SunTemple/README.txt: -------------------------------------------------------------------------------- 1 | Part of Unreal Engine 4 sample scenes pack, the Sun Temple was designed to showcase mobile features. This single level contains detailed PBR materials useful for a variety of graphics features and techniques. 2 | Exported directly from the Unreal Engine by Kai-Hwa Yao and Nicholas Hull. 3 | 4 | Model (SunTemple.fbx) contains the following vertex attributes: 5 | - Positions 6 | - Normals 7 | - Tangents 8 | - Bitangents 9 | - 2 sets of texture coordinates: 10 | Set 0 (Materials) 11 | Set 1 (Lightmap UV) 12 | - 1,641,711 vertices 13 | 14 | Textures (compressed .DDS) designed for GGX-based, metal-rough PBR material system with the following convention: 15 | - BaseColor 16 | RGB channels: BaseColor value 17 | Alpha channel: Opacity 18 | 19 | - Specular: 20 | Red channel: Occlusion 21 | Green channel: Roughness 22 | Blue channel: Metalness 23 | 24 | - Normal (DirectX) 25 | 26 | Also included: 27 | - Spherical reflection HDR map from UE4 scene 28 | - Spherical environment HDR map from UE4 scene 29 | - Falcor scene file (SunTemple.fscene) to be used with Falcor's forward renderer demo. Contains lighting and camera information. 30 | 31 | How to cite use of this asset: 32 | 33 | @misc{OrcaUE4SunTemple, 34 | title = {Unreal Engine Sun Temple, Open Research Content Archive (ORCA)}, 35 | author = {Epic Games}, 36 | year = {2017}, 37 | month = {October}, 38 | note = {\small \texttt{http://developer.nvidia.com/orca/epic-games-sun-temple}}, 39 | url = {http://developer.nvidia.com/orca/epic-games-sun-temple} 40 | } -------------------------------------------------------------------------------- /RT-RSM/Data/Models/SunTemple/SunTempleMerged.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/SunTemple/SunTempleMerged.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/SunTemple/sunTemple2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/SunTemple/sunTemple2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/bistro_interior_with_street.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/bistro_interior_with_street.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/bistro_interior_with_street2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/bistro_interior_with_street2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/robot.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/robot.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/back_wall.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/back_wall.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/back_wall2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/back_wall2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/back_wall_extended2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/back_wall_extended2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/ceiling.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/ceiling.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/ceiling2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/ceiling2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/ceiling_extended2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/ceiling_extended2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/floor.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/floor.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/floor2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/floor2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/floor_extended2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/floor_extended2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/front_wall_extended2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/front_wall_extended2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/left_wall_extended2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/left_wall_extended2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/left_wall_inside.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/left_wall_inside.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/left_wall_outside.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/left_wall_outside.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/left_wall_outside2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/left_wall_outside2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/right_wall_inside.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/right_wall_inside.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/right_wall_inside2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/right_wall_inside2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/right_wall_outside.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/right_wall_outside.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/right_wall_outside2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/right_wall_outside2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/wall_window.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/wall_window.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room/wall_window2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room/wall_window2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room_complete.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room_complete.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/room_with_window.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/room_with_window.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/sphere.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/sphere.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/sponza.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/sponza.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/sponza2.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/sponza2.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/Models/teapot.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/Models/teapot.fbx -------------------------------------------------------------------------------- /RT-RSM/Data/ShadowRay.hlsl: -------------------------------------------------------------------------------- 1 | #include "Common.hlsli" 2 | 3 | [shader("closesthit")] 4 | void shadowChs(inout ShadowPayload payload, in BuiltInTriangleIntersectionAttributes attribs) 5 | { 6 | payload.hit = true; 7 | } 8 | 9 | [shader("miss")] 10 | void shadowMiss(inout ShadowPayload payload) 11 | { 12 | payload.hit = false; 13 | } -------------------------------------------------------------------------------- /RT-RSM/Data/SpatialFilter.hlsl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NiklasLundstrom/Ray-Traced-Reflective-Shadow-Maps/3c42bc88f832718a3fa48a60008e3601e9b9ef37/RT-RSM/Data/SpatialFilter.hlsl -------------------------------------------------------------------------------- /RT-RSM/Data/offline shaders/offline_Miss.hlsl: -------------------------------------------------------------------------------- 1 | #include "../Common.hlsli" 2 | 3 | Texture2D gHDRTexture : register(t0); 4 | SamplerState gSampler : register(s0); 5 | 6 | 7 | [shader("miss")] 8 | void miss(inout OfflineRayPayload payload) 9 | { 10 | //uint width, height; 11 | //gHDRTexture.GetDimensions(width, height); 12 | 13 | //float3 dir = WorldRayDirection(); 14 | //dir.y = -dir.y; 15 | 16 | //float r = (1 / PI) * acos(dir.z) / length(dir.xy); 17 | //float2 coord = float2(((dir.xy * r) * 0.5 + 0.5));// * float2(width, height)); 18 | //float4 c = gHDRTexture.SampleLevel(gSampler, coord, 0).rgba; 19 | 20 | //payload.color = c.rgb; 21 | 22 | payload.color = float3(0.0, 0.0, 0.0); //float3(201.0, 226.0, 255.0) * 5 / 255.0; 23 | 24 | } 25 | -------------------------------------------------------------------------------- /RT-RSM/nsight_profiler.cfg: -------------------------------------------------------------------------------- 1 | ; This file contains the counters to configure using the Nsight Frame Profiler. 2 | ; The counters can be configured for the domains common, graphics, and compute individually. 3 | ; To obtain a list of supported counters, please use NvPmApiQuery.exe (\Host\Common\Injection32). 4 | ; For example, execute 'NvPmApiQuery.exe --gl' or 'NvPmApiQuery.exe --d3d11' on the target to obtain a list of supported OpenGL or D3D11 counters respectively. 5 | ; Executing 'NvPmApiQuery.exe --help' will show more available options. 6 | 7 | ; The configuration uses one regex for each of the domains. Here are some examples: 8 | ; 1. collect texture_busy and geom_busy only: 9 | ; graphics "texture_busy|"\ 10 | ; "geom_busy" 11 | ; 2. collect read sector counters from all subpartitions and framebuffers: 12 | ; common "fb_subp\\d_read_sectors_fb\\d" 13 | ; 3. collect all common counters: 14 | ; common ".*" 15 | ; 4. collect aggregated compute counters: 16 | ; compute "^((?!(vsm|slice|gpc|subp)).)*$" 17 | ; 5. collect no common counters: 18 | ; common "" 19 | 20 | counters 21 | { 22 | common "" 23 | graphics "" 24 | compute "" 25 | } 26 | -------------------------------------------------------------------------------- /RT-RSM/packages.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | --------------------------------------------------------------------------------