├── include ├── glm │ ├── gtc │ │ ├── quaternion_simd.inl │ │ ├── ulp.inl │ │ ├── type_precision.inl │ │ ├── matrix_transform.inl │ │ ├── ulp.hpp │ │ ├── vec1.hpp │ │ ├── matrix_transform.hpp │ │ ├── matrix_access.inl │ │ ├── matrix_access.hpp │ │ └── matrix_inverse.hpp │ ├── detail │ │ ├── func_trigonometric_simd.inl │ │ ├── type_mat4x4_simd.inl │ │ ├── func_packing_simd.inl │ │ ├── func_vector_relational_simd.inl │ │ ├── type_half.hpp │ │ ├── _fixes.hpp │ │ ├── compute_vector_relational.hpp │ │ ├── func_exponential_simd.inl │ │ └── compute_common.hpp │ ├── gtx │ │ ├── raw_data.inl │ │ ├── type_aligned.inl │ │ ├── std_based_type.inl │ │ ├── number_precision.inl │ │ ├── matrix_factorisation.inl │ │ ├── perpendicular.inl │ │ ├── projection.inl │ │ ├── mixed_product.inl │ │ ├── normal.inl │ │ ├── float_notmalize.inl │ │ ├── texture.inl │ │ ├── log_base.inl │ │ ├── optimum_pow.inl │ │ ├── normalize_dot.inl │ │ ├── handed_coordinate_space.inl │ │ ├── transform.inl │ │ ├── orthonormalize.inl │ │ ├── exterior_product.inl │ │ ├── matrix_cross_product.inl │ │ ├── functions.inl │ │ ├── polar_coordinates.inl │ │ ├── scalar_relational.hpp │ │ ├── gradient_paint.inl │ │ ├── extend.inl │ │ ├── normal.hpp │ │ ├── mixed_product.hpp │ │ ├── extend.hpp │ │ ├── exterior_product.hpp │ │ ├── functions.hpp │ │ ├── projection.hpp │ │ ├── perpendicular.hpp │ │ ├── closest_point.inl │ │ ├── log_base.hpp │ │ ├── raw_data.hpp │ │ ├── texture.hpp │ │ ├── scalar_relational.inl │ │ ├── matrix_cross_product.hpp │ │ ├── orthonormalize.hpp │ │ ├── closest_point.hpp │ │ ├── optimum_pow.hpp │ │ ├── polar_coordinates.hpp │ │ ├── matrix_decompose.hpp │ │ ├── vector_angle.inl │ │ ├── string_cast.hpp │ │ ├── color_encoding.hpp │ │ ├── matrix_transform_2d.inl │ │ ├── wrap.hpp │ │ └── gradient_paint.hpp │ ├── simd │ │ ├── packing.h │ │ ├── vector_relational.h │ │ ├── trigonometric.h │ │ └── exponential.h │ ├── mat3x3.hpp │ ├── mat3x4.hpp │ ├── mat4x3.hpp │ ├── mat2x2.hpp │ ├── mat2x3.hpp │ ├── mat2x4.hpp │ ├── mat3x2.hpp │ ├── mat4x2.hpp │ ├── mat4x4.hpp │ ├── ext │ │ ├── quaternion_common_simd.inl │ │ ├── vector_bool2.hpp │ │ ├── vector_bool3.hpp │ │ ├── vector_bool4.hpp │ │ ├── vector_int2.hpp │ │ ├── vector_int3.hpp │ │ ├── vector_int4.hpp │ │ ├── vector_uint2.hpp │ │ ├── vector_uint3.hpp │ │ ├── vector_uint4.hpp │ │ ├── vector_float2.hpp │ │ ├── vector_double2.hpp │ │ ├── vector_double3.hpp │ │ ├── vector_double4.hpp │ │ ├── vector_float3.hpp │ │ ├── vector_float4.hpp │ │ ├── matrix_float3x2.hpp │ │ ├── matrix_double2x3.hpp │ │ ├── matrix_double2x4.hpp │ │ ├── matrix_double3x2.hpp │ │ ├── matrix_double3x4.hpp │ │ ├── matrix_double4x2.hpp │ │ ├── matrix_double4x3.hpp │ │ ├── matrix_float2x3.hpp │ │ ├── matrix_float2x4.hpp │ │ ├── matrix_float3x4.hpp │ │ ├── matrix_float4x2.hpp │ │ ├── matrix_float4x3.hpp │ │ ├── scalar_constants.inl │ │ ├── matrix_common.inl │ │ ├── quaternion_transform.inl │ │ ├── vector_bool1.hpp │ │ ├── matrix_float2x2.hpp │ │ ├── matrix_float4x4.hpp │ │ ├── matrix_double2x2.hpp │ │ ├── matrix_double3x3.hpp │ │ ├── matrix_double4x4.hpp │ │ ├── matrix_float3x3.hpp │ │ ├── vector_int1.hpp │ │ ├── vector_uint1.hpp │ │ ├── quaternion_trigonometric.inl │ │ ├── vector_float1.hpp │ │ ├── vector_double1.hpp │ │ ├── vector_bool1_precision.hpp │ │ ├── scalar_constants.hpp │ │ ├── vector_int1_precision.hpp │ │ ├── quaternion_float.hpp │ │ ├── matrix_common.hpp │ │ ├── quaternion_double.hpp │ │ ├── quaternion_relational.inl │ │ ├── vector_uint1_precision.hpp │ │ ├── vector_float1_precision.hpp │ │ ├── quaternion_float_precision.hpp │ │ ├── vector_double1_precision.hpp │ │ ├── quaternion_geometric.inl │ │ ├── scalar_relational.inl │ │ ├── vector_bool2_precision.hpp │ │ ├── vector_bool3_precision.hpp │ │ ├── vector_bool4_precision.hpp │ │ ├── vector_int2_precision.hpp │ │ ├── vector_int3_precision.hpp │ │ ├── vector_int4_precision.hpp │ │ ├── quaternion_double_precision.hpp │ │ ├── vector_float2_precision.hpp │ │ ├── vector_float3_precision.hpp │ │ ├── vector_float4_precision.hpp │ │ ├── vector_uint2_precision.hpp │ │ ├── vector_uint3_precision.hpp │ │ ├── vector_uint4_precision.hpp │ │ ├── vector_double2_precision.hpp │ │ ├── quaternion_transform.hpp │ │ ├── scalar_int_sized.hpp │ │ ├── scalar_uint_sized.hpp │ │ ├── vector_double3_precision.hpp │ │ ├── matrix_float2x3_precision.hpp │ │ ├── matrix_float2x4_precision.hpp │ │ ├── matrix_float3x2_precision.hpp │ │ ├── matrix_float3x4_precision.hpp │ │ ├── matrix_float4x2_precision.hpp │ │ ├── matrix_float4x3_precision.hpp │ │ ├── matrix_double2x3_precision.hpp │ │ ├── matrix_double2x4_precision.hpp │ │ ├── matrix_double3x2_precision.hpp │ │ └── matrix_double3x4_precision.hpp │ ├── vec2.hpp │ ├── vec3.hpp │ └── vec4.hpp ├── oneweekend │ ├── ray.hpp │ ├── external.hpp │ ├── sphere.hpp │ ├── random.hpp │ ├── camera.hpp │ └── color.hpp └── custom │ ├── image.hpp │ └── external.hpp ├── oneweekend.png ├── .clangd └── index │ ├── fwd.hpp.45E3DEF603BA8EB5.idx │ ├── glm.hpp.A18383C2AF2D71E1.idx │ ├── vec2.hpp.26CC110E0A52EE17.idx │ ├── vec3.hpp.2CA08EB7B653A205.idx │ ├── vec4.hpp.6DBA5742320906A1.idx │ ├── _fixes.hpp.0030035F79BC684A.idx │ ├── common.hpp.776177FC1C8D2B77.idx │ ├── hello.cpp.CD59E5A5168DA9F6.idx │ ├── integer.hpp.40084CB6629A8DD5.idx │ ├── mat2x2.hpp.A35A1626209E9371.idx │ ├── mat2x3.hpp.34B640D53EBCFDCE.idx │ ├── mat2x4.hpp.281840F367626EB7.idx │ ├── mat3x2.hpp.C0A27D9C21AB5333.idx │ ├── mat3x3.hpp.7DBFEFF2FAEE4341.idx │ ├── mat3x4.hpp.C5123F170399368D.idx │ ├── mat4x2.hpp.9BD860823C696756.idx │ ├── mat4x3.hpp.01C11E4820AB196E.idx │ ├── mat4x4.hpp.85CD2D78D2BBE272.idx │ ├── matrix.hpp.9C450EB34372448C.idx │ ├── packing.hpp.2B551C7FC81FA572.idx │ ├── platform.h.552AAA6450F83081.idx │ ├── setup.hpp.580FDDB4877E2C23.idx │ ├── sphere.cpp.2C7E15E3A86831CE.idx │ ├── utils.hpp.2235619B05B03A88.idx │ ├── external.hpp.2C77953201EBD4B9.idx │ ├── geometric.hpp.6CBBD50501FA4A9D.idx │ ├── gradient.cpp.2C063E810D3D9499.idx │ ├── qualifier.hpp.F72B5FAD4BE2AF6B.idx │ ├── rtsphere.cpp.88EDECA5C1C691C8.idx │ ├── type_half.hpp.6E00DDB3336E2017.idx │ ├── type_half.inl.5AAC328F1F4E698F.idx │ ├── type_vec1.hpp.ED6B28AC0C3E656C.idx │ ├── type_vec1.inl.70058D7C12B26ABC.idx │ ├── type_vec2.hpp.DBFEC81E285E5A30.idx │ ├── type_vec2.inl.229A87816E4B78EB.idx │ ├── type_vec3.hpp.87BB8775DB2FB33F.idx │ ├── type_vec3.inl.9EF357CA6C135A29.idx │ ├── type_vec4.hpp.7F65D2F322947648.idx │ ├── type_vec4.inl.FF86FF9C7742A152.idx │ ├── _vectorize.hpp.16375A72D8AF732A.idx │ ├── exponential.hpp.BBD595D1D76ECAF9.idx │ ├── func_common.inl.0579D109A5FC26C0.idx │ ├── func_integer.inl.BC26D75BB3E33466.idx │ ├── func_matrix.inl.3981093BE56CCE77.idx │ ├── func_packing.inl.A71D7C8E3F0F3859.idx │ ├── type_mat2x2.hpp.E822F8B8C9E54486.idx │ ├── type_mat2x2.inl.289FC7969B727B65.idx │ ├── type_mat2x3.hpp.9DFE11BA8EEA88B2.idx │ ├── type_mat2x3.inl.B9373D3BC0C54356.idx │ ├── type_mat2x4.hpp.DC9B4E974F7AD5CA.idx │ ├── type_mat2x4.inl.F2A9DAE89B9AA564.idx │ ├── type_mat3x2.hpp.2BC5F16CAD29DEFE.idx │ ├── type_mat3x2.inl.25A96229CE2F0E10.idx │ ├── type_mat3x3.hpp.66A093F0F8C34587.idx │ ├── type_mat3x3.inl.C474BC14D7586FE9.idx │ ├── type_mat3x4.hpp.2892EEBAF364DB27.idx │ ├── type_mat3x4.inl.2A8AA30B8495281B.idx │ ├── type_mat4x2.hpp.25653701EA258291.idx │ ├── type_mat4x2.inl.2FA135695B06B1D1.idx │ ├── type_mat4x3.hpp.C6287F3B896A7ADA.idx │ ├── type_mat4x3.inl.7A3858FCC96ED527.idx │ ├── type_mat4x4.hpp.F20E979E651E19F9.idx │ ├── type_mat4x4.inl.48C1FAC2E297AF11.idx │ ├── vector_bool2.hpp.46A7F9D85C66340A.idx │ ├── vector_bool3.hpp.CCD4A0D2ED841274.idx │ ├── vector_bool4.hpp.E9BDA713B5E67866.idx │ ├── vector_int2.hpp.96E45B2EC937F4CB.idx │ ├── vector_int3.hpp.4D9DB983557E1C8D.idx │ ├── vector_int4.hpp.209BB286690B995A.idx │ ├── vector_uint2.hpp.C2BE2E1E6045B731.idx │ ├── vector_uint3.hpp.E7C3D320644CB646.idx │ ├── vector_uint4.hpp.322103A3E901BA61.idx │ ├── compute_common.hpp.291968145E636087.idx │ ├── func_geometric.inl.0D65C708E24EDDBE.idx │ ├── trigonometric.hpp.ABF345E26EB7ACF7.idx │ ├── vector_double2.hpp.F0E586C370711965.idx │ ├── vector_double3.hpp.5A7F19AC3A57E22B.idx │ ├── vector_double4.hpp.65EBC1F6146BF8A0.idx │ ├── vector_float2.hpp.DEECDCFEA259DF2E.idx │ ├── vector_float3.hpp.9ED7F727C7A27E0A.idx │ ├── vector_float4.hpp.DEDD64D1F158F531.idx │ ├── func_exponential.inl.21E31BBFE459576E.idx │ ├── matrix_double2x2.hpp.805C87ECF4541518.idx │ ├── matrix_double2x3.hpp.FFE9DC338AACE511.idx │ ├── matrix_double2x4.hpp.DF3B0CAB86BED47F.idx │ ├── matrix_double3x2.hpp.36478A49347503AE.idx │ ├── matrix_double3x3.hpp.59B0C9EA13A34317.idx │ ├── matrix_double3x4.hpp.73841A1A8F31B0F1.idx │ ├── matrix_double4x2.hpp.736093FBAA6B5684.idx │ ├── matrix_double4x3.hpp.03025A4F901ABA34.idx │ ├── matrix_double4x4.hpp.67C1454C2ACF0AEE.idx │ ├── matrix_float2x2.hpp.E06EE4CC4F1AB0A4.idx │ ├── matrix_float2x3.hpp.59FD3BF00C14D076.idx │ ├── matrix_float2x4.hpp.8CEBA5BC558B4C72.idx │ ├── matrix_float3x2.hpp.A497E0A9BD0BF16F.idx │ ├── matrix_float3x3.hpp.F4AE0698B5AE5F20.idx │ ├── matrix_float3x4.hpp.65F80CA2069796E3.idx │ ├── matrix_float4x2.hpp.826EF4E309C75035.idx │ ├── matrix_float4x3.hpp.490AA1A6D994C522.idx │ ├── matrix_float4x4.hpp.E447480956451A7B.idx │ ├── vector_relational.hpp.997A5F542F6F790D.idx │ ├── func_trigonometric.inl.0B7C8E918DA2864D.idx │ ├── func_vector_relational.inl.97C0A48476FC7089.idx │ ├── vector_bool2_precision.hpp.201FE0BFC65E3E53.idx │ ├── vector_bool3_precision.hpp.E6C42BBEB706F5F8.idx │ ├── vector_bool4_precision.hpp.021C24AED2641828.idx │ ├── vector_int2_precision.hpp.D2CD78801487B618.idx │ ├── vector_int3_precision.hpp.D4BD94C0F2954177.idx │ ├── vector_int4_precision.hpp.2C88C4A3C59FEFD6.idx │ ├── vector_uint2_precision.hpp.948436C524F8B382.idx │ ├── vector_uint3_precision.hpp.90541EDEBB8B3A34.idx │ ├── vector_uint4_precision.hpp.1A52B8F472CFB0BF.idx │ ├── vector_double2_precision.hpp.D737D36E07AD5DB9.idx │ ├── vector_double3_precision.hpp.8BB7D9B0864DD5D3.idx │ ├── vector_double4_precision.hpp.2D482C276D88579E.idx │ ├── vector_float2_precision.hpp.CADD1962598F2C2C.idx │ ├── vector_float3_precision.hpp.1212F16AFD7FE46F.idx │ ├── vector_float4_precision.hpp.679F9080B0D0FDBB.idx │ ├── compute_vector_relational.hpp.04DB6A9E0C98D657.idx │ ├── matrix_double2x2_precision.hpp.FB94B58821420745.idx │ ├── matrix_double2x3_precision.hpp.D52D71F2B950581F.idx │ ├── matrix_double2x4_precision.hpp.767F352780996DEB.idx │ ├── matrix_double3x2_precision.hpp.2B36F8A105BB9516.idx │ ├── matrix_double3x3_precision.hpp.DBD8B192DAA7BE13.idx │ ├── matrix_double3x4_precision.hpp.249E2317F8920449.idx │ ├── matrix_double4x2_precision.hpp.CCCB19D8F205640F.idx │ ├── matrix_double4x3_precision.hpp.4AF844F2C27BFD46.idx │ ├── matrix_double4x4_precision.hpp.85DACA3D7FD243DF.idx │ ├── matrix_float2x2_precision.hpp.CC9026831A8B0CD6.idx │ ├── matrix_float2x3_precision.hpp.30C8514389159A41.idx │ ├── matrix_float2x4_precision.hpp.38C005328240A5C9.idx │ ├── matrix_float3x2_precision.hpp.B493B11D8B484527.idx │ ├── matrix_float3x3_precision.hpp.3D4FA308948E8AE4.idx │ ├── matrix_float3x4_precision.hpp.24E329BC7233A4F3.idx │ ├── matrix_float4x2_precision.hpp.B37C54FCED4DF710.idx │ ├── matrix_float4x3_precision.hpp.29AB225216492647.idx │ └── matrix_float4x4_precision.hpp.B26E29B85E11CF47.idx ├── bin └── errorlog.txt ├── .gitignore └── src └── sphere └── sphere.cpp /include/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /include/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /include/glm/gtc/ulp.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_ulp 2 | /// 3 | 4 | -------------------------------------------------------------------------------- /include/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | 3 | -------------------------------------------------------------------------------- /include/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /include/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /oneweekend.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/oneweekend.png -------------------------------------------------------------------------------- /include/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /include/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /include/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /include/glm/gtc/matrix_transform.inl: -------------------------------------------------------------------------------- 1 | #include "../geometric.hpp" 2 | #include "../trigonometric.hpp" 3 | #include "../matrix.hpp" 4 | -------------------------------------------------------------------------------- /include/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /include/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /include/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/include/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /.clangd/index/fwd.hpp.45E3DEF603BA8EB5.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/fwd.hpp.45E3DEF603BA8EB5.idx -------------------------------------------------------------------------------- /.clangd/index/glm.hpp.A18383C2AF2D71E1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/glm.hpp.A18383C2AF2D71E1.idx -------------------------------------------------------------------------------- /.clangd/index/vec2.hpp.26CC110E0A52EE17.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vec2.hpp.26CC110E0A52EE17.idx -------------------------------------------------------------------------------- /.clangd/index/vec3.hpp.2CA08EB7B653A205.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vec3.hpp.2CA08EB7B653A205.idx -------------------------------------------------------------------------------- /.clangd/index/vec4.hpp.6DBA5742320906A1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vec4.hpp.6DBA5742320906A1.idx -------------------------------------------------------------------------------- /.clangd/index/_fixes.hpp.0030035F79BC684A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/_fixes.hpp.0030035F79BC684A.idx -------------------------------------------------------------------------------- /.clangd/index/common.hpp.776177FC1C8D2B77.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/common.hpp.776177FC1C8D2B77.idx -------------------------------------------------------------------------------- /.clangd/index/hello.cpp.CD59E5A5168DA9F6.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/hello.cpp.CD59E5A5168DA9F6.idx -------------------------------------------------------------------------------- /.clangd/index/integer.hpp.40084CB6629A8DD5.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/integer.hpp.40084CB6629A8DD5.idx -------------------------------------------------------------------------------- /.clangd/index/mat2x2.hpp.A35A1626209E9371.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/mat2x2.hpp.A35A1626209E9371.idx -------------------------------------------------------------------------------- /.clangd/index/mat2x3.hpp.34B640D53EBCFDCE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/mat2x3.hpp.34B640D53EBCFDCE.idx -------------------------------------------------------------------------------- /.clangd/index/mat2x4.hpp.281840F367626EB7.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/mat2x4.hpp.281840F367626EB7.idx -------------------------------------------------------------------------------- /.clangd/index/mat3x2.hpp.C0A27D9C21AB5333.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/mat3x2.hpp.C0A27D9C21AB5333.idx -------------------------------------------------------------------------------- /.clangd/index/mat3x3.hpp.7DBFEFF2FAEE4341.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/mat3x3.hpp.7DBFEFF2FAEE4341.idx -------------------------------------------------------------------------------- /.clangd/index/mat3x4.hpp.C5123F170399368D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/mat3x4.hpp.C5123F170399368D.idx -------------------------------------------------------------------------------- /.clangd/index/mat4x2.hpp.9BD860823C696756.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/mat4x2.hpp.9BD860823C696756.idx -------------------------------------------------------------------------------- /.clangd/index/mat4x3.hpp.01C11E4820AB196E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/mat4x3.hpp.01C11E4820AB196E.idx -------------------------------------------------------------------------------- /.clangd/index/mat4x4.hpp.85CD2D78D2BBE272.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/mat4x4.hpp.85CD2D78D2BBE272.idx -------------------------------------------------------------------------------- /.clangd/index/matrix.hpp.9C450EB34372448C.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix.hpp.9C450EB34372448C.idx -------------------------------------------------------------------------------- /.clangd/index/packing.hpp.2B551C7FC81FA572.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/packing.hpp.2B551C7FC81FA572.idx -------------------------------------------------------------------------------- /.clangd/index/platform.h.552AAA6450F83081.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/platform.h.552AAA6450F83081.idx -------------------------------------------------------------------------------- /.clangd/index/setup.hpp.580FDDB4877E2C23.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/setup.hpp.580FDDB4877E2C23.idx -------------------------------------------------------------------------------- /.clangd/index/sphere.cpp.2C7E15E3A86831CE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/sphere.cpp.2C7E15E3A86831CE.idx -------------------------------------------------------------------------------- /.clangd/index/utils.hpp.2235619B05B03A88.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/utils.hpp.2235619B05B03A88.idx -------------------------------------------------------------------------------- /.clangd/index/external.hpp.2C77953201EBD4B9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/external.hpp.2C77953201EBD4B9.idx -------------------------------------------------------------------------------- /.clangd/index/geometric.hpp.6CBBD50501FA4A9D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/geometric.hpp.6CBBD50501FA4A9D.idx -------------------------------------------------------------------------------- /.clangd/index/gradient.cpp.2C063E810D3D9499.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/gradient.cpp.2C063E810D3D9499.idx -------------------------------------------------------------------------------- /.clangd/index/qualifier.hpp.F72B5FAD4BE2AF6B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/qualifier.hpp.F72B5FAD4BE2AF6B.idx -------------------------------------------------------------------------------- /.clangd/index/rtsphere.cpp.88EDECA5C1C691C8.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/rtsphere.cpp.88EDECA5C1C691C8.idx -------------------------------------------------------------------------------- /.clangd/index/type_half.hpp.6E00DDB3336E2017.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_half.hpp.6E00DDB3336E2017.idx -------------------------------------------------------------------------------- /.clangd/index/type_half.inl.5AAC328F1F4E698F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_half.inl.5AAC328F1F4E698F.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec1.hpp.ED6B28AC0C3E656C.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_vec1.hpp.ED6B28AC0C3E656C.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec1.inl.70058D7C12B26ABC.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_vec1.inl.70058D7C12B26ABC.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec2.hpp.DBFEC81E285E5A30.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_vec2.hpp.DBFEC81E285E5A30.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec2.inl.229A87816E4B78EB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_vec2.inl.229A87816E4B78EB.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec3.hpp.87BB8775DB2FB33F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_vec3.hpp.87BB8775DB2FB33F.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec3.inl.9EF357CA6C135A29.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_vec3.inl.9EF357CA6C135A29.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec4.hpp.7F65D2F322947648.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_vec4.hpp.7F65D2F322947648.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec4.inl.FF86FF9C7742A152.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_vec4.inl.FF86FF9C7742A152.idx -------------------------------------------------------------------------------- /.clangd/index/_vectorize.hpp.16375A72D8AF732A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/_vectorize.hpp.16375A72D8AF732A.idx -------------------------------------------------------------------------------- /.clangd/index/exponential.hpp.BBD595D1D76ECAF9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/exponential.hpp.BBD595D1D76ECAF9.idx -------------------------------------------------------------------------------- /.clangd/index/func_common.inl.0579D109A5FC26C0.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/func_common.inl.0579D109A5FC26C0.idx -------------------------------------------------------------------------------- /.clangd/index/func_integer.inl.BC26D75BB3E33466.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/func_integer.inl.BC26D75BB3E33466.idx -------------------------------------------------------------------------------- /.clangd/index/func_matrix.inl.3981093BE56CCE77.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/func_matrix.inl.3981093BE56CCE77.idx -------------------------------------------------------------------------------- /.clangd/index/func_packing.inl.A71D7C8E3F0F3859.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/func_packing.inl.A71D7C8E3F0F3859.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x2.hpp.E822F8B8C9E54486.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat2x2.hpp.E822F8B8C9E54486.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x2.inl.289FC7969B727B65.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat2x2.inl.289FC7969B727B65.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x3.hpp.9DFE11BA8EEA88B2.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat2x3.hpp.9DFE11BA8EEA88B2.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x3.inl.B9373D3BC0C54356.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat2x3.inl.B9373D3BC0C54356.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x4.hpp.DC9B4E974F7AD5CA.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat2x4.hpp.DC9B4E974F7AD5CA.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x4.inl.F2A9DAE89B9AA564.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat2x4.inl.F2A9DAE89B9AA564.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x2.hpp.2BC5F16CAD29DEFE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat3x2.hpp.2BC5F16CAD29DEFE.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x2.inl.25A96229CE2F0E10.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat3x2.inl.25A96229CE2F0E10.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x3.hpp.66A093F0F8C34587.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat3x3.hpp.66A093F0F8C34587.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x3.inl.C474BC14D7586FE9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat3x3.inl.C474BC14D7586FE9.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x4.hpp.2892EEBAF364DB27.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat3x4.hpp.2892EEBAF364DB27.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x4.inl.2A8AA30B8495281B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat3x4.inl.2A8AA30B8495281B.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x2.hpp.25653701EA258291.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat4x2.hpp.25653701EA258291.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x2.inl.2FA135695B06B1D1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat4x2.inl.2FA135695B06B1D1.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x3.hpp.C6287F3B896A7ADA.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat4x3.hpp.C6287F3B896A7ADA.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x3.inl.7A3858FCC96ED527.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat4x3.inl.7A3858FCC96ED527.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x4.hpp.F20E979E651E19F9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat4x4.hpp.F20E979E651E19F9.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x4.inl.48C1FAC2E297AF11.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/type_mat4x4.inl.48C1FAC2E297AF11.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool2.hpp.46A7F9D85C66340A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_bool2.hpp.46A7F9D85C66340A.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool3.hpp.CCD4A0D2ED841274.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_bool3.hpp.CCD4A0D2ED841274.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool4.hpp.E9BDA713B5E67866.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_bool4.hpp.E9BDA713B5E67866.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int2.hpp.96E45B2EC937F4CB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_int2.hpp.96E45B2EC937F4CB.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int3.hpp.4D9DB983557E1C8D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_int3.hpp.4D9DB983557E1C8D.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int4.hpp.209BB286690B995A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_int4.hpp.209BB286690B995A.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint2.hpp.C2BE2E1E6045B731.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_uint2.hpp.C2BE2E1E6045B731.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint3.hpp.E7C3D320644CB646.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_uint3.hpp.E7C3D320644CB646.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint4.hpp.322103A3E901BA61.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_uint4.hpp.322103A3E901BA61.idx -------------------------------------------------------------------------------- /.clangd/index/compute_common.hpp.291968145E636087.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/compute_common.hpp.291968145E636087.idx -------------------------------------------------------------------------------- /.clangd/index/func_geometric.inl.0D65C708E24EDDBE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/func_geometric.inl.0D65C708E24EDDBE.idx -------------------------------------------------------------------------------- /.clangd/index/trigonometric.hpp.ABF345E26EB7ACF7.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/trigonometric.hpp.ABF345E26EB7ACF7.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double2.hpp.F0E586C370711965.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_double2.hpp.F0E586C370711965.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double3.hpp.5A7F19AC3A57E22B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_double3.hpp.5A7F19AC3A57E22B.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double4.hpp.65EBC1F6146BF8A0.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_double4.hpp.65EBC1F6146BF8A0.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float2.hpp.DEECDCFEA259DF2E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_float2.hpp.DEECDCFEA259DF2E.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float3.hpp.9ED7F727C7A27E0A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_float3.hpp.9ED7F727C7A27E0A.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float4.hpp.DEDD64D1F158F531.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_float4.hpp.DEDD64D1F158F531.idx -------------------------------------------------------------------------------- /.clangd/index/func_exponential.inl.21E31BBFE459576E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/func_exponential.inl.21E31BBFE459576E.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x2.hpp.805C87ECF4541518.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double2x2.hpp.805C87ECF4541518.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x3.hpp.FFE9DC338AACE511.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double2x3.hpp.FFE9DC338AACE511.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x4.hpp.DF3B0CAB86BED47F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double2x4.hpp.DF3B0CAB86BED47F.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x2.hpp.36478A49347503AE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double3x2.hpp.36478A49347503AE.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x3.hpp.59B0C9EA13A34317.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double3x3.hpp.59B0C9EA13A34317.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x4.hpp.73841A1A8F31B0F1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double3x4.hpp.73841A1A8F31B0F1.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x2.hpp.736093FBAA6B5684.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double4x2.hpp.736093FBAA6B5684.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x3.hpp.03025A4F901ABA34.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double4x3.hpp.03025A4F901ABA34.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x4.hpp.67C1454C2ACF0AEE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double4x4.hpp.67C1454C2ACF0AEE.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x2.hpp.E06EE4CC4F1AB0A4.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float2x2.hpp.E06EE4CC4F1AB0A4.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x3.hpp.59FD3BF00C14D076.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float2x3.hpp.59FD3BF00C14D076.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x4.hpp.8CEBA5BC558B4C72.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float2x4.hpp.8CEBA5BC558B4C72.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x2.hpp.A497E0A9BD0BF16F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float3x2.hpp.A497E0A9BD0BF16F.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x3.hpp.F4AE0698B5AE5F20.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float3x3.hpp.F4AE0698B5AE5F20.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x4.hpp.65F80CA2069796E3.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float3x4.hpp.65F80CA2069796E3.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x2.hpp.826EF4E309C75035.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float4x2.hpp.826EF4E309C75035.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x3.hpp.490AA1A6D994C522.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float4x3.hpp.490AA1A6D994C522.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x4.hpp.E447480956451A7B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float4x4.hpp.E447480956451A7B.idx -------------------------------------------------------------------------------- /.clangd/index/vector_relational.hpp.997A5F542F6F790D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_relational.hpp.997A5F542F6F790D.idx -------------------------------------------------------------------------------- /.clangd/index/func_trigonometric.inl.0B7C8E918DA2864D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/func_trigonometric.inl.0B7C8E918DA2864D.idx -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /.clangd/index/func_vector_relational.inl.97C0A48476FC7089.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/func_vector_relational.inl.97C0A48476FC7089.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool2_precision.hpp.201FE0BFC65E3E53.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_bool2_precision.hpp.201FE0BFC65E3E53.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool3_precision.hpp.E6C42BBEB706F5F8.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_bool3_precision.hpp.E6C42BBEB706F5F8.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool4_precision.hpp.021C24AED2641828.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_bool4_precision.hpp.021C24AED2641828.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int2_precision.hpp.D2CD78801487B618.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_int2_precision.hpp.D2CD78801487B618.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int3_precision.hpp.D4BD94C0F2954177.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_int3_precision.hpp.D4BD94C0F2954177.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int4_precision.hpp.2C88C4A3C59FEFD6.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_int4_precision.hpp.2C88C4A3C59FEFD6.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint2_precision.hpp.948436C524F8B382.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_uint2_precision.hpp.948436C524F8B382.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint3_precision.hpp.90541EDEBB8B3A34.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_uint3_precision.hpp.90541EDEBB8B3A34.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint4_precision.hpp.1A52B8F472CFB0BF.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_uint4_precision.hpp.1A52B8F472CFB0BF.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double2_precision.hpp.D737D36E07AD5DB9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_double2_precision.hpp.D737D36E07AD5DB9.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double3_precision.hpp.8BB7D9B0864DD5D3.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_double3_precision.hpp.8BB7D9B0864DD5D3.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double4_precision.hpp.2D482C276D88579E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_double4_precision.hpp.2D482C276D88579E.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float2_precision.hpp.CADD1962598F2C2C.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_float2_precision.hpp.CADD1962598F2C2C.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float3_precision.hpp.1212F16AFD7FE46F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_float3_precision.hpp.1212F16AFD7FE46F.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float4_precision.hpp.679F9080B0D0FDBB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/vector_float4_precision.hpp.679F9080B0D0FDBB.idx -------------------------------------------------------------------------------- /.clangd/index/compute_vector_relational.hpp.04DB6A9E0C98D657.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/compute_vector_relational.hpp.04DB6A9E0C98D657.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x2_precision.hpp.FB94B58821420745.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double2x2_precision.hpp.FB94B58821420745.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x3_precision.hpp.D52D71F2B950581F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double2x3_precision.hpp.D52D71F2B950581F.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x4_precision.hpp.767F352780996DEB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double2x4_precision.hpp.767F352780996DEB.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x2_precision.hpp.2B36F8A105BB9516.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double3x2_precision.hpp.2B36F8A105BB9516.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x3_precision.hpp.DBD8B192DAA7BE13.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double3x3_precision.hpp.DBD8B192DAA7BE13.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x4_precision.hpp.249E2317F8920449.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double3x4_precision.hpp.249E2317F8920449.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x2_precision.hpp.CCCB19D8F205640F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double4x2_precision.hpp.CCCB19D8F205640F.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x3_precision.hpp.4AF844F2C27BFD46.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double4x3_precision.hpp.4AF844F2C27BFD46.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x4_precision.hpp.85DACA3D7FD243DF.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_double4x4_precision.hpp.85DACA3D7FD243DF.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x2_precision.hpp.CC9026831A8B0CD6.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float2x2_precision.hpp.CC9026831A8B0CD6.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x3_precision.hpp.30C8514389159A41.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float2x3_precision.hpp.30C8514389159A41.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x4_precision.hpp.38C005328240A5C9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float2x4_precision.hpp.38C005328240A5C9.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x2_precision.hpp.B493B11D8B484527.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float3x2_precision.hpp.B493B11D8B484527.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x3_precision.hpp.3D4FA308948E8AE4.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float3x3_precision.hpp.3D4FA308948E8AE4.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x4_precision.hpp.24E329BC7233A4F3.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float3x4_precision.hpp.24E329BC7233A4F3.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x2_precision.hpp.B37C54FCED4DF710.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float4x2_precision.hpp.B37C54FCED4DF710.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x3_precision.hpp.29AB225216492647.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float4x3_precision.hpp.29AB225216492647.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x4_precision.hpp.B26E29B85E11CF47.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/opencl-raytracer-oneweekend/master/.clangd/index/matrix_float4x4_precision.hpp.B26E29B85E11CF47.idx -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/oneweekend/ray.hpp: -------------------------------------------------------------------------------- 1 | #ifndef RAY_HPP 2 | #define RAY_HPP 3 | 4 | #include 5 | #include 6 | 7 | struct Ray { 8 | cl_float3 origin; 9 | cl_float3 direction; 10 | }; 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /include/custom/image.hpp: -------------------------------------------------------------------------------- 1 | #ifndef IMAGE_HPP 2 | #define IMAGE_HPP 3 | // stbi 4 | #define STB_IMAGE_WRITE_IMPLEMENTATION 5 | #include 6 | 7 | #define STB_IMAGE_IMPLEMENTATION 8 | #include 9 | 10 | #endif 11 | 12 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/oneweekend/external.hpp: -------------------------------------------------------------------------------- 1 | #ifndef EXTERNAL_HPP 2 | #define EXTERNAL_HPP 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /bin/errorlog.txt: -------------------------------------------------------------------------------- 1 | log 2 | :46:23: error: use of undeclared identifier 'seed' 3 | float a = map_range(seed.x, -1.0f, 1.0f, 0, 2 * PI); 4 | ^ 5 | :47:13: error: use of undeclared identifier 'seed' 6 | float z = seed.y; 7 | ^ 8 | :53:14: warning: implicit declaration of function 'random_vec_minmax' is invalid in C99 9 | Vec3 p = random_vec_minmax(seed, -1.0f, 1.0f); 10 | ^ 11 | 12 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/custom/external.hpp: -------------------------------------------------------------------------------- 1 | #ifndef EXTERNAL_HPP 2 | #define EXTERNAL_HPP 3 | // license: see, LICENSE 4 | // glm ------- 5 | #include 6 | // ---------- 7 | // assimp vs 8 | 9 | // opencl 10 | #include 11 | 12 | // system headers 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/oneweekend/sphere.hpp: -------------------------------------------------------------------------------- 1 | #ifndef SPHERE_HPP 2 | #define SPHERE_HPP 3 | #include 4 | #include 5 | 6 | struct Sphere { 7 | cl_float radius; 8 | cl_float3 center; 9 | Sphere(float rad, Vec3 cent) { 10 | radius = rad; 11 | center = cent.e; 12 | } 13 | }; 14 | 15 | struct MovingSphere { 16 | cl_float radius; 17 | cl_float3 center1; 18 | cl_float3 center2; 19 | cl_float time0; 20 | cl_float time1; 21 | MovingSphere(float rad, Vec3 cent, Vec3 cent2, float t0, 22 | float t1) 23 | : radius(rad), center1(cent.e), center2(cent2.e), 24 | time0(t0), time1(t1) {} 25 | }; 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | CMakeLists.txt.user 2 | CMakeCache.txt 3 | CMakeFiles 4 | CMakeScripts 5 | Testing 6 | Makefile 7 | cmake_install.cmake 8 | install_manifest.txt 9 | compile_commands.json 10 | CTestTestfile.cmake 11 | 12 | # Prerequisites 13 | *.d 14 | 15 | # Compiled Object files 16 | *.slo 17 | *.lo 18 | *.o 19 | *.obj 20 | 21 | # Precompiled Headers 22 | *.gch 23 | *.pch 24 | 25 | # Compiled Dynamic libraries 26 | *.so 27 | *.dylib 28 | *.dll 29 | 30 | # Fortran module files 31 | *.mod 32 | *.smod 33 | 34 | # Compiled Static libraries 35 | *.lai 36 | *.la 37 | *.a 38 | *.lib 39 | 40 | # Executables 41 | *.exe 42 | *.out 43 | *.app 44 | 45 | # by qm 46 | **/bin/media/** 47 | **/libs/** 48 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_common.inl: -------------------------------------------------------------------------------- 1 | #include "../matrix.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, U a) 7 | { 8 | return mat(x) * (static_cast(1) - a) + mat(y) * a; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, mat const& a) 13 | { 14 | return matrixCompMult(mat(x), static_cast(1) - a) + matrixCompMult(mat(y), a); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /include/glm/gtc/ulp.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_ulp 2 | /// @file glm/gtc/ulp.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_ulp GLM_GTC_ulp 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Allow the measurement of the accuracy of a function against a reference 12 | /// implementation. This extension works on floating-point data and provide results 13 | /// in ULP. 14 | 15 | #pragma once 16 | 17 | // Dependencies 18 | #include "../ext/scalar_ulp.hpp" 19 | #include "../ext/vector_ulp.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # pragma message("GLM: GLM_GTC_ulp extension included") 23 | #endif 24 | 25 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/gtx/scalar_relational.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | /// @file glm/gtx/scalar_relational.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Extend a position from a source to a position at a defined length. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # elif 22 | # pragma message("GLM: GLM_GTX_extend extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_scalar_relational 29 | /// @{ 30 | 31 | 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "scalar_relational.inl" 37 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_common.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_common 2 | /// @file glm/ext/matrix_common.hpp 3 | /// 4 | /// @defgroup ext_matrix_common GLM_EXT_matrix_common 5 | /// @ingroup ext 6 | /// 7 | /// Defines functions for common matrix operations. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_matrix_common 12 | 13 | #pragma once 14 | 15 | #include "../detail/qualifier.hpp" 16 | #include "../detail/_fixes.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_transform extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_common 25 | /// @{ 26 | 27 | template 28 | GLM_FUNC_DECL mat mix(mat const& x, mat const& y, mat const& a); 29 | 30 | template 31 | GLM_FUNC_DECL mat mix(mat const& x, mat const& y, U a); 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "matrix_common.inl" 37 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/gtx/normal.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | /// @file glm/gtx/normal.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_normal GLM_GTX_normal 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Compute the normal of a triangle. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # ifndef GLM_ENABLE_EXPERIMENTAL 21 | # pragma message("GLM: GLM_GTX_normal is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 22 | # elif 23 | # pragma message("GLM: GLM_GTX_normal extension included") 24 | # endif 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normal 30 | /// @{ 31 | 32 | /// Computes triangle normal from triangle points. 33 | /// 34 | /// @see gtx_normal 35 | template 36 | GLM_FUNC_DECL vec<3, T, Q> triangleNormal(vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "normal.inl" 42 | -------------------------------------------------------------------------------- /include/glm/gtx/mixed_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | /// @file glm/gtx/mixed_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_mixed_product GLM_GTX_mixed_producte 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Mixed product of 3 vectors. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_mixed_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # elif 22 | # pragma message("GLM: GLM_GTX_mixed_product extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_mixed_product 29 | /// @{ 30 | 31 | /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) 32 | template 33 | GLM_FUNC_DECL T mixedProduct( 34 | vec<3, T, Q> const& v1, 35 | vec<3, T, Q> const& v2, 36 | vec<3, T, Q> const& v3); 37 | 38 | /// @} 39 | }// namespace glm 40 | 41 | #include "mixed_product.inl" 42 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/gtx/extend.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_extend 2 | /// @file glm/gtx/extend.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_extend GLM_GTX_extend 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Extend a position from a source to a position at a defined length. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # elif 22 | # pragma message("GLM: GLM_GTX_extend extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_extend 29 | /// @{ 30 | 31 | /// Extends of Length the Origin position using the (Source - Origin) direction. 32 | /// @see gtx_extend 33 | template 34 | GLM_FUNC_DECL genType extend( 35 | genType const& Origin, 36 | genType const& Source, 37 | typename genType::value_type const Length); 38 | 39 | /// @} 40 | }//namespace glm 41 | 42 | #include "extend.inl" 43 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/gtx/projection.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | /// @file glm/gtx/projection.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_projection GLM_GTX_projection 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Projection of a vector to other one 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../geometric.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_projection is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # elif 22 | # pragma message("GLM: GLM_GTX_projection extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_projection 29 | /// @{ 30 | 31 | /// Projects x on Normal. 32 | /// 33 | /// @param[in] x A vector to project 34 | /// @param[in] Normal A normal that doesn't need to be of unit length. 35 | /// 36 | /// @see gtx_projection 37 | template 38 | GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); 39 | 40 | /// @} 41 | }//namespace glm 42 | 43 | #include "projection.inl" 44 | -------------------------------------------------------------------------------- /include/glm/gtx/perpendicular.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | /// @file glm/gtx/perpendicular.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_projection (dependence) 6 | /// 7 | /// @defgroup gtx_perpendicular GLM_GTX_perpendicular 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Perpendicular of a vector from other one 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include "../gtx/projection.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # ifndef GLM_ENABLE_EXPERIMENTAL 22 | # pragma message("GLM: GLM_GTX_perpendicular is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 23 | # elif 24 | # pragma message("GLM: GLM_GTX_perpendicular extension included") 25 | # endif 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_perpendicular 31 | /// @{ 32 | 33 | //! Projects x a perpendicular axis of Normal. 34 | //! From GLM_GTX_perpendicular extension. 35 | template 36 | GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "perpendicular.inl" 42 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/gtx/log_base.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | /// @file glm/gtx/log_base.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_log_base GLM_GTX_log_base 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Logarithm for any base. base can be a vector or a scalar. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_log_base is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # elif 22 | # pragma message("GLM: GLM_GTX_log_base extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_log_base 29 | /// @{ 30 | 31 | /// Logarithm for any base. 32 | /// From GLM_GTX_log_base. 33 | template 34 | GLM_FUNC_DECL genType log( 35 | genType const& x, 36 | genType const& base); 37 | 38 | /// Logarithm for any base. 39 | /// From GLM_GTX_log_base. 40 | template 41 | GLM_FUNC_DECL vec sign( 42 | vec const& x, 43 | vec const& base); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "log_base.inl" 49 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/ext/scalar_relational.inl: -------------------------------------------------------------------------------- 1 | #include "../common.hpp" 2 | #include "../ext/scalar_int_sized.hpp" 3 | #include "../ext/scalar_uint_sized.hpp" 4 | #include "../detail/type_float.hpp" 5 | 6 | namespace glm 7 | { 8 | template 9 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon) 10 | { 11 | return abs(x - y) <= epsilon; 12 | } 13 | 14 | template 15 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon) 16 | { 17 | return abs(x - y) > epsilon; 18 | } 19 | 20 | template 21 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, int MaxULPs) 22 | { 23 | detail::float_t const a(x); 24 | detail::float_t const b(y); 25 | 26 | // Different signs means they do not match. 27 | if(a.negative() != b.negative()) 28 | { 29 | // Check for equality to make sure +0==-0 30 | return a.mantissa() == b.mantissa() && a.exponent() == b.exponent(); 31 | } 32 | 33 | // Find the difference in ULPs. 34 | typename detail::float_t::int_type const DiffULPs = abs(a.i - b.i); 35 | return DiffULPs <= MaxULPs; 36 | } 37 | 38 | template 39 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, int ULPs) 40 | { 41 | return !equal(x, y, ULPs); 42 | } 43 | }//namespace glm 44 | -------------------------------------------------------------------------------- /src/sphere/sphere.cpp: -------------------------------------------------------------------------------- 1 | // render sphere in opencl 2 | #include 3 | // 4 | #include "utils.hpp" 5 | 6 | int main() { 7 | 8 | // 1. bellekte alan aç 9 | cpu_out = new cl_float3[IMWIDTH * IMHEIGHT]; 10 | 11 | // 2. opencl baglamini baslat 12 | init_opencl("kernels/sphere.cl", "render_sphere_with_normal"); 13 | 14 | // 3. OpenCL Buffer'ini ayarla 15 | cl_outp = cl::Buffer(contxt, CL_MEM_WRITE_ONLY, 16 | IMWIDTH * IMHEIGHT * sizeof(cl_float3)); 17 | 18 | // 4. Kernel argumanlarini olustur 19 | kernel.setArg(0, cl_outp); 20 | kernel.setArg(1, IMWIDTH); 21 | kernel.setArg(2, IMHEIGHT); 22 | 23 | // 5. Thread ve Bloklara dayali Veri hatti olustur 24 | std::size_t global_work_size = IMWIDTH * IMHEIGHT; 25 | std::size_t local_work_size = 32; 26 | 27 | clock_t baslar, biter; 28 | baslar = clock(); 29 | 30 | queue.enqueueNDRangeKernel(kernel, NULL, global_work_size, local_work_size); 31 | queue.finish(); 32 | 33 | // 6. Cikti al 34 | queue.enqueueReadBuffer(cl_outp, CL_TRUE, 0, 35 | IMWIDTH * IMHEIGHT * sizeof(cl_float3), cpu_out); 36 | biter = clock(); 37 | 38 | double saniyeler = ((double)(biter - baslar)) / CLOCKS_PER_SEC; 39 | std::cout << "Islem " << saniyeler << " saniye surdu" << std::endl; 40 | 41 | save_to_ppm("media/ppm/sphere.ppm"); 42 | 43 | // 7. Temizle == Bellegi bosalt 44 | clean_up(); 45 | 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /include/glm/gtx/raw_data.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | /// @file glm/gtx/raw_data.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_raw_data GLM_GTX_raw_data 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Projection of a vector to other one 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../ext/scalar_uint_sized.hpp" 17 | #include "../detail/setup.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # ifndef GLM_ENABLE_EXPERIMENTAL 21 | # pragma message("GLM: GLM_GTX_raw_data is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 22 | # elif 23 | # pragma message("GLM: GLM_GTX_raw_data extension included") 24 | # endif 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_raw_data 30 | /// @{ 31 | 32 | //! Type for byte numbers. 33 | //! From GLM_GTX_raw_data extension. 34 | typedef detail::uint8 byte; 35 | 36 | //! Type for word numbers. 37 | //! From GLM_GTX_raw_data extension. 38 | typedef detail::uint16 word; 39 | 40 | //! Type for dword numbers. 41 | //! From GLM_GTX_raw_data extension. 42 | typedef detail::uint32 dword; 43 | 44 | //! Type for qword numbers. 45 | //! From GLM_GTX_raw_data extension. 46 | typedef detail::uint64 qword; 47 | 48 | /// @} 49 | }// namespace glm 50 | 51 | #include "raw_data.inl" 52 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/gtx/texture.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | /// @file glm/gtx/texture.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_texture GLM_GTX_texture 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Wrapping mode of texture coordinates. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtc/integer.hpp" 18 | #include "../gtx/component_wise.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # ifndef GLM_ENABLE_EXPERIMENTAL 22 | # pragma message("GLM: GLM_GTX_texture is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 23 | # elif 24 | # pragma message("GLM: GLM_GTX_texture extension included") 25 | # endif 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_texture 31 | /// @{ 32 | 33 | /// Compute the number of mipmaps levels necessary to create a mipmap complete texture 34 | /// 35 | /// @param Extent Extent of the texture base level mipmap 36 | /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector 37 | /// @tparam T Floating-point or signed integer scalar types 38 | /// @tparam Q Value from qualifier enum 39 | template 40 | T levels(vec const& Extent); 41 | 42 | /// @} 43 | }// namespace glm 44 | 45 | #include "texture.inl" 46 | 47 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # ifndef GLM_ENABLE_EXPERIMENTAL 21 | # pragma message("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.") 22 | # elif 23 | # pragma message("GLM: GLM_GTX_matrix_cross_product extension included") 24 | # endif 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 | -------------------------------------------------------------------------------- /include/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 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # ifndef GLM_ENABLE_EXPERIMENTAL 23 | # pragma message("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.") 24 | # elif 25 | # pragma message("GLM: GLM_GTX_orthonormalize extension included") 26 | # endif 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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # elif 22 | # pragma message("GLM: GLM_GTX_closest_point extension included") 23 | # endif 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 | -------------------------------------------------------------------------------- /include/oneweekend/random.hpp: -------------------------------------------------------------------------------- 1 | #ifndef RANDOM_HPP 2 | #define RANDOM_HPP 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | Vec3 random_vec() { 9 | return Vec3(random_float(), random_float(), 10 | random_float()); 11 | } 12 | Vec3 random_vec(float mn, float mx) { 13 | return Vec3(random_float(mn, mx), random_float(mn, mx), 14 | random_float(mn, mx)); 15 | } 16 | Vec3 random_in_unit_sphere() { 17 | while (true) { 18 | Vec3 p = random_vec(-1, 1); 19 | if (p.length_squared() < 1.0f) { 20 | return p; 21 | } 22 | } 23 | } 24 | 25 | enum RandomType : cl_int { 26 | RANDOM_INT = 1, 27 | RANDOM_FLOAT = 2, 28 | RANDOM_UINT = 3, 29 | RANDOM_UINT3 = 4 30 | }; 31 | 32 | template class SceneRandom { 33 | public: 34 | std::vector rand_vals; 35 | int size; 36 | cl::Buffer cl_rand_vals; 37 | 38 | public: 39 | SceneRandom() : size(0) {} 40 | SceneRandom(const int obj_size) : size(obj_size) { 41 | std::vector rvals(size); 42 | rand_vals = rvals; 43 | } 44 | void addRandom(T val) { 45 | size++; 46 | rand_vals.push_back(val); 47 | } 48 | void addRandom(T val, const int index) { 49 | rand_vals[index] = val; 50 | } 51 | void to_buffer(cl::Context &context, 52 | cl::CommandQueue &queue) { 53 | std::cout << "random size: " << size << std::endl; 54 | make_buffer(cl_rand_vals, context, queue, size, 55 | rand_vals.data()); 56 | } 57 | }; 58 | 59 | #endif 60 | -------------------------------------------------------------------------------- /include/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 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("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.") 21 | # elif 22 | # pragma message("GLM: GLM_GTX_optimum_pow extension included") 23 | # endif 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 | -------------------------------------------------------------------------------- /include/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 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("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.") 21 | # elif 22 | # pragma message("GLM: GLM_GTX_polar_coordinates extension included") 23 | # endif 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 | -------------------------------------------------------------------------------- /include/oneweekend/camera.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CAMERA_HPP 2 | #define CAMERA_HPP 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | class Camera { 10 | public: 11 | cl_float3 origin; 12 | cl_float3 lower_left_corner; 13 | cl_float3 horizontal; 14 | cl_float3 vertical; 15 | cl_float3 w, v, u; 16 | cl_float lens_radius; 17 | cl_float time0; 18 | cl_float time1; 19 | 20 | public: 21 | Camera(Point3 lookfrom, Point3 lookat, Vec3 worldUp, 22 | float vfov, float aspect_ratio, float aperture, 23 | float focus_dist, float t0 = 0.0f, 24 | float t1 = 0.0f) { 25 | lens_radius = aperture / 2.0f; 26 | time0 = t0; 27 | time1 = t1; 28 | float theta = degrees_to_radians(vfov); 29 | float h = tan(theta / 2.0f); 30 | 31 | float view_height = 2.0f * h; 32 | float view_width = aspect_ratio * view_height; 33 | 34 | Vec3 wv = unit_vector(lookfrom - lookat); 35 | Vec3 uv = unit_vector(cross(worldUp, wv)); 36 | Vec3 vv = cross(wv, uv); 37 | 38 | Vec3 corig = Vec3(lookfrom.e); 39 | Vec3 hori = view_width * uv * focus_dist; 40 | Vec3 vert = view_height * vv * focus_dist; 41 | Vec3 lleft = corig - (hori / 2.0f) - (vert / 2.0f) - 42 | (focus_dist * wv); 43 | 44 | // pass values to attributes 45 | vertical = vert.e; 46 | horizontal = hori.e; 47 | lower_left_corner = lleft.e; 48 | origin = corig.e; 49 | w = wv.e; 50 | u = uv.e; 51 | v = vv.e; 52 | } 53 | }; 54 | 55 | #endif 56 | -------------------------------------------------------------------------------- /include/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 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 24 | # ifndef GLM_ENABLE_EXPERIMENTAL 25 | # pragma message("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.") 26 | # elif 27 | # pragma message("GLM: GLM_GTX_matrix_decompose extension included") 28 | # endif 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 | -------------------------------------------------------------------------------- /include/oneweekend/color.hpp: -------------------------------------------------------------------------------- 1 | #ifndef COLOR_HPP 2 | #define COLOR_HPP 3 | 4 | #include 5 | 6 | inline float clamp(float x, float min, float max) { 7 | bool xmin = x < min; 8 | bool xmax = x > max; 9 | if (xmin) 10 | return min; 11 | if (xmax) 12 | return max; 13 | return x; 14 | } 15 | 16 | inline int cast_color(float x) { 17 | return int(clamp(x, 0.0f, 0.999) * 256); 18 | } 19 | 20 | inline cl_int3 cast_color(cl_float4 incolor) { 21 | cl_int3 color = {{cast_color((float)incolor.s[0]), 22 | cast_color((float)incolor.s[1]), 23 | cast_color((float)incolor.s[2])}}; 24 | return color; 25 | } 26 | void save_to_ppm(const char *ppm_path, int imwidth, 27 | int imheight, cl_float4 *cpu_out) { 28 | std::ofstream ppm; 29 | ppm.open(ppm_path); 30 | 31 | ppm << "P3" << std::endl; 32 | ppm << imwidth << " " << imheight << std::endl; 33 | ppm << "255" << std::endl; 34 | /* 35 | for (int i = 0; i < imwidth * imheight; i++) { 36 | cl_int3 color = cast_color(cpu_out[i]); 37 | int ir = color.s[0]; 38 | int ig = color.s[1]; 39 | int ib = color.s[2]; 40 | ppm << ir << " " << ig << " " << ib << std::endl; 41 | } 42 | */ 43 | for (int j = imheight - 1; j >= 0; j--) { 44 | for (int i = 0; i < imwidth; i++) { 45 | cl_int3 color = cast_color(cpu_out[j * imwidth + i]); 46 | int ir = color.s[0]; 47 | int ig = color.s[1]; 48 | int ib = color.s[2]; 49 | ppm << ir << " " << ig << " " << ib << std::endl; 50 | } 51 | } 52 | 53 | ppm.close(); 54 | } 55 | 56 | #endif 57 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 28 | # ifndef GLM_ENABLE_EXPERIMENTAL 29 | # pragma message("GLM: GLM_GTX_string_cast is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 30 | # elif 31 | # pragma message("GLM: GLM_GTX_string_cast extension included") 32 | # endif 33 | #endif 34 | 35 | #if(GLM_COMPILER & GLM_COMPILER_CUDA) 36 | # error "GLM_GTX_string_cast is not supported on CUDA compiler" 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 | -------------------------------------------------------------------------------- /include/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 signed char int8; 30 | typedef signed short int16; 31 | typedef signed 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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # ifndef GLM_ENABLE_EXPERIMENTAL 21 | # pragma message("GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 22 | # elif 23 | # pragma message("GLM: GLM_GTX_wrap extension included") 24 | # endif 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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # ifndef GLM_ENABLE_EXPERIMENTAL 22 | # pragma message("GLM: GLM_GTX_gradient_paint is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 23 | # elif 24 | # pragma message("GLM: GLM_GTX_gradient_paint extension included") 25 | # endif 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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/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 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_float4x3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix_precision 10 | /// @{ 11 | 12 | /// 4 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<4, 3, float, lowp> lowp_mat4x3; 17 | 18 | /// 4 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<4, 3, float, mediump> mediump_mat4x3; 23 | 24 | /// 4 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<4, 3, float, highp> highp_mat4x3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_double2x3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x3_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 double-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, double, lowp> lowp_dmat2x3; 17 | 18 | /// 2 columns of 3 components matrix of double-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, double, mediump> mediump_dmat2x3; 23 | 24 | /// 2 columns of 3 components matrix of double-precision floating-point numbers using medium 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, double, highp> highp_dmat2x3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_double2x4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x4_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 double-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, double, lowp> lowp_dmat2x4; 17 | 18 | /// 2 columns of 4 components matrix of double-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, double, mediump> mediump_dmat2x4; 23 | 24 | /// 2 columns of 4 components matrix of double-precision floating-point numbers using medium 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, double, highp> highp_dmat2x4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_double3x2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x2_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 double-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, double, lowp> lowp_dmat3x2; 17 | 18 | /// 3 columns of 2 components matrix of double-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, double, mediump> mediump_dmat3x2; 23 | 24 | /// 3 columns of 2 components matrix of double-precision floating-point numbers using medium 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, double, highp> highp_dmat3x2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_double3x4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x4_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 double-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, double, lowp> lowp_dmat3x4; 17 | 18 | /// 3 columns of 4 components matrix of double-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, double, mediump> mediump_dmat3x4; 23 | 24 | /// 3 columns of 4 components matrix of double-precision floating-point numbers using medium 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, double, highp> highp_dmat3x4; 29 | 30 | /// @} 31 | }//namespace glm 32 | --------------------------------------------------------------------------------