├── include ├── glm │ ├── ext │ │ ├── scalar_packing.inl │ │ ├── vector_packing.inl │ │ ├── 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 │ │ ├── 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 │ │ ├── scalar_constants.inl │ │ ├── vector_packing.hpp │ │ ├── scalar_packing.hpp │ │ ├── vector_int1.hpp │ │ ├── matrix_int2x3.hpp │ │ ├── matrix_int2x4.hpp │ │ ├── matrix_int3x2.hpp │ │ ├── matrix_int3x4.hpp │ │ ├── matrix_int4x2.hpp │ │ ├── matrix_int4x3.hpp │ │ ├── matrix_uint3x4.hpp │ │ ├── matrix_uint2x3.hpp │ │ ├── matrix_uint2x4.hpp │ │ ├── matrix_uint3x2.hpp │ │ ├── matrix_uint4x2.hpp │ │ ├── matrix_uint4x3.hpp │ │ ├── vector_uint1.hpp │ │ ├── vector_float1.hpp │ │ ├── vector_double1.hpp │ │ ├── matrix_int2x2.hpp │ │ ├── matrix_int3x3.hpp │ │ ├── matrix_int4x4.hpp │ │ ├── matrix_uint2x2.hpp │ │ ├── matrix_uint3x3.hpp │ │ ├── matrix_uint4x4.hpp │ │ ├── vector_bool1_precision.hpp │ │ ├── quaternion_float.hpp │ │ ├── matrix_common.hpp │ │ ├── quaternion_double.hpp │ │ ├── quaternion_trigonometric.inl │ │ ├── quaternion_relational.inl │ │ ├── scalar_constants.hpp │ │ ├── scalar_relational.inl │ │ ├── vector_float1_precision.hpp │ │ ├── quaternion_float_precision.hpp │ │ ├── vector_double1_precision.hpp │ │ ├── quaternion_geometric.inl │ │ ├── matrix_int2x3_sized.hpp │ │ ├── matrix_int2x4_sized.hpp │ │ ├── matrix_int3x2_sized.hpp │ │ ├── matrix_int3x4_sized.hpp │ │ ├── matrix_int4x2_sized.hpp │ │ ├── matrix_int4x3_sized.hpp │ │ ├── matrix_uint3x2_sized.hpp │ │ ├── matrix_uint2x3_sized.hpp │ │ ├── matrix_uint2x4_sized.hpp │ │ ├── matrix_uint3x4_sized.hpp │ │ ├── matrix_uint4x2_sized.hpp │ │ ├── matrix_uint4x3_sized.hpp │ │ ├── vector_int1_sized.hpp │ │ ├── vector_int2_sized.hpp │ │ ├── vector_int3_sized.hpp │ │ ├── vector_int4_sized.hpp │ │ ├── vector_uint1_sized.hpp │ │ ├── vector_bool2_precision.hpp │ │ └── vector_bool3_precision.hpp │ ├── gtc │ │ ├── quaternion_simd.inl │ │ ├── type_precision.inl │ │ ├── matrix_transform.inl │ │ ├── reciprocal.hpp │ │ ├── vec1.hpp │ │ ├── integer.inl │ │ ├── integer.hpp │ │ ├── matrix_transform.hpp │ │ └── matrix_access.inl │ ├── 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 │ │ ├── wrap.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 │ │ ├── wrap.hpp │ │ ├── scalar_relational.hpp │ │ ├── gradient_paint.inl │ │ ├── extend.inl │ │ ├── normal.hpp │ │ ├── mixed_product.hpp │ │ ├── extend.hpp │ │ ├── projection.hpp │ │ ├── perpendicular.hpp │ │ ├── closest_point.inl │ │ ├── log_base.hpp │ │ ├── string_cast.hpp │ │ └── raw_data.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 │ ├── vec2.hpp │ ├── vec3.hpp │ └── vec4.hpp ├── vivaphysics │ ├── plinkenum.hpp │ ├── precision.hpp │ └── pfgenenum.hpp ├── external.hpp └── demos │ ├── apputils.hpp │ ├── texture.hpp │ └── meshutils.hpp ├── README.md ├── bin ├── media │ └── demos │ │ └── glsl │ │ ├── shadow_depth.frag │ │ ├── basic_color_light.frag │ │ ├── line.vert │ │ ├── basic_point_light.vert │ │ ├── shadow_depth.vert │ │ └── meshcolor.vert └── err.txt ├── .clangd └── index │ ├── app.hpp.73AE6FE30BC03F8B.idx │ ├── core.h.B71DB5B21EB946C2.idx │ ├── fwd.hpp.3F38E19D5F3F676B.idx │ ├── glad.c.63487DD2E1B07EB9.idx │ ├── glad.h.A8C000788EB12BE3.idx │ ├── glm.hpp.48A436E467C09FC3.idx │ ├── _fixes.hpp.5BC9322CC158D67E.idx │ ├── camera.hpp.454E1BEA03988A64.idx │ ├── common.hpp.C17AEDBAD37AEDA7.idx │ ├── debug.hpp.C906A1A88401C9C1.idx │ ├── debug.hpp.F570682C6AC64985.idx │ ├── light.hpp.34EE54F4D3834A1F.idx │ ├── main.cpp.72E7E24AA8596D97.idx │ ├── mat2x2.hpp.92AEF1E2A9B2BC23.idx │ ├── mat2x3.hpp.B49233943619DB0D.idx │ ├── mat2x4.hpp.980595EB946E99F7.idx │ ├── mat3x2.hpp.5A7DB28FCCCA876D.idx │ ├── mat3x3.hpp.CF2D4FA39A36B328.idx │ ├── mat3x4.hpp.BFB92D377687DD1D.idx │ ├── mat4x2.hpp.E05FA5C1A042ED95.idx │ ├── mat4x3.hpp.E95B67C53D263496.idx │ ├── mat4x4.hpp.71E34AEA9ED73D01.idx │ ├── matrix.hpp.AA71D2E2775BFBDD.idx │ ├── mesh.hpp.A5AC75A28C9D28FA.idx │ ├── pfgen.hpp.929FA2A180835932.idx │ ├── platform.h.6AE9960FF78F72A0.idx │ ├── plink.hpp.94808C72A24BCA08.idx │ ├── pworld.hpp.B428100856681113.idx │ ├── setup.hpp.268C3D193225941F.idx │ ├── shader.hpp.FD75EC4C092238C0.idx │ ├── vec1.hpp.BFD7678554113E8C.idx │ ├── vec2.hpp.3B10601D58D244CB.idx │ ├── vec3.hpp.D9CFE5C1453A3D9E.idx │ ├── vec4.hpp.62A2E57C1BE44554.idx │ ├── vertex.hpp.FE181EC60C85ED51.idx │ ├── apputils.hpp.33531E22E47D1EE9.idx │ ├── epsilon.hpp.7E7DD8E6E472F1B0.idx │ ├── epsilon.inl.C58A764939C70FD9.idx │ ├── external.hpp.2D188C3A47F567BC.idx │ ├── integer.hpp.A2C77DE27D7AC090.idx │ ├── massapp.hpp.9EF1CED9FAE65B01.idx │ ├── meshapp.hpp.AB9CCC1C3A5B142E.idx │ ├── packing.hpp.8914C7158CE8E156.idx │ ├── particle.hpp.96D812BD9B3A9ADB.idx │ ├── pcontact.hpp.08B1ED5815557DBD.idx │ ├── platform.cpp.5A34AAC2D4EEC284.idx │ ├── texture.hpp.7280487074CECE5E.idx │ ├── type_ptr.hpp.11CCADE121AA3C89.idx │ ├── type_ptr.inl.E112C76BD589B95A.idx │ ├── _vectorize.hpp.1F61062517254A6C.idx │ ├── ballistic.hpp.C73063211A8ED894.idx │ ├── constants.hpp.6C7466907DEA0355.idx │ ├── constants.inl.A3C1ADBFF24AEB97.idx │ ├── demowindow.cpp.7FDCCB7731AEB729.idx │ ├── exponential.hpp.1E40FF29DF117FF0.idx │ ├── func_common.inl.EFAC4EECD1A660AC.idx │ ├── func_matrix.inl.5226020CD08A327F.idx │ ├── geometric.hpp.27E2A58D3AB37845.idx │ ├── meshutils.hpp.1328C1BFB20D1E63.idx │ ├── pfgenenum.hpp.52D25085344DB177.idx │ ├── platformapp.hpp.3C2B90E8755BF218.idx │ ├── plinkenum.hpp.BDC15740ACC0E9AB.idx │ ├── precision.hpp.D8F3C04D761E93E9.idx │ ├── qualifier.hpp.C3FFEFDEA6030AD9.idx │ ├── quaternion.hpp.C02C5299477B1DE6.idx │ ├── quaternion.inl.F87764777A944239.idx │ ├── rendershape.hpp.77C7AD354453BD05.idx │ ├── type_float.hpp.D3152D63BCA2E11F.idx │ ├── type_half.hpp.C368342F1E05C9A5.idx │ ├── type_half.inl.7566A4C5EAD22872.idx │ ├── type_mat2x2.hpp.DC7D61BE39832C31.idx │ ├── type_mat2x2.inl.E2AAE0B856CB2D33.idx │ ├── type_mat2x3.hpp.E36EFD4888287AEB.idx │ ├── type_mat2x3.inl.CD67C99D611D6314.idx │ ├── type_mat2x4.hpp.723DEB8738C0AD7C.idx │ ├── type_mat2x4.inl.CF5325C6602A0FCC.idx │ ├── type_mat3x2.hpp.A75A8BC2A2BF9550.idx │ ├── type_mat3x2.inl.B464B3FEE0204641.idx │ ├── type_mat3x3.hpp.2E9411D956FF92B7.idx │ ├── type_mat3x3.inl.426CE9C6873968F8.idx │ ├── type_mat3x4.hpp.69E5403CCBD677CA.idx │ ├── type_mat3x4.inl.DB8AC3F278B834D7.idx │ ├── type_mat4x2.hpp.730CE4C35FDB4336.idx │ ├── type_mat4x2.inl.64DD05A6E743506C.idx │ ├── type_mat4x3.hpp.95E701A90F27087A.idx │ ├── type_mat4x3.inl.EED542D9FC097FF1.idx │ ├── type_mat4x4.hpp.3607E51432E45D01.idx │ ├── type_mat4x4.inl.B4F59150C414F0F1.idx │ ├── type_quat.hpp.79CC19EC22DF2E7A.idx │ ├── type_quat.inl.C4976F8B589E26D3.idx │ ├── type_vec1.hpp.C8D4C9BE84CACE1B.idx │ ├── type_vec1.inl.A124491DB04E121D.idx │ ├── type_vec2.hpp.E0C5C7B8F4335438.idx │ ├── type_vec2.inl.2FAAAB92E36DD08F.idx │ ├── type_vec3.hpp.E8DC77AF8DA5B4A8.idx │ ├── type_vec3.inl.2F6D536EB96FFE56.idx │ ├── type_vec4.hpp.E8A33A5BFADC517D.idx │ ├── type_vec4.inl.E4CD44A02906BE26.idx │ ├── vector_int1.hpp.CEEDBFFB460A1244.idx │ ├── vector_int2.hpp.FFFFF2E1149F5F3B.idx │ ├── vector_int3.hpp.C7DDF32B81E75FBF.idx │ ├── vector_int4.hpp.C822D61007FBEBDC.idx │ ├── ballisticdemo.cpp.DCB7EE26675AA904.idx │ ├── func_integer.inl.D515BA8B58FF7341.idx │ ├── func_packing.inl.886D3250EC45B1D8.idx │ ├── trigonometric.hpp.EF4D45EA3F411713.idx │ ├── vector_bool1.hpp.41693CF67D7C9823.idx │ ├── vector_bool2.hpp.551CE45E8044322A.idx │ ├── vector_bool3.hpp.F7F808D22E247CD4.idx │ ├── vector_bool4.hpp.DF48F22BB8F4874E.idx │ ├── vector_float1.hpp.08B97AEF9AD571EB.idx │ ├── vector_float2.hpp.97BB406E1ECC51C1.idx │ ├── vector_float3.hpp.E3CD86586FA06FEB.idx │ ├── vector_float4.hpp.E774C4816CAA33E1.idx │ ├── vector_uint1.hpp.76DDAD9BB365228B.idx │ ├── vector_uint2.hpp.2349E93A92329C1E.idx │ ├── vector_uint3.hpp.BB44EE23BB583130.idx │ ├── vector_uint4.hpp.123794EE5F36CAE4.idx │ ├── compute_common.hpp.4EF8B8D2BB9F37B6.idx │ ├── func_exponential.inl.73D5C85085808401.idx │ ├── func_geometric.inl.79AB75245D490544.idx │ ├── matrix_double2x2.hpp.C0C80C0C91915A20.idx │ ├── matrix_double2x3.hpp.162F36564D433597.idx │ ├── matrix_double2x4.hpp.9D085281EF1D8FA9.idx │ ├── matrix_double3x2.hpp.91C1292B49A7A842.idx │ ├── matrix_double3x3.hpp.7F368955AEBF1F56.idx │ ├── matrix_double3x4.hpp.DD141FDF5DFDD103.idx │ ├── matrix_double4x2.hpp.3633D09FDEE73D1D.idx │ ├── matrix_double4x3.hpp.C29605BD46C8E57B.idx │ ├── matrix_double4x4.hpp.9A8AE394F039C5A0.idx │ ├── matrix_float2x2.hpp.927A2302F0AE042F.idx │ ├── matrix_float2x3.hpp.D3EAE04EF45D5293.idx │ ├── matrix_float2x4.hpp.88AE2CB9AD789B55.idx │ ├── matrix_float3x2.hpp.535DBFC539E447E7.idx │ ├── matrix_float3x3.hpp.1077AE93CEC99206.idx │ ├── matrix_float3x4.hpp.AD8032CA0F62AAAE.idx │ ├── matrix_float4x2.hpp.1D23AF3A83BCBD42.idx │ ├── matrix_float4x3.hpp.0B71BACB3974003F.idx │ ├── matrix_float4x4.hpp.1A8745935C545560.idx │ ├── matrix_transform.hpp.95DE60511EE4A264.idx │ ├── matrix_transform.hpp.9D21F9FF67195386.idx │ ├── matrix_transform.inl.29E72BAF0D0922F1.idx │ ├── matrix_transform.inl.BD01D6A6989D494A.idx │ ├── meshdemowindow.cpp.D40630DA6F7919B1.idx │ ├── quaternion_float.hpp.03C13B307AD86805.idx │ ├── scalar_constants.hpp.16207C9D95B9D6AE.idx │ ├── scalar_constants.inl.8B05B0C8D46D18E7.idx │ ├── scalar_int_sized.hpp.7E5BFB582A04F742.idx │ ├── vector_double1.hpp.C9EC402D005B4ADA.idx │ ├── vector_double2.hpp.443A45A306AC6FCC.idx │ ├── vector_double3.hpp.2395D41672AD9BE1.idx │ ├── vector_double4.hpp.9BD504A4A7024CFC.idx │ ├── func_trigonometric.inl.E76712308DA6BB87.idx │ ├── matrix_clip_space.hpp.1EFBD092467D7A4A.idx │ ├── matrix_clip_space.inl.7EE937A2EE3B1196.idx │ ├── matrix_projection.hpp.B684807CC073819B.idx │ ├── matrix_projection.inl.7BB76A178EDE650E.idx │ ├── quaternion_common.hpp.EF0283C5186A7D36.idx │ ├── quaternion_common.inl.6EA43AC617A6F0F4.idx │ ├── quaternion_double.hpp.A4F16600CE865440.idx │ ├── scalar_uint_sized.hpp.B6062179A75035C6.idx │ ├── vector_int1_sized.hpp.DE2CB3AED1DBF6A0.idx │ ├── vector_int2_sized.hpp.33F2E5C35D7D0536.idx │ ├── vector_int3_sized.hpp.52978F0AEE2D2DA1.idx │ ├── vector_int4_sized.hpp.B013BE46DC3F7BD2.idx │ ├── vector_relational.hpp.43BF150B795C6208.idx │ ├── vector_relational.hpp.C48BAA9563F5B5DA.idx │ ├── vector_relational.inl.06185C60D2D3904F.idx │ ├── vector_uint1_sized.hpp.AD454395657F88C2.idx │ ├── vector_uint2_sized.hpp.30D48D7C27EC9BD4.idx │ ├── vector_uint3_sized.hpp.412E219FE685A210.idx │ ├── vector_uint4_sized.hpp.7392C030183A179A.idx │ ├── quaternion_geometric.hpp.97017743A13BB63C.idx │ ├── quaternion_geometric.inl.B3CE6FDB5873EE29.idx │ ├── quaternion_relational.hpp.52FB3DD0D09D9C30.idx │ ├── quaternion_relational.inl.84D9042EF3FD68BA.idx │ ├── quaternion_transform.hpp.F0F1174449E94318.idx │ ├── quaternion_transform.inl.03BE1B9A5C2C2ED2.idx │ ├── func_vector_relational.inl.6773506C59136C1A.idx │ ├── vector_bool1_precision.hpp.966FC4A27F2A3A39.idx │ ├── vector_bool2_precision.hpp.823EAC2B68A97864.idx │ ├── vector_bool3_precision.hpp.9E38B0ADC710000F.idx │ ├── vector_bool4_precision.hpp.FED386778F2F62DA.idx │ ├── vector_float1_precision.hpp.5F47F9F44D1316BE.idx │ ├── vector_float2_precision.hpp.A7F6A362DF2C2336.idx │ ├── vector_float3_precision.hpp.756950A41B50841F.idx │ ├── vector_float4_precision.hpp.95C3D081229AA691.idx │ ├── compute_vector_relational.hpp.0197E84F49BFF1D6.idx │ ├── matrix_double2x2_precision.hpp.2C5901B30DEA3BE4.idx │ ├── matrix_double2x3_precision.hpp.9A4F47B3ED38AA3A.idx │ ├── matrix_double2x4_precision.hpp.55F02CF2A7B88576.idx │ ├── matrix_double3x2_precision.hpp.81D84195C0D2AAC6.idx │ ├── matrix_double3x3_precision.hpp.866369420067C56E.idx │ ├── matrix_double3x4_precision.hpp.CE74AE24DDAAE720.idx │ ├── matrix_double4x2_precision.hpp.B189A2896C57EFB4.idx │ ├── matrix_double4x3_precision.hpp.9FBB03C6C4C850DD.idx │ ├── matrix_double4x4_precision.hpp.A9255374ACD1260E.idx │ ├── matrix_float2x2_precision.hpp.D816A3534EA34054.idx │ ├── matrix_float2x3_precision.hpp.8D00F6C21388D914.idx │ ├── matrix_float2x4_precision.hpp.CE557C2E220889AE.idx │ ├── matrix_float3x2_precision.hpp.680C68222C5097DD.idx │ ├── matrix_float3x3_precision.hpp.597903EED690D041.idx │ ├── matrix_float3x4_precision.hpp.97E91F1B195E8EF0.idx │ ├── matrix_float4x2_precision.hpp.CF7BDFBE7409F00B.idx │ ├── matrix_float4x3_precision.hpp.CDD1A9156939B140.idx │ ├── matrix_float4x4_precision.hpp.4E9F744443591C72.idx │ ├── quaternion_float_precision.hpp.B0C7C54C0512381D.idx │ ├── quaternion_trigonometric.hpp.B08BD41C1A6C6E5F.idx │ ├── quaternion_trigonometric.inl.E70B111F1A6105BF.idx │ ├── vector_double1_precision.hpp.6E201D8253BBBA44.idx │ ├── vector_double2_precision.hpp.4C95EBB7534C9A45.idx │ ├── vector_double3_precision.hpp.1A6E6F330EB0BF55.idx │ ├── vector_double4_precision.hpp.3A3A632ED095A349.idx │ └── quaternion_double_precision.hpp.BF399AFB0A26526A.idx ├── src ├── main.cpp └── demos │ ├── platform.cpp │ ├── meshdemowindow.cpp │ ├── demowindow.cpp │ └── ballisticdemo.cpp └── .gitignore /include/glm/ext/scalar_packing.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /include/glm/ext/vector_packing.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /include/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /include/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # physics-engine 2 | Physics Engine trial 3 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /include/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /bin/media/demos/glsl/shadow_depth.frag: -------------------------------------------------------------------------------- 1 | #version 330 2 | void main() { gl_FragDepth = gl_FragCoord.z; } 3 | -------------------------------------------------------------------------------- /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/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/include/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /.clangd/index/app.hpp.73AE6FE30BC03F8B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/app.hpp.73AE6FE30BC03F8B.idx -------------------------------------------------------------------------------- /.clangd/index/core.h.B71DB5B21EB946C2.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/core.h.B71DB5B21EB946C2.idx -------------------------------------------------------------------------------- /.clangd/index/fwd.hpp.3F38E19D5F3F676B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/fwd.hpp.3F38E19D5F3F676B.idx -------------------------------------------------------------------------------- /.clangd/index/glad.c.63487DD2E1B07EB9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/glad.c.63487DD2E1B07EB9.idx -------------------------------------------------------------------------------- /.clangd/index/glad.h.A8C000788EB12BE3.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/glad.h.A8C000788EB12BE3.idx -------------------------------------------------------------------------------- /.clangd/index/glm.hpp.48A436E467C09FC3.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/glm.hpp.48A436E467C09FC3.idx -------------------------------------------------------------------------------- /.clangd/index/_fixes.hpp.5BC9322CC158D67E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/_fixes.hpp.5BC9322CC158D67E.idx -------------------------------------------------------------------------------- /.clangd/index/camera.hpp.454E1BEA03988A64.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/camera.hpp.454E1BEA03988A64.idx -------------------------------------------------------------------------------- /.clangd/index/common.hpp.C17AEDBAD37AEDA7.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/common.hpp.C17AEDBAD37AEDA7.idx -------------------------------------------------------------------------------- /.clangd/index/debug.hpp.C906A1A88401C9C1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/debug.hpp.C906A1A88401C9C1.idx -------------------------------------------------------------------------------- /.clangd/index/debug.hpp.F570682C6AC64985.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/debug.hpp.F570682C6AC64985.idx -------------------------------------------------------------------------------- /.clangd/index/light.hpp.34EE54F4D3834A1F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/light.hpp.34EE54F4D3834A1F.idx -------------------------------------------------------------------------------- /.clangd/index/main.cpp.72E7E24AA8596D97.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/main.cpp.72E7E24AA8596D97.idx -------------------------------------------------------------------------------- /.clangd/index/mat2x2.hpp.92AEF1E2A9B2BC23.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mat2x2.hpp.92AEF1E2A9B2BC23.idx -------------------------------------------------------------------------------- /.clangd/index/mat2x3.hpp.B49233943619DB0D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mat2x3.hpp.B49233943619DB0D.idx -------------------------------------------------------------------------------- /.clangd/index/mat2x4.hpp.980595EB946E99F7.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mat2x4.hpp.980595EB946E99F7.idx -------------------------------------------------------------------------------- /.clangd/index/mat3x2.hpp.5A7DB28FCCCA876D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mat3x2.hpp.5A7DB28FCCCA876D.idx -------------------------------------------------------------------------------- /.clangd/index/mat3x3.hpp.CF2D4FA39A36B328.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mat3x3.hpp.CF2D4FA39A36B328.idx -------------------------------------------------------------------------------- /.clangd/index/mat3x4.hpp.BFB92D377687DD1D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mat3x4.hpp.BFB92D377687DD1D.idx -------------------------------------------------------------------------------- /.clangd/index/mat4x2.hpp.E05FA5C1A042ED95.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mat4x2.hpp.E05FA5C1A042ED95.idx -------------------------------------------------------------------------------- /.clangd/index/mat4x3.hpp.E95B67C53D263496.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mat4x3.hpp.E95B67C53D263496.idx -------------------------------------------------------------------------------- /.clangd/index/mat4x4.hpp.71E34AEA9ED73D01.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mat4x4.hpp.71E34AEA9ED73D01.idx -------------------------------------------------------------------------------- /.clangd/index/matrix.hpp.AA71D2E2775BFBDD.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix.hpp.AA71D2E2775BFBDD.idx -------------------------------------------------------------------------------- /.clangd/index/mesh.hpp.A5AC75A28C9D28FA.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/mesh.hpp.A5AC75A28C9D28FA.idx -------------------------------------------------------------------------------- /.clangd/index/pfgen.hpp.929FA2A180835932.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/pfgen.hpp.929FA2A180835932.idx -------------------------------------------------------------------------------- /.clangd/index/platform.h.6AE9960FF78F72A0.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/platform.h.6AE9960FF78F72A0.idx -------------------------------------------------------------------------------- /.clangd/index/plink.hpp.94808C72A24BCA08.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/plink.hpp.94808C72A24BCA08.idx -------------------------------------------------------------------------------- /.clangd/index/pworld.hpp.B428100856681113.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/pworld.hpp.B428100856681113.idx -------------------------------------------------------------------------------- /.clangd/index/setup.hpp.268C3D193225941F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/setup.hpp.268C3D193225941F.idx -------------------------------------------------------------------------------- /.clangd/index/shader.hpp.FD75EC4C092238C0.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/shader.hpp.FD75EC4C092238C0.idx -------------------------------------------------------------------------------- /.clangd/index/vec1.hpp.BFD7678554113E8C.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vec1.hpp.BFD7678554113E8C.idx -------------------------------------------------------------------------------- /.clangd/index/vec2.hpp.3B10601D58D244CB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vec2.hpp.3B10601D58D244CB.idx -------------------------------------------------------------------------------- /.clangd/index/vec3.hpp.D9CFE5C1453A3D9E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vec3.hpp.D9CFE5C1453A3D9E.idx -------------------------------------------------------------------------------- /.clangd/index/vec4.hpp.62A2E57C1BE44554.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vec4.hpp.62A2E57C1BE44554.idx -------------------------------------------------------------------------------- /.clangd/index/vertex.hpp.FE181EC60C85ED51.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vertex.hpp.FE181EC60C85ED51.idx -------------------------------------------------------------------------------- /include/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /.clangd/index/apputils.hpp.33531E22E47D1EE9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/apputils.hpp.33531E22E47D1EE9.idx -------------------------------------------------------------------------------- /.clangd/index/epsilon.hpp.7E7DD8E6E472F1B0.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/epsilon.hpp.7E7DD8E6E472F1B0.idx -------------------------------------------------------------------------------- /.clangd/index/epsilon.inl.C58A764939C70FD9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/epsilon.inl.C58A764939C70FD9.idx -------------------------------------------------------------------------------- /.clangd/index/external.hpp.2D188C3A47F567BC.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/external.hpp.2D188C3A47F567BC.idx -------------------------------------------------------------------------------- /.clangd/index/integer.hpp.A2C77DE27D7AC090.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/integer.hpp.A2C77DE27D7AC090.idx -------------------------------------------------------------------------------- /.clangd/index/massapp.hpp.9EF1CED9FAE65B01.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/massapp.hpp.9EF1CED9FAE65B01.idx -------------------------------------------------------------------------------- /.clangd/index/meshapp.hpp.AB9CCC1C3A5B142E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/meshapp.hpp.AB9CCC1C3A5B142E.idx -------------------------------------------------------------------------------- /.clangd/index/packing.hpp.8914C7158CE8E156.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/packing.hpp.8914C7158CE8E156.idx -------------------------------------------------------------------------------- /.clangd/index/particle.hpp.96D812BD9B3A9ADB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/particle.hpp.96D812BD9B3A9ADB.idx -------------------------------------------------------------------------------- /.clangd/index/pcontact.hpp.08B1ED5815557DBD.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/pcontact.hpp.08B1ED5815557DBD.idx -------------------------------------------------------------------------------- /.clangd/index/platform.cpp.5A34AAC2D4EEC284.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/platform.cpp.5A34AAC2D4EEC284.idx -------------------------------------------------------------------------------- /.clangd/index/texture.hpp.7280487074CECE5E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/texture.hpp.7280487074CECE5E.idx -------------------------------------------------------------------------------- /.clangd/index/type_ptr.hpp.11CCADE121AA3C89.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_ptr.hpp.11CCADE121AA3C89.idx -------------------------------------------------------------------------------- /.clangd/index/type_ptr.inl.E112C76BD589B95A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_ptr.inl.E112C76BD589B95A.idx -------------------------------------------------------------------------------- /.clangd/index/_vectorize.hpp.1F61062517254A6C.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/_vectorize.hpp.1F61062517254A6C.idx -------------------------------------------------------------------------------- /.clangd/index/ballistic.hpp.C73063211A8ED894.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/ballistic.hpp.C73063211A8ED894.idx -------------------------------------------------------------------------------- /.clangd/index/constants.hpp.6C7466907DEA0355.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/constants.hpp.6C7466907DEA0355.idx -------------------------------------------------------------------------------- /.clangd/index/constants.inl.A3C1ADBFF24AEB97.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/constants.inl.A3C1ADBFF24AEB97.idx -------------------------------------------------------------------------------- /.clangd/index/demowindow.cpp.7FDCCB7731AEB729.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/demowindow.cpp.7FDCCB7731AEB729.idx -------------------------------------------------------------------------------- /.clangd/index/exponential.hpp.1E40FF29DF117FF0.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/exponential.hpp.1E40FF29DF117FF0.idx -------------------------------------------------------------------------------- /.clangd/index/func_common.inl.EFAC4EECD1A660AC.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/func_common.inl.EFAC4EECD1A660AC.idx -------------------------------------------------------------------------------- /.clangd/index/func_matrix.inl.5226020CD08A327F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/func_matrix.inl.5226020CD08A327F.idx -------------------------------------------------------------------------------- /.clangd/index/geometric.hpp.27E2A58D3AB37845.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/geometric.hpp.27E2A58D3AB37845.idx -------------------------------------------------------------------------------- /.clangd/index/meshutils.hpp.1328C1BFB20D1E63.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/meshutils.hpp.1328C1BFB20D1E63.idx -------------------------------------------------------------------------------- /.clangd/index/pfgenenum.hpp.52D25085344DB177.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/pfgenenum.hpp.52D25085344DB177.idx -------------------------------------------------------------------------------- /.clangd/index/platformapp.hpp.3C2B90E8755BF218.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/platformapp.hpp.3C2B90E8755BF218.idx -------------------------------------------------------------------------------- /.clangd/index/plinkenum.hpp.BDC15740ACC0E9AB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/plinkenum.hpp.BDC15740ACC0E9AB.idx -------------------------------------------------------------------------------- /.clangd/index/precision.hpp.D8F3C04D761E93E9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/precision.hpp.D8F3C04D761E93E9.idx -------------------------------------------------------------------------------- /.clangd/index/qualifier.hpp.C3FFEFDEA6030AD9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/qualifier.hpp.C3FFEFDEA6030AD9.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion.hpp.C02C5299477B1DE6.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion.hpp.C02C5299477B1DE6.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion.inl.F87764777A944239.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion.inl.F87764777A944239.idx -------------------------------------------------------------------------------- /.clangd/index/rendershape.hpp.77C7AD354453BD05.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/rendershape.hpp.77C7AD354453BD05.idx -------------------------------------------------------------------------------- /.clangd/index/type_float.hpp.D3152D63BCA2E11F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_float.hpp.D3152D63BCA2E11F.idx -------------------------------------------------------------------------------- /.clangd/index/type_half.hpp.C368342F1E05C9A5.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_half.hpp.C368342F1E05C9A5.idx -------------------------------------------------------------------------------- /.clangd/index/type_half.inl.7566A4C5EAD22872.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_half.inl.7566A4C5EAD22872.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x2.hpp.DC7D61BE39832C31.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat2x2.hpp.DC7D61BE39832C31.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x2.inl.E2AAE0B856CB2D33.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat2x2.inl.E2AAE0B856CB2D33.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x3.hpp.E36EFD4888287AEB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat2x3.hpp.E36EFD4888287AEB.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x3.inl.CD67C99D611D6314.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat2x3.inl.CD67C99D611D6314.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x4.hpp.723DEB8738C0AD7C.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat2x4.hpp.723DEB8738C0AD7C.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat2x4.inl.CF5325C6602A0FCC.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat2x4.inl.CF5325C6602A0FCC.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x2.hpp.A75A8BC2A2BF9550.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat3x2.hpp.A75A8BC2A2BF9550.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x2.inl.B464B3FEE0204641.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat3x2.inl.B464B3FEE0204641.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x3.hpp.2E9411D956FF92B7.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat3x3.hpp.2E9411D956FF92B7.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x3.inl.426CE9C6873968F8.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat3x3.inl.426CE9C6873968F8.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x4.hpp.69E5403CCBD677CA.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat3x4.hpp.69E5403CCBD677CA.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat3x4.inl.DB8AC3F278B834D7.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat3x4.inl.DB8AC3F278B834D7.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x2.hpp.730CE4C35FDB4336.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat4x2.hpp.730CE4C35FDB4336.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x2.inl.64DD05A6E743506C.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat4x2.inl.64DD05A6E743506C.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x3.hpp.95E701A90F27087A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat4x3.hpp.95E701A90F27087A.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x3.inl.EED542D9FC097FF1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat4x3.inl.EED542D9FC097FF1.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x4.hpp.3607E51432E45D01.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat4x4.hpp.3607E51432E45D01.idx -------------------------------------------------------------------------------- /.clangd/index/type_mat4x4.inl.B4F59150C414F0F1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_mat4x4.inl.B4F59150C414F0F1.idx -------------------------------------------------------------------------------- /.clangd/index/type_quat.hpp.79CC19EC22DF2E7A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_quat.hpp.79CC19EC22DF2E7A.idx -------------------------------------------------------------------------------- /.clangd/index/type_quat.inl.C4976F8B589E26D3.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_quat.inl.C4976F8B589E26D3.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec1.hpp.C8D4C9BE84CACE1B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_vec1.hpp.C8D4C9BE84CACE1B.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec1.inl.A124491DB04E121D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_vec1.inl.A124491DB04E121D.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec2.hpp.E0C5C7B8F4335438.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_vec2.hpp.E0C5C7B8F4335438.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec2.inl.2FAAAB92E36DD08F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_vec2.inl.2FAAAB92E36DD08F.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec3.hpp.E8DC77AF8DA5B4A8.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_vec3.hpp.E8DC77AF8DA5B4A8.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec3.inl.2F6D536EB96FFE56.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_vec3.inl.2F6D536EB96FFE56.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec4.hpp.E8A33A5BFADC517D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_vec4.hpp.E8A33A5BFADC517D.idx -------------------------------------------------------------------------------- /.clangd/index/type_vec4.inl.E4CD44A02906BE26.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/type_vec4.inl.E4CD44A02906BE26.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int1.hpp.CEEDBFFB460A1244.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_int1.hpp.CEEDBFFB460A1244.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int2.hpp.FFFFF2E1149F5F3B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_int2.hpp.FFFFF2E1149F5F3B.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int3.hpp.C7DDF32B81E75FBF.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_int3.hpp.C7DDF32B81E75FBF.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int4.hpp.C822D61007FBEBDC.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_int4.hpp.C822D61007FBEBDC.idx -------------------------------------------------------------------------------- /.clangd/index/ballisticdemo.cpp.DCB7EE26675AA904.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/ballisticdemo.cpp.DCB7EE26675AA904.idx -------------------------------------------------------------------------------- /.clangd/index/func_integer.inl.D515BA8B58FF7341.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/func_integer.inl.D515BA8B58FF7341.idx -------------------------------------------------------------------------------- /.clangd/index/func_packing.inl.886D3250EC45B1D8.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/func_packing.inl.886D3250EC45B1D8.idx -------------------------------------------------------------------------------- /.clangd/index/trigonometric.hpp.EF4D45EA3F411713.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/trigonometric.hpp.EF4D45EA3F411713.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool1.hpp.41693CF67D7C9823.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_bool1.hpp.41693CF67D7C9823.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool2.hpp.551CE45E8044322A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_bool2.hpp.551CE45E8044322A.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool3.hpp.F7F808D22E247CD4.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_bool3.hpp.F7F808D22E247CD4.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool4.hpp.DF48F22BB8F4874E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_bool4.hpp.DF48F22BB8F4874E.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float1.hpp.08B97AEF9AD571EB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_float1.hpp.08B97AEF9AD571EB.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float2.hpp.97BB406E1ECC51C1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_float2.hpp.97BB406E1ECC51C1.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float3.hpp.E3CD86586FA06FEB.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_float3.hpp.E3CD86586FA06FEB.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float4.hpp.E774C4816CAA33E1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_float4.hpp.E774C4816CAA33E1.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint1.hpp.76DDAD9BB365228B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_uint1.hpp.76DDAD9BB365228B.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint2.hpp.2349E93A92329C1E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_uint2.hpp.2349E93A92329C1E.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint3.hpp.BB44EE23BB583130.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_uint3.hpp.BB44EE23BB583130.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint4.hpp.123794EE5F36CAE4.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_uint4.hpp.123794EE5F36CAE4.idx -------------------------------------------------------------------------------- /.clangd/index/compute_common.hpp.4EF8B8D2BB9F37B6.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/compute_common.hpp.4EF8B8D2BB9F37B6.idx -------------------------------------------------------------------------------- /.clangd/index/func_exponential.inl.73D5C85085808401.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/func_exponential.inl.73D5C85085808401.idx -------------------------------------------------------------------------------- /.clangd/index/func_geometric.inl.79AB75245D490544.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/func_geometric.inl.79AB75245D490544.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x2.hpp.C0C80C0C91915A20.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double2x2.hpp.C0C80C0C91915A20.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x3.hpp.162F36564D433597.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double2x3.hpp.162F36564D433597.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x4.hpp.9D085281EF1D8FA9.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double2x4.hpp.9D085281EF1D8FA9.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x2.hpp.91C1292B49A7A842.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double3x2.hpp.91C1292B49A7A842.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x3.hpp.7F368955AEBF1F56.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double3x3.hpp.7F368955AEBF1F56.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x4.hpp.DD141FDF5DFDD103.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double3x4.hpp.DD141FDF5DFDD103.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x2.hpp.3633D09FDEE73D1D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double4x2.hpp.3633D09FDEE73D1D.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x3.hpp.C29605BD46C8E57B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double4x3.hpp.C29605BD46C8E57B.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x4.hpp.9A8AE394F039C5A0.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double4x4.hpp.9A8AE394F039C5A0.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x2.hpp.927A2302F0AE042F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float2x2.hpp.927A2302F0AE042F.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x3.hpp.D3EAE04EF45D5293.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float2x3.hpp.D3EAE04EF45D5293.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x4.hpp.88AE2CB9AD789B55.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float2x4.hpp.88AE2CB9AD789B55.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x2.hpp.535DBFC539E447E7.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float3x2.hpp.535DBFC539E447E7.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x3.hpp.1077AE93CEC99206.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float3x3.hpp.1077AE93CEC99206.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x4.hpp.AD8032CA0F62AAAE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float3x4.hpp.AD8032CA0F62AAAE.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x2.hpp.1D23AF3A83BCBD42.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float4x2.hpp.1D23AF3A83BCBD42.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x3.hpp.0B71BACB3974003F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float4x3.hpp.0B71BACB3974003F.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x4.hpp.1A8745935C545560.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float4x4.hpp.1A8745935C545560.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_transform.hpp.95DE60511EE4A264.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_transform.hpp.95DE60511EE4A264.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_transform.hpp.9D21F9FF67195386.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_transform.hpp.9D21F9FF67195386.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_transform.inl.29E72BAF0D0922F1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_transform.inl.29E72BAF0D0922F1.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_transform.inl.BD01D6A6989D494A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_transform.inl.BD01D6A6989D494A.idx -------------------------------------------------------------------------------- /.clangd/index/meshdemowindow.cpp.D40630DA6F7919B1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/meshdemowindow.cpp.D40630DA6F7919B1.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_float.hpp.03C13B307AD86805.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_float.hpp.03C13B307AD86805.idx -------------------------------------------------------------------------------- /.clangd/index/scalar_constants.hpp.16207C9D95B9D6AE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/scalar_constants.hpp.16207C9D95B9D6AE.idx -------------------------------------------------------------------------------- /.clangd/index/scalar_constants.inl.8B05B0C8D46D18E7.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/scalar_constants.inl.8B05B0C8D46D18E7.idx -------------------------------------------------------------------------------- /.clangd/index/scalar_int_sized.hpp.7E5BFB582A04F742.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/scalar_int_sized.hpp.7E5BFB582A04F742.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double1.hpp.C9EC402D005B4ADA.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_double1.hpp.C9EC402D005B4ADA.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double2.hpp.443A45A306AC6FCC.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_double2.hpp.443A45A306AC6FCC.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double3.hpp.2395D41672AD9BE1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_double3.hpp.2395D41672AD9BE1.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double4.hpp.9BD504A4A7024CFC.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_double4.hpp.9BD504A4A7024CFC.idx -------------------------------------------------------------------------------- /.clangd/index/func_trigonometric.inl.E76712308DA6BB87.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/func_trigonometric.inl.E76712308DA6BB87.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_clip_space.hpp.1EFBD092467D7A4A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_clip_space.hpp.1EFBD092467D7A4A.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_clip_space.inl.7EE937A2EE3B1196.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_clip_space.inl.7EE937A2EE3B1196.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_projection.hpp.B684807CC073819B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_projection.hpp.B684807CC073819B.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_projection.inl.7BB76A178EDE650E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_projection.inl.7BB76A178EDE650E.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_common.hpp.EF0283C5186A7D36.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_common.hpp.EF0283C5186A7D36.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_common.inl.6EA43AC617A6F0F4.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_common.inl.6EA43AC617A6F0F4.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_double.hpp.A4F16600CE865440.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_double.hpp.A4F16600CE865440.idx -------------------------------------------------------------------------------- /.clangd/index/scalar_uint_sized.hpp.B6062179A75035C6.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/scalar_uint_sized.hpp.B6062179A75035C6.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int1_sized.hpp.DE2CB3AED1DBF6A0.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_int1_sized.hpp.DE2CB3AED1DBF6A0.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int2_sized.hpp.33F2E5C35D7D0536.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_int2_sized.hpp.33F2E5C35D7D0536.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int3_sized.hpp.52978F0AEE2D2DA1.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_int3_sized.hpp.52978F0AEE2D2DA1.idx -------------------------------------------------------------------------------- /.clangd/index/vector_int4_sized.hpp.B013BE46DC3F7BD2.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_int4_sized.hpp.B013BE46DC3F7BD2.idx -------------------------------------------------------------------------------- /.clangd/index/vector_relational.hpp.43BF150B795C6208.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_relational.hpp.43BF150B795C6208.idx -------------------------------------------------------------------------------- /.clangd/index/vector_relational.hpp.C48BAA9563F5B5DA.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_relational.hpp.C48BAA9563F5B5DA.idx -------------------------------------------------------------------------------- /.clangd/index/vector_relational.inl.06185C60D2D3904F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_relational.inl.06185C60D2D3904F.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint1_sized.hpp.AD454395657F88C2.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_uint1_sized.hpp.AD454395657F88C2.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint2_sized.hpp.30D48D7C27EC9BD4.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_uint2_sized.hpp.30D48D7C27EC9BD4.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint3_sized.hpp.412E219FE685A210.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_uint3_sized.hpp.412E219FE685A210.idx -------------------------------------------------------------------------------- /.clangd/index/vector_uint4_sized.hpp.7392C030183A179A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_uint4_sized.hpp.7392C030183A179A.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_geometric.hpp.97017743A13BB63C.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_geometric.hpp.97017743A13BB63C.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_geometric.inl.B3CE6FDB5873EE29.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_geometric.inl.B3CE6FDB5873EE29.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_relational.hpp.52FB3DD0D09D9C30.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_relational.hpp.52FB3DD0D09D9C30.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_relational.inl.84D9042EF3FD68BA.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_relational.inl.84D9042EF3FD68BA.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_transform.hpp.F0F1174449E94318.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_transform.hpp.F0F1174449E94318.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_transform.inl.03BE1B9A5C2C2ED2.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_transform.inl.03BE1B9A5C2C2ED2.idx -------------------------------------------------------------------------------- /.clangd/index/func_vector_relational.inl.6773506C59136C1A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/func_vector_relational.inl.6773506C59136C1A.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool1_precision.hpp.966FC4A27F2A3A39.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_bool1_precision.hpp.966FC4A27F2A3A39.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool2_precision.hpp.823EAC2B68A97864.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_bool2_precision.hpp.823EAC2B68A97864.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool3_precision.hpp.9E38B0ADC710000F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_bool3_precision.hpp.9E38B0ADC710000F.idx -------------------------------------------------------------------------------- /.clangd/index/vector_bool4_precision.hpp.FED386778F2F62DA.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_bool4_precision.hpp.FED386778F2F62DA.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float1_precision.hpp.5F47F9F44D1316BE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_float1_precision.hpp.5F47F9F44D1316BE.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float2_precision.hpp.A7F6A362DF2C2336.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_float2_precision.hpp.A7F6A362DF2C2336.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float3_precision.hpp.756950A41B50841F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_float3_precision.hpp.756950A41B50841F.idx -------------------------------------------------------------------------------- /.clangd/index/vector_float4_precision.hpp.95C3D081229AA691.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_float4_precision.hpp.95C3D081229AA691.idx -------------------------------------------------------------------------------- /bin/media/demos/glsl/basic_color_light.frag: -------------------------------------------------------------------------------- 1 | #version 410 2 | 3 | out vec4 FragColor; 4 | 5 | uniform vec3 lightColor; 6 | 7 | void main() { FragColor = vec4(lightColor, 1.0); } 8 | -------------------------------------------------------------------------------- /.clangd/index/compute_vector_relational.hpp.0197E84F49BFF1D6.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/compute_vector_relational.hpp.0197E84F49BFF1D6.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x2_precision.hpp.2C5901B30DEA3BE4.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double2x2_precision.hpp.2C5901B30DEA3BE4.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x3_precision.hpp.9A4F47B3ED38AA3A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double2x3_precision.hpp.9A4F47B3ED38AA3A.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double2x4_precision.hpp.55F02CF2A7B88576.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double2x4_precision.hpp.55F02CF2A7B88576.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x2_precision.hpp.81D84195C0D2AAC6.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double3x2_precision.hpp.81D84195C0D2AAC6.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x3_precision.hpp.866369420067C56E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double3x3_precision.hpp.866369420067C56E.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double3x4_precision.hpp.CE74AE24DDAAE720.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double3x4_precision.hpp.CE74AE24DDAAE720.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x2_precision.hpp.B189A2896C57EFB4.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double4x2_precision.hpp.B189A2896C57EFB4.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x3_precision.hpp.9FBB03C6C4C850DD.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double4x3_precision.hpp.9FBB03C6C4C850DD.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_double4x4_precision.hpp.A9255374ACD1260E.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_double4x4_precision.hpp.A9255374ACD1260E.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x2_precision.hpp.D816A3534EA34054.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float2x2_precision.hpp.D816A3534EA34054.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x3_precision.hpp.8D00F6C21388D914.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float2x3_precision.hpp.8D00F6C21388D914.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float2x4_precision.hpp.CE557C2E220889AE.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float2x4_precision.hpp.CE557C2E220889AE.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x2_precision.hpp.680C68222C5097DD.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float3x2_precision.hpp.680C68222C5097DD.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x3_precision.hpp.597903EED690D041.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float3x3_precision.hpp.597903EED690D041.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float3x4_precision.hpp.97E91F1B195E8EF0.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float3x4_precision.hpp.97E91F1B195E8EF0.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x2_precision.hpp.CF7BDFBE7409F00B.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float4x2_precision.hpp.CF7BDFBE7409F00B.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x3_precision.hpp.CDD1A9156939B140.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float4x3_precision.hpp.CDD1A9156939B140.idx -------------------------------------------------------------------------------- /.clangd/index/matrix_float4x4_precision.hpp.4E9F744443591C72.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/matrix_float4x4_precision.hpp.4E9F744443591C72.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_float_precision.hpp.B0C7C54C0512381D.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_float_precision.hpp.B0C7C54C0512381D.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_trigonometric.hpp.B08BD41C1A6C6E5F.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_trigonometric.hpp.B08BD41C1A6C6E5F.idx -------------------------------------------------------------------------------- /.clangd/index/quaternion_trigonometric.inl.E70B111F1A6105BF.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_trigonometric.inl.E70B111F1A6105BF.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double1_precision.hpp.6E201D8253BBBA44.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_double1_precision.hpp.6E201D8253BBBA44.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double2_precision.hpp.4C95EBB7534C9A45.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_double2_precision.hpp.4C95EBB7534C9A45.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double3_precision.hpp.1A6E6F330EB0BF55.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_double3_precision.hpp.1A6E6F330EB0BF55.idx -------------------------------------------------------------------------------- /.clangd/index/vector_double4_precision.hpp.3A3A632ED095A349.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/vector_double4_precision.hpp.3A3A632ED095A349.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/quaternion_double_precision.hpp.BF399AFB0A26526A.idx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/physics-engine/master/.clangd/index/quaternion_double_precision.hpp.BF399AFB0A26526A.idx -------------------------------------------------------------------------------- /src/main.cpp: -------------------------------------------------------------------------------- 1 | // main file 2 | #include 3 | #include 4 | 5 | int main() { 6 | std::cout << "Hello Engine" << std::endl; 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /bin/media/demos/glsl/line.vert: -------------------------------------------------------------------------------- 1 | #version 410 2 | layout(location = 0) in vec3 aPos; 3 | uniform mat4 view; 4 | uniform mat4 model; 5 | uniform mat4 projection; 6 | 7 | void main() { gl_Position = projection * view * model * vec4(aPos, 1.0); } 8 | -------------------------------------------------------------------------------- /include/vivaphysics/plinkenum.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace vivaphysics { 4 | // 5 | enum class ParticleContactGeneratorType { 6 | CABLE = 0, 7 | ROD = 1, 8 | CABLE_CONSTRAINT = 2, 9 | ROD_CONSTRAINT = 3, 10 | GROUND = 4, 11 | }; 12 | }; 13 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /src/demos/platform.cpp: -------------------------------------------------------------------------------- 1 | // platform demo 2 | #include 3 | using namespace vivademos; 4 | 5 | int main() { 6 | auto demo = PlatformDemo(800, 600, "platform demo"); 7 | demo.init_graphics(); 8 | demo.display(); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /bin/media/demos/glsl/basic_point_light.vert: -------------------------------------------------------------------------------- 1 | #version 410 2 | 3 | layout(location = 0) in vec3 aPos; 4 | 5 | uniform mat4 view; 6 | uniform mat4 model; 7 | uniform mat4 projection; 8 | 9 | void main() { gl_Position = projection * view * model * vec4(aPos, 1.0); } 10 | -------------------------------------------------------------------------------- /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/vivaphysics/precision.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace vivaphysics { 3 | typedef float real; 4 | // typedef double real; 5 | // #define REAL_MAX std::numeric_limits::max 6 | #define REAL_MAX FLT_MAX; 7 | 8 | #define REAL_MIN FLT_MIN; 9 | }; 10 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /src/demos/meshdemowindow.cpp: -------------------------------------------------------------------------------- 1 | // mesh demo application 2 | #include 3 | using namespace vivademos; 4 | 5 | int main() { 6 | auto demo = 7 | MeshDemoApp(800, 600, "Basic Mesh Demo App Test"); 8 | demo.init_graphics(); 9 | demo.display(); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /src/demos/demowindow.cpp: -------------------------------------------------------------------------------- 1 | // demo application window 2 | #include 3 | #include 4 | // #include 5 | using namespace vivademos; 6 | 7 | int main() { 8 | auto demo = DemoApp(800, 600, "Basic Demo App Test"); 9 | demo.init_graphics(); 10 | demo.display(); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /src/demos/ballisticdemo.cpp: -------------------------------------------------------------------------------- 1 | // ballistic objects demo 2 | #include 3 | // #include 4 | using namespace vivademos; 5 | 6 | int main() { 7 | auto demo = BallisticMeshDemo( 8 | 800, 600, "Ballistic Mesh Demo App Test"); 9 | demo.init_graphics(); 10 | demo.display(); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /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/vivaphysics/pfgenenum.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | using namespace vivaphysics; 6 | 7 | namespace vivaphysics { 8 | 9 | enum class ParticleForceGeneratorType { 10 | GRAVITY = 0, 11 | DRAG = 1, 12 | ANCHORED_SPRING = 2, 13 | ANCHORED_BUNGEE = 3, 14 | FAKE_SPRING = 4, 15 | SPRING = 5, 16 | BUNGEE = 6, 17 | BUOYANCY = 7 18 | }; 19 | }; 20 | -------------------------------------------------------------------------------- /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/media/demos/glsl/shadow_depth.vert: -------------------------------------------------------------------------------- 1 | #version 330 2 | /** 3 | * from learnopengl.com 4 | * https://learnopengl.com/code_viewer_gh.php?code=src/5.advanced_lighting/3.1.3.shadow_mapping/3.1.3.shadow_mapping_depth.vs 5 | * */ 6 | layout(location = 0) in vec3 aPos; 7 | 8 | uniform mat4 lightSpaceMatrix; 9 | uniform mat4 model; 10 | 11 | void main() { gl_Position = lightSpaceMatrix * model * vec4(aPos, 1.0); } 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_sized.hpp" 13 | #include "./ext/vector_uint2.hpp" 14 | #include "./ext/vector_uint2_sized.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_sized.hpp" 13 | #include "./ext/vector_uint3.hpp" 14 | #include "./ext/vector_uint3_sized.hpp" 15 | -------------------------------------------------------------------------------- /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_sized.hpp" 13 | #include "./ext/vector_uint4.hpp" 14 | #include "./ext/vector_uint4_sized.hpp" 15 | 16 | -------------------------------------------------------------------------------- /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/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/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 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | *.smod 22 | 23 | # Compiled Static libraries 24 | *.lai 25 | *.la 26 | *.a 27 | *.lib 28 | 29 | # Executables 30 | *.exe 31 | *.out 32 | *.app 33 | 34 | 35 | CMakeLists.txt.user 36 | CMakeCache.txt 37 | CMakeFiles 38 | CMakeScripts 39 | Testing 40 | Makefile 41 | cmake_install.cmake 42 | install_manifest.txt 43 | compile_commands.json 44 | CTestTestfile.cmake 45 | _deps 46 | 47 | -------------------------------------------------------------------------------- /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/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/gtc/reciprocal.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_reciprocal 2 | /// @file glm/gtc/reciprocal.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_reciprocal GLM_GTC_reciprocal 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Define secant, cosecant and cotangent functions. 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_GTC_reciprocal extension included") 20 | #endif 21 | 22 | #include "../ext/scalar_reciprocal.hpp" 23 | #include "../ext/vector_reciprocal.hpp" 24 | 25 | -------------------------------------------------------------------------------- /include/external.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | // thirdparty modules 21 | // gl pointer 22 | #include 23 | // window manager 24 | #include 25 | // glm 26 | #include 27 | #include 28 | #include 29 | 30 | // glut 31 | // #include 32 | -------------------------------------------------------------------------------- /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/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/scalar_constants.inl: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() 7 | { 8 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'epsilon' only accepts floating-point inputs"); 9 | return std::numeric_limits::epsilon(); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() 14 | { 15 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'pi' only accepts floating-point inputs"); 16 | return static_cast(3.14159265358979323846264338327950288); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType cos_one_over_two() 21 | { 22 | return genType(0.877582561890372716130286068203503191); 23 | } 24 | } //namespace glm 25 | -------------------------------------------------------------------------------- /include/glm/ext/vector_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_packing 2 | /// @file glm/ext/vector_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_vector_packing GLM_EXT_vector_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert vectors to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "vector_packing.inl" 33 | -------------------------------------------------------------------------------- /include/glm/ext/scalar_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_packing 2 | /// @file glm/ext/scalar_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_scalar_packing GLM_EXT_scalar_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert scalar values to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_scalar_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_scalar_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "scalar_packing.inl" 33 | -------------------------------------------------------------------------------- /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/matrix_int2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x3 2 | /// @file glm/ext/matrix_int2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_int2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x3 25 | /// @{ 26 | 27 | /// Signed integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_int2x3 30 | typedef mat<2, 3, int, defaultp> imat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x4 2 | /// @file glm/ext/matrix_int2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x4 25 | /// @{ 26 | 27 | /// Signed integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_int2x4 30 | typedef mat<2, 4, int, defaultp> imat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x2 2 | /// @file glm/ext/matrix_int3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_int3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x2 25 | /// @{ 26 | 27 | /// Signed integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_int3x2 30 | typedef mat<3, 2, int, defaultp> imat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x4 2 | /// @file glm/ext/matrix_int3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x4 GLM_EXT_matrix_int3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_int3x4 30 | typedef mat<3, 4, int, defaultp> imat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x2 2 | /// @file glm/ext/matrix_int4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x2 GLM_EXT_matrix_int4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x2 25 | /// @{ 26 | 27 | /// Signed integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_int4x2 30 | typedef mat<4, 2, int, defaultp> imat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x3 2 | /// @file glm/ext/matrix_int4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x3 GLM_EXT_matrix_int4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x3 25 | /// @{ 26 | 27 | /// Signed integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_int4x3 30 | typedef mat<4, 3, int, defaultp> imat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x4 2 | /// @file glm/ext/matrix_uint3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x4 GLM_EXT_matrix_uint3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x4 30 | typedef mat<3, 4, uint, defaultp> umat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x3 2 | /// @file glm/ext/matrix_uint2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_uint2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x3 25 | /// @{ 26 | 27 | /// Unsigned integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x3 30 | typedef mat<2, 3, uint, defaultp> umat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x4 2 | /// @file glm/ext/matrix_uint2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x4 25 | /// @{ 26 | 27 | /// Unsigned integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x4 30 | typedef mat<2, 4, uint, defaultp> umat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x2 2 | /// @file glm/ext/matrix_uint3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_uint3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x2 25 | /// @{ 26 | 27 | /// Unsigned integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x2 30 | typedef mat<3, 2, uint, defaultp> umat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x2 2 | /// @file glm/ext/matrix_uint4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x2 GLM_EXT_matrix_uint4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x2 25 | /// @{ 26 | 27 | /// Unsigned integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x2 30 | typedef mat<4, 2, uint, defaultp> umat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x3 2 | /// @file glm/ext/matrix_uint4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x3 GLM_EXT_matrix_uint4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x3 25 | /// @{ 26 | 27 | /// Unsigned integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x3 30 | typedef mat<4, 3, uint, defaultp> umat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /bin/err.txt: -------------------------------------------------------------------------------- 1 | Print Keys: 2 | SPACE + V 3 | ------------------------- 4 | Toggle Movement: 5 | ------------------------- 6 | key pad 7 camera 7 | key pad 8 light 8 | key pad 9 object 9 | ------------------------- 10 | Move Rotate Camera Keys: 11 | ------------------------- 12 | W/Z move forward 13 | A/Q move left 14 | S move backward 15 | D move right 16 | H rotate left 17 | J rotate right 18 | K rotate downward 19 | L rotate upward 20 | ------------------------- 21 | Move Light Keys: 22 | ------------------------- 23 | key pad 1 move upward 24 | key pad 2 move downward 25 | key pad 3 move right 26 | key pad 4 move left 27 | key pad 5 move forward 28 | key pad 6 move backward 29 | ------------------------- 30 | Move Object Keys: 31 | ------------------------- 32 | E move left 33 | R move right 34 | T move up 35 | Y move down 36 | I move forward 37 | O move backward 38 | ------------------------- 39 | -------------------------------------------------------------------------------- /bin/media/demos/glsl/meshcolor.vert: -------------------------------------------------------------------------------- 1 | #version 410 2 | layout(location = 0) in vec3 aPos; 3 | layout(location = 1) in vec3 aNormal; 4 | layout(location = 2) in vec2 aTexCoord; 5 | layout(location = 3) in vec3 aTan; 6 | layout(location = 4) in vec3 aBiTan; 7 | 8 | uniform mat4 view; 9 | uniform mat4 model; 10 | uniform mat4 projection; 11 | uniform mat4 lightSpaceMatrix; 12 | 13 | out vec3 FragPos; 14 | out vec4 FragPosLightSpace; 15 | out vec2 TexCoord; 16 | out vec3 Normal; 17 | 18 | void main() { 19 | FragPos = vec3(model * vec4(aPos, 1.0)); 20 | TexCoord = aTexCoord; 21 | Normal = vec3(model * vec4(aNormal, 1.0)); 22 | /*TBN = mat3(vec3(model * vec4(aTan, 0.0)), vec3(model * vec4(aBiTan, 0.0)), 23 | vec3(model * vec4(aNormal, 0.0)));*/ 24 | FragPosLightSpace = lightSpaceMatrix * vec4(FragPos, 1.0); 25 | gl_Position = projection * view * model * vec4(aPos, 1.0); 26 | } 27 | -------------------------------------------------------------------------------- /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_double1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_double1 25 | /// @{ 26 | 27 | /// 1 components vector of double-precision floating-point numbers. 28 | typedef vec<1, double, defaultp> dvec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /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_sized.hpp" 24 | #include "../ext/vector_uint1.hpp" 25 | #include "../ext/vector_uint1_sized.hpp" 26 | 27 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTC_vec1 extension included") 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x2 2 | /// @file glm/ext/matrix_int2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x2 GLM_EXT_matrix_int2x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x2 25 | /// @{ 26 | 27 | /// Signed integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_int2x2 30 | typedef mat<2, 2, int, defaultp> imat2x2; 31 | 32 | /// Signed integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_int2x2 35 | typedef mat<2, 2, int, defaultp> imat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x3 2 | /// @file glm/ext/matrix_int3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x3 GLM_EXT_matrix_int3x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x3 25 | /// @{ 26 | 27 | /// Signed integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_int3x3 30 | typedef mat<3, 3, int, defaultp> imat3x3; 31 | 32 | /// Signed integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_int3x3 35 | typedef mat<3, 3, int, defaultp> imat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x4 2 | /// @file glm/ext/matrix_int4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x4 GLM_EXT_matrix_int4x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x4 25 | /// @{ 26 | 27 | /// Signed integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_int4x4 30 | typedef mat<4, 4, int, defaultp> imat4x4; 31 | 32 | /// Signed integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_int4x4 35 | typedef mat<4, 4, int, defaultp> imat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /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/matrix_uint2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x2 2 | /// @file glm/ext/matrix_uint2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x2 GLM_EXT_matrix_uint2x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x2 25 | /// @{ 26 | 27 | /// Unsigned integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x2 30 | typedef mat<2, 2, uint, defaultp> umat2x2; 31 | 32 | /// Unsigned integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_uint2x2 35 | typedef mat<2, 2, uint, defaultp> umat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x3 2 | /// @file glm/ext/matrix_uint3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x3 GLM_EXT_matrix_uint3x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x3 25 | /// @{ 26 | 27 | /// Unsigned integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x3 30 | typedef mat<3, 3, uint, defaultp> umat3x3; 31 | 32 | /// Unsigned integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_uint3x3 35 | typedef mat<3, 3, uint, defaultp> umat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x4 2 | /// @file glm/ext/matrix_uint4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x4 GLM_EXT_matrix_uint4x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x4 25 | /// @{ 26 | 27 | /// Unsigned integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x4 30 | typedef mat<4, 4, uint, defaultp> umat4x4; 31 | 32 | /// Unsigned integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_uint4x4 35 | typedef mat<4, 4, uint, defaultp> umat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /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 "../ext/scalar_common.hpp" 18 | #include "../ext/vector_common.hpp" 19 | #include "../gtc/vec1.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # ifndef GLM_ENABLE_EXPERIMENTAL 23 | # pragma message("GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 24 | # else 25 | # pragma message("GLM: GLM_GTX_wrap extension included") 26 | # endif 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_wrap 32 | /// @{ 33 | 34 | /// @} 35 | }// namespace glm 36 | 37 | #include "wrap.inl" 38 | -------------------------------------------------------------------------------- /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/gtx/scalar_relational.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | /// @file glm/gtx/scalar_relational.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Extend a position from a source to a position at a defined length. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # else 22 | # pragma message("GLM: GLM_GTX_extend extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_scalar_relational 29 | /// @{ 30 | 31 | 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "scalar_relational.inl" 37 | -------------------------------------------------------------------------------- /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/demos/apputils.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // utilty functions for demo application 3 | #include 4 | 5 | namespace vivademos { 6 | 7 | void framebuffer_size_callback(GLFWwindow *window, 8 | int newWidth, 9 | int newHeight) { 10 | glViewport(0, 0, newWidth, newHeight); 11 | } 12 | void glfwErrorCallBack(int id, const char *desc) { 13 | std::cout << desc << std::endl; 14 | } 15 | void initializeGLFWMajorMinor(unsigned int maj, 16 | unsigned int min) { 17 | // initialize glfw version with correct profiling etc 18 | glfwSetErrorCallback(glfwErrorCallBack); 19 | if (glfwInit() == 0) { 20 | std::cout << "glfw not initialized correctly" 21 | << std::endl; 22 | } 23 | glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, maj); 24 | glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, min); 25 | glfwWindowHint(GLFW_OPENGL_PROFILE, 26 | GLFW_OPENGL_CORE_PROFILE); 27 | } 28 | 29 | template T clamp(T nb, T mn, T mx) { 30 | if (nb < mn) 31 | nb = mn; 32 | if (nb > mx) 33 | nb = mx; 34 | return nb; 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /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_trigonometric.inl: -------------------------------------------------------------------------------- 1 | #include "scalar_constants.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T angle(qua const& x) 7 | { 8 | if (abs(x.w) > cos_one_over_two()) 9 | { 10 | T const a = asin(sqrt(x.x * x.x + x.y * x.y + x.z * x.z)) * static_cast(2); 11 | if(x.w < static_cast(0)) 12 | return pi() * static_cast(2) - a; 13 | return a; 14 | } 15 | 16 | return acos(x.w) * static_cast(2); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER vec<3, T, Q> axis(qua const& x) 21 | { 22 | T const tmp1 = static_cast(1) - x.w * x.w; 23 | if(tmp1 <= static_cast(0)) 24 | return vec<3, T, Q>(0, 0, 1); 25 | T const tmp2 = static_cast(1) / sqrt(tmp1); 26 | return vec<3, T, Q>(x.x * tmp2, x.y * tmp2, x.z * tmp2); 27 | } 28 | 29 | template 30 | GLM_FUNC_QUALIFIER qua angleAxis(T const& angle, vec<3, T, Q> const& v) 31 | { 32 | T const a(angle); 33 | T const s = glm::sin(a * static_cast(0.5)); 34 | 35 | return qua(glm::cos(a * static_cast(0.5)), v * s); 36 | } 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /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/gtc/integer.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_integer 2 | 3 | namespace glm{ 4 | namespace detail 5 | { 6 | template 7 | struct compute_log2 8 | { 9 | GLM_FUNC_QUALIFIER static vec call(vec const& v) 10 | { 11 | //Equivalent to return findMSB(vec); but save one function call in ASM with VC 12 | //return findMSB(vec); 13 | return vec(detail::compute_findMSB_vec::call(v)); 14 | } 15 | }; 16 | 17 | # if GLM_HAS_BITSCAN_WINDOWS 18 | template 19 | struct compute_log2<4, int, Q, false, Aligned> 20 | { 21 | GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v) 22 | { 23 | vec<4, int, Q> Result; 24 | _BitScanReverse(reinterpret_cast(&Result.x), v.x); 25 | _BitScanReverse(reinterpret_cast(&Result.y), v.y); 26 | _BitScanReverse(reinterpret_cast(&Result.z), v.z); 27 | _BitScanReverse(reinterpret_cast(&Result.w), v.w); 28 | return Result; 29 | } 30 | }; 31 | # endif//GLM_HAS_BITSCAN_WINDOWS 32 | }//namespace detail 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/gtc/integer.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_integer 2 | /// @file glm/gtc/integer.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_integer (dependence) 6 | /// 7 | /// @defgroup gtc_integer GLM_GTC_integer 8 | /// @ingroup gtc 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// @brief Allow to perform bit operations on integer values 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | #include "../common.hpp" 20 | #include "../integer.hpp" 21 | #include "../exponential.hpp" 22 | #include "../ext/scalar_common.hpp" 23 | #include "../ext/vector_common.hpp" 24 | #include 25 | 26 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 27 | # pragma message("GLM: GLM_GTC_integer extension included") 28 | #endif 29 | 30 | namespace glm 31 | { 32 | /// @addtogroup gtc_integer 33 | /// @{ 34 | 35 | /// Returns the log2 of x for integer values. Usefull to compute mipmap count from the texture size. 36 | /// @see gtc_integer 37 | template 38 | GLM_FUNC_DECL genIUType log2(genIUType x); 39 | 40 | /// @} 41 | } //namespace glm 42 | 43 | #include "integer.inl" 44 | -------------------------------------------------------------------------------- /include/demos/texture.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // texture related 3 | #include 4 | namespace vivademos { 5 | enum class TextureType { 6 | Specular, 7 | Normal, 8 | Diffuse, 9 | Height, 10 | Displacement, 11 | Roughness, 12 | Metallic, 13 | Ao, 14 | Albedo 15 | }; 16 | 17 | inline std::ostream &operator<<(std::ostream &out, 18 | const TextureType &t) { 19 | switch (t) { 20 | case TextureType::Diffuse: 21 | return out << "type diffuse"; 22 | case TextureType::Specular: 23 | return out << "type specular"; 24 | case TextureType::Normal: 25 | return out << "type normal"; 26 | case TextureType::Height: 27 | return out << "type height"; 28 | case TextureType::Displacement: 29 | return out << "type displacement"; 30 | case TextureType::Ao: 31 | return out << "type ambient occlusion"; 32 | case TextureType::Roughness: 33 | return out << "type roughness"; 34 | case TextureType::Albedo: 35 | return out << "type albedo"; 36 | case TextureType::Metallic: 37 | return out << "type metallic"; 38 | } 39 | } 40 | 41 | struct Texture { 42 | GLuint id; 43 | TextureType type; 44 | std::string name; 45 | std::string path; 46 | }; 47 | }; 48 | -------------------------------------------------------------------------------- /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 | /// Return the value of cos(1 / 2) for floating point types. 34 | template 35 | GLM_FUNC_DECL GLM_CONSTEXPR genType cos_one_over_two(); 36 | 37 | /// @} 38 | } //namespace glm 39 | 40 | #include "scalar_constants.inl" 41 | -------------------------------------------------------------------------------- /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 | # else 23 | # pragma message("GLM: GLM_GTX_normal extension included") 24 | # endif 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normal 30 | /// @{ 31 | 32 | /// Computes triangle normal from triangle points. 33 | /// 34 | /// @see gtx_normal 35 | template 36 | GLM_FUNC_DECL vec<3, T, Q> triangleNormal(vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "normal.inl" 42 | -------------------------------------------------------------------------------- /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 | # else 22 | # pragma message("GLM: GLM_GTX_mixed_product extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_mixed_product 29 | /// @{ 30 | 31 | /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) 32 | template 33 | GLM_FUNC_DECL T mixedProduct( 34 | vec<3, T, Q> const& v1, 35 | vec<3, T, Q> const& v2, 36 | vec<3, T, Q> const& v3); 37 | 38 | /// @} 39 | }// namespace glm 40 | 41 | #include "mixed_product.inl" 42 | -------------------------------------------------------------------------------- /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 | # else 22 | # pragma message("GLM: GLM_GTX_extend extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_extend 29 | /// @{ 30 | 31 | /// Extends of Length the Origin position using the (Source - Origin) direction. 32 | /// @see gtx_extend 33 | template 34 | GLM_FUNC_DECL genType extend( 35 | genType const& Origin, 36 | genType const& Source, 37 | typename genType::value_type const Length); 38 | 39 | /// @} 40 | }//namespace glm 41 | 42 | #include "extend.inl" 43 | -------------------------------------------------------------------------------- /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 | # else 22 | # pragma message("GLM: GLM_GTX_projection extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_projection 29 | /// @{ 30 | 31 | /// Projects x on Normal. 32 | /// 33 | /// @param[in] x A vector to project 34 | /// @param[in] Normal A normal that doesn't need to be of unit length. 35 | /// 36 | /// @see gtx_projection 37 | template 38 | GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); 39 | 40 | /// @} 41 | }//namespace glm 42 | 43 | #include "projection.inl" 44 | -------------------------------------------------------------------------------- /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 | # else 24 | # pragma message("GLM: GLM_GTX_perpendicular extension included") 25 | # endif 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_perpendicular 31 | /// @{ 32 | 33 | //! Projects x a perpendicular axis of Normal. 34 | //! From GLM_GTX_perpendicular extension. 35 | template 36 | GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "perpendicular.inl" 42 | -------------------------------------------------------------------------------- /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 | return false; 29 | 30 | // Find the difference in ULPs. 31 | typename detail::float_t::int_type const DiffULPs = abs(a.i - b.i); 32 | return DiffULPs <= MaxULPs; 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, int ULPs) 37 | { 38 | return !equal(x, y, ULPs); 39 | } 40 | }//namespace glm 41 | -------------------------------------------------------------------------------- /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/demos/meshutils.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // utility functions for mesh 3 | #include 4 | 5 | namespace vivademos { 6 | 7 | glm::vec3 getTangent(glm::vec2 deltaUV2, glm::vec2 deltaUV1, 8 | glm::vec3 edge1, glm::vec3 edge2) { 9 | // Compute tangent 10 | GLfloat f = 1.0f / (deltaUV1.x * deltaUV2.y - 11 | deltaUV2.x * deltaUV1.y); 12 | glm::vec3 tangent; 13 | tangent.x = 14 | f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x); 15 | tangent.y = 16 | f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y); 17 | tangent.z = 18 | f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z); 19 | tangent = glm::normalize(tangent); 20 | return tangent; 21 | } 22 | glm::vec3 getBiTangent(glm::vec2 deltaUV2, 23 | glm::vec2 deltaUV1, glm::vec3 edge1, 24 | glm::vec3 edge2) { 25 | GLfloat f = 1.0f / (deltaUV1.x * deltaUV2.y - 26 | deltaUV2.x * deltaUV1.y); 27 | glm::vec3 bitangent; 28 | bitangent.x = 29 | f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x); 30 | bitangent.y = 31 | f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y); 32 | bitangent.z = 33 | f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z); 34 | bitangent = glm::normalize(bitangent); 35 | return bitangent; 36 | } 37 | 38 | }; 39 | -------------------------------------------------------------------------------- /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 | # else 22 | # pragma message("GLM: GLM_GTX_log_base extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_log_base 29 | /// @{ 30 | 31 | /// Logarithm for any base. 32 | /// From GLM_GTX_log_base. 33 | template 34 | GLM_FUNC_DECL genType log( 35 | genType const& x, 36 | genType const& base); 37 | 38 | /// Logarithm for any base. 39 | /// From GLM_GTX_log_base. 40 | template 41 | GLM_FUNC_DECL vec sign( 42 | vec const& x, 43 | vec const& base); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "log_base.inl" 49 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int2x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x3_sized 2 | /// @file glm/ext/matrix_int2x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3_sized GLM_EXT_matrix_int2x3_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int2x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int2x3_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 2x3 matrix. 29 | /// 30 | /// @see ext_matrix_int2x3_sized 31 | typedef mat<2, 3, int8, defaultp> i8mat2x3; 32 | 33 | /// 16 bit signed integer 2x3 matrix. 34 | /// 35 | /// @see ext_matrix_int2x3_sized 36 | typedef mat<2, 3, int16, defaultp> i16mat2x3; 37 | 38 | /// 32 bit signed integer 2x3 matrix. 39 | /// 40 | /// @see ext_matrix_int2x3_sized 41 | typedef mat<2, 3, int32, defaultp> i32mat2x3; 42 | 43 | /// 64 bit signed integer 2x3 matrix. 44 | /// 45 | /// @see ext_matrix_int2x3_sized 46 | typedef mat<2, 3, int64, defaultp> i64mat2x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int2x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x4_sized 2 | /// @file glm/ext/matrix_int2x4_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x4_sized GLM_EXT_matrix_int2x4_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int2x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int2x4_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 2x4 matrix. 29 | /// 30 | /// @see ext_matrix_int2x4_sized 31 | typedef mat<2, 4, int8, defaultp> i8mat2x4; 32 | 33 | /// 16 bit signed integer 2x4 matrix. 34 | /// 35 | /// @see ext_matrix_int2x4_sized 36 | typedef mat<2, 4, int16, defaultp> i16mat2x4; 37 | 38 | /// 32 bit signed integer 2x4 matrix. 39 | /// 40 | /// @see ext_matrix_int2x4_sized 41 | typedef mat<2, 4, int32, defaultp> i32mat2x4; 42 | 43 | /// 64 bit signed integer 2x4 matrix. 44 | /// 45 | /// @see ext_matrix_int2x4_sized 46 | typedef mat<2, 4, int64, defaultp> i64mat2x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int3x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x2_sized 2 | /// @file glm/ext/matrix_int3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2_sized GLM_EXT_matrix_int3x2_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int3x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int3x2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 3x2 matrix. 29 | /// 30 | /// @see ext_matrix_int3x2_sized 31 | typedef mat<3, 2, int8, defaultp> i8mat3x2; 32 | 33 | /// 16 bit signed integer 3x2 matrix. 34 | /// 35 | /// @see ext_matrix_int3x2_sized 36 | typedef mat<3, 2, int16, defaultp> i16mat3x2; 37 | 38 | /// 32 bit signed integer 3x2 matrix. 39 | /// 40 | /// @see ext_matrix_int3x2_sized 41 | typedef mat<3, 2, int32, defaultp> i32mat3x2; 42 | 43 | /// 64 bit signed integer 3x2 matrix. 44 | /// 45 | /// @see ext_matrix_int3x2_sized 46 | typedef mat<3, 2, int64, defaultp> i64mat3x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int3x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x4_sized 2 | /// @file glm/ext/matrix_int3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x4_sized GLM_EXT_matrix_int3x4_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int3x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int3x4_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 3x4 matrix. 29 | /// 30 | /// @see ext_matrix_int3x4_sized 31 | typedef mat<3, 4, int8, defaultp> i8mat3x4; 32 | 33 | /// 16 bit signed integer 3x4 matrix. 34 | /// 35 | /// @see ext_matrix_int3x4_sized 36 | typedef mat<3, 4, int16, defaultp> i16mat3x4; 37 | 38 | /// 32 bit signed integer 3x4 matrix. 39 | /// 40 | /// @see ext_matrix_int3x4_sized 41 | typedef mat<3, 4, int32, defaultp> i32mat3x4; 42 | 43 | /// 64 bit signed integer 3x4 matrix. 44 | /// 45 | /// @see ext_matrix_int3x4_sized 46 | typedef mat<3, 4, int64, defaultp> i64mat3x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int4x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x2_sized 2 | /// @file glm/ext/matrix_int4x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x2_sized GLM_EXT_matrix_int4x2_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int4x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int4x2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 4x2 matrix. 29 | /// 30 | /// @see ext_matrix_int4x2_sized 31 | typedef mat<4, 2, int8, defaultp> i8mat4x2; 32 | 33 | /// 16 bit signed integer 4x2 matrix. 34 | /// 35 | /// @see ext_matrix_int4x2_sized 36 | typedef mat<4, 2, int16, defaultp> i16mat4x2; 37 | 38 | /// 32 bit signed integer 4x2 matrix. 39 | /// 40 | /// @see ext_matrix_int4x2_sized 41 | typedef mat<4, 2, int32, defaultp> i32mat4x2; 42 | 43 | /// 64 bit signed integer 4x2 matrix. 44 | /// 45 | /// @see ext_matrix_int4x2_sized 46 | typedef mat<4, 2, int64, defaultp> i64mat4x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_int4x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x3_sized 2 | /// @file glm/ext/matrix_int4x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x3_sized GLM_EXT_matrix_int4x3_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int4x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int4x3_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 4x3 matrix. 29 | /// 30 | /// @see ext_matrix_int4x3_sized 31 | typedef mat<4, 3, int8, defaultp> i8mat4x3; 32 | 33 | /// 16 bit signed integer 4x3 matrix. 34 | /// 35 | /// @see ext_matrix_int4x3_sized 36 | typedef mat<4, 3, int16, defaultp> i16mat4x3; 37 | 38 | /// 32 bit signed integer 4x3 matrix. 39 | /// 40 | /// @see ext_matrix_int4x3_sized 41 | typedef mat<4, 3, int32, defaultp> i32mat4x3; 42 | 43 | /// 64 bit signed integer 4x3 matrix. 44 | /// 45 | /// @see ext_matrix_int4x3_sized 46 | typedef mat<4, 3, int64, defaultp> i64mat4x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /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/matrix_uint3x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x2_sized 2 | /// @file glm/ext/matrix_uint3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x2_sized GLM_EXT_matrix_uint3x2_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint3x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint3x2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 3x2 matrix. 29 | /// 30 | /// @see ext_matrix_uint3x2_sized 31 | typedef mat<3, 2, uint8, defaultp> u8mat3x2; 32 | 33 | /// 16 bit signed integer 3x2 matrix. 34 | /// 35 | /// @see ext_matrix_uint3x2_sized 36 | typedef mat<3, 2, uint16, defaultp> u16mat3x2; 37 | 38 | /// 32 bit signed integer 3x2 matrix. 39 | /// 40 | /// @see ext_matrix_uint3x2_sized 41 | typedef mat<3, 2, uint32, defaultp> u32mat3x2; 42 | 43 | /// 64 bit signed integer 3x2 matrix. 44 | /// 45 | /// @see ext_matrix_uint3x2_sized 46 | typedef mat<3, 2, uint64, defaultp> u64mat3x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /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 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/type_precision.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | #include "../gtx/dual_quaternion.hpp" 22 | #include 23 | #include 24 | 25 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 26 | # ifndef GLM_ENABLE_EXPERIMENTAL 27 | # pragma message("GLM: GLM_GTX_string_cast is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 28 | # else 29 | # pragma message("GLM: GLM_GTX_string_cast extension included") 30 | # endif 31 | #endif 32 | 33 | namespace glm 34 | { 35 | /// @addtogroup gtx_string_cast 36 | /// @{ 37 | 38 | /// Create a string from a GLM vector or matrix typed variable. 39 | /// @see gtx_string_cast extension. 40 | template 41 | GLM_FUNC_DECL std::string to_string(genType const& x); 42 | 43 | /// @} 44 | }//namespace glm 45 | 46 | #include "string_cast.inl" 47 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint2x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x3_sized 2 | /// @file glm/ext/matrix_uint2x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x3_sized GLM_EXT_matrix_uint2x3_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint2x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint2x3_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 2x3 matrix. 29 | /// 30 | /// @see ext_matrix_uint2x3_sized 31 | typedef mat<2, 3, uint8, defaultp> u8mat2x3; 32 | 33 | /// 16 bit unsigned integer 2x3 matrix. 34 | /// 35 | /// @see ext_matrix_uint2x3_sized 36 | typedef mat<2, 3, uint16, defaultp> u16mat2x3; 37 | 38 | /// 32 bit unsigned integer 2x3 matrix. 39 | /// 40 | /// @see ext_matrix_uint2x3_sized 41 | typedef mat<2, 3, uint32, defaultp> u32mat2x3; 42 | 43 | /// 64 bit unsigned integer 2x3 matrix. 44 | /// 45 | /// @see ext_matrix_uint2x3_sized 46 | typedef mat<2, 3, uint64, defaultp> u64mat2x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint2x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x4_sized 2 | /// @file glm/ext/matrixu_uint2x4_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x4_sized GLM_EXT_matrix_uint2x4_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint2x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint2x4_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 2x4 matrix. 29 | /// 30 | /// @see ext_matrix_uint2x4_sized 31 | typedef mat<2, 4, uint8, defaultp> u8mat2x4; 32 | 33 | /// 16 bit unsigned integer 2x4 matrix. 34 | /// 35 | /// @see ext_matrix_uint2x4_sized 36 | typedef mat<2, 4, uint16, defaultp> u16mat2x4; 37 | 38 | /// 32 bit unsigned integer 2x4 matrix. 39 | /// 40 | /// @see ext_matrix_uint2x4_sized 41 | typedef mat<2, 4, uint32, defaultp> u32mat2x4; 42 | 43 | /// 64 bit unsigned integer 2x4 matrix. 44 | /// 45 | /// @see ext_matrix_uint2x4_sized 46 | typedef mat<2, 4, uint64, defaultp> u64mat2x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint3x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x4_sized 2 | /// @file glm/ext/matrix_uint3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x4_sized GLM_EXT_matrix_uint3x4_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint3x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint3x4_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 3x4 matrix. 29 | /// 30 | /// @see ext_matrix_uint3x4_sized 31 | typedef mat<3, 4, uint8, defaultp> u8mat3x4; 32 | 33 | /// 16 bit unsigned integer 3x4 matrix. 34 | /// 35 | /// @see ext_matrix_uint3x4_sized 36 | typedef mat<3, 4, uint16, defaultp> u16mat3x4; 37 | 38 | /// 32 bit unsigned integer 3x4 matrix. 39 | /// 40 | /// @see ext_matrix_uint3x4_sized 41 | typedef mat<3, 4, uint32, defaultp> u32mat3x4; 42 | 43 | /// 64 bit unsigned integer 3x4 matrix. 44 | /// 45 | /// @see ext_matrix_uint3x4_sized 46 | typedef mat<3, 4, uint64, defaultp> u64mat3x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint4x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x2_sized 2 | /// @file glm/ext/matrix_uint4x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x2_sized GLM_EXT_matrix_uint4x2_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint4x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint4x2_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 4x2 matrix. 29 | /// 30 | /// @see ext_matrix_uint4x2_sized 31 | typedef mat<4, 2, uint8, defaultp> u8mat4x2; 32 | 33 | /// 16 bit unsigned integer 4x2 matrix. 34 | /// 35 | /// @see ext_matrix_uint4x2_sized 36 | typedef mat<4, 2, uint16, defaultp> u16mat4x2; 37 | 38 | /// 32 bit unsigned integer 4x2 matrix. 39 | /// 40 | /// @see ext_matrix_uint4x2_sized 41 | typedef mat<4, 2, uint32, defaultp> u32mat4x2; 42 | 43 | /// 64 bit unsigned integer 4x2 matrix. 44 | /// 45 | /// @see ext_matrix_uint4x2_sized 46 | typedef mat<4, 2, uint64, defaultp> u64mat4x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/matrix_uint4x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x3_sized 2 | /// @file glm/ext/matrix_uint4x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x3_sized GLM_EXT_matrix_uint4x3_sized 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint4x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint4x3_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 4x3 matrix. 29 | /// 30 | /// @see ext_matrix_uint4x3_sized 31 | typedef mat<4, 3, uint8, defaultp> u8mat4x3; 32 | 33 | /// 16 bit unsigned integer 4x3 matrix. 34 | /// 35 | /// @see ext_matrix_uint4x3_sized 36 | typedef mat<4, 3, uint16, defaultp> u16mat4x3; 37 | 38 | /// 32 bit unsigned integer 4x3 matrix. 39 | /// 40 | /// @see ext_matrix_uint4x3_sized 41 | typedef mat<4, 3, uint32, defaultp> u32mat4x3; 42 | 43 | /// 64 bit unsigned integer 4x3 matrix. 44 | /// 45 | /// @see ext_matrix_uint4x3_sized 46 | typedef mat<4, 3, uint64, defaultp> u64mat4x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/vector_int1_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int1_sized 2 | /// @file glm/ext/vector_int1_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int1_sized GLM_EXT_vector_int1_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint1_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int1.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int1_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int1_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 1 component type. 29 | /// 30 | /// @see ext_vector_int1_sized 31 | typedef vec<1, int8, defaultp> i8vec1; 32 | 33 | /// 16 bit signed integer vector of 1 component type. 34 | /// 35 | /// @see ext_vector_int1_sized 36 | typedef vec<1, int16, defaultp> i16vec1; 37 | 38 | /// 32 bit signed integer vector of 1 component type. 39 | /// 40 | /// @see ext_vector_int1_sized 41 | typedef vec<1, int32, defaultp> i32vec1; 42 | 43 | /// 64 bit signed integer vector of 1 component type. 44 | /// 45 | /// @see ext_vector_int1_sized 46 | typedef vec<1, int64, defaultp> i64vec1; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/vector_int2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int2_sized 2 | /// @file glm/ext/vector_int2_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int2_sized GLM_EXT_vector_int2_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector of 2 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint2_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int2.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 2 components type. 29 | /// 30 | /// @see ext_vector_int2_sized 31 | typedef vec<2, int8, defaultp> i8vec2; 32 | 33 | /// 16 bit signed integer vector of 2 components type. 34 | /// 35 | /// @see ext_vector_int2_sized 36 | typedef vec<2, int16, defaultp> i16vec2; 37 | 38 | /// 32 bit signed integer vector of 2 components type. 39 | /// 40 | /// @see ext_vector_int2_sized 41 | typedef vec<2, int32, defaultp> i32vec2; 42 | 43 | /// 64 bit signed integer vector of 2 components type. 44 | /// 45 | /// @see ext_vector_int2_sized 46 | typedef vec<2, int64, defaultp> i64vec2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/vector_int3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int3_sized 2 | /// @file glm/ext/vector_int3_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int3_sized GLM_EXT_vector_int3_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector of 3 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint3_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int3.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int3_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 3 components type. 29 | /// 30 | /// @see ext_vector_int3_sized 31 | typedef vec<3, int8, defaultp> i8vec3; 32 | 33 | /// 16 bit signed integer vector of 3 components type. 34 | /// 35 | /// @see ext_vector_int3_sized 36 | typedef vec<3, int16, defaultp> i16vec3; 37 | 38 | /// 32 bit signed integer vector of 3 components type. 39 | /// 40 | /// @see ext_vector_int3_sized 41 | typedef vec<3, int32, defaultp> i32vec3; 42 | 43 | /// 64 bit signed integer vector of 3 components type. 44 | /// 45 | /// @see ext_vector_int3_sized 46 | typedef vec<3, int64, defaultp> i64vec3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/vector_int4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int4_sized 2 | /// @file glm/ext/vector_int4_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int4_sized GLM_EXT_vector_int4_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector of 4 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint4_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int4.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int4_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 4 components type. 29 | /// 30 | /// @see ext_vector_int4_sized 31 | typedef vec<4, int8, defaultp> i8vec4; 32 | 33 | /// 16 bit signed integer vector of 4 components type. 34 | /// 35 | /// @see ext_vector_int4_sized 36 | typedef vec<4, int16, defaultp> i16vec4; 37 | 38 | /// 32 bit signed integer vector of 4 components type. 39 | /// 40 | /// @see ext_vector_int4_sized 41 | typedef vec<4, int32, defaultp> i32vec4; 42 | 43 | /// 64 bit signed integer vector of 4 components type. 44 | /// 45 | /// @see ext_vector_int4_sized 46 | typedef vec<4, int64, defaultp> i64vec4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /include/glm/ext/vector_uint1_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint1_sized 2 | /// @file glm/ext/vector_uint1_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_uint1_sized GLM_EXT_vector_uint1_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer vector types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | /// @see ext_vector_int1_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_uint1.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_uint1_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_uint1_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer vector of 1 component type. 29 | /// 30 | /// @see ext_vector_uint1_sized 31 | typedef vec<1, uint8, defaultp> u8vec1; 32 | 33 | /// 16 bit unsigned integer vector of 1 component type. 34 | /// 35 | /// @see ext_vector_uint1_sized 36 | typedef vec<1, uint16, defaultp> u16vec1; 37 | 38 | /// 32 bit unsigned integer vector of 1 component type. 39 | /// 40 | /// @see ext_vector_uint1_sized 41 | typedef vec<1, uint32, defaultp> u32vec1; 42 | 43 | /// 64 bit unsigned integer vector of 1 component type. 44 | /// 45 | /// @see ext_vector_uint1_sized 46 | typedef vec<1, uint64, defaultp> u64vec1; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /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 | # else 23 | # pragma message("GLM: GLM_GTX_raw_data extension included") 24 | # endif 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_raw_data 30 | /// @{ 31 | 32 | //! Type for byte numbers. 33 | //! From GLM_GTX_raw_data extension. 34 | typedef detail::uint8 byte; 35 | 36 | //! Type for word numbers. 37 | //! From GLM_GTX_raw_data extension. 38 | typedef detail::uint16 word; 39 | 40 | //! Type for dword numbers. 41 | //! From GLM_GTX_raw_data extension. 42 | typedef detail::uint32 dword; 43 | 44 | //! Type for qword numbers. 45 | //! From GLM_GTX_raw_data extension. 46 | typedef detail::uint64 qword; 47 | 48 | /// @} 49 | }// namespace glm 50 | 51 | #include "raw_data.inl" 52 | -------------------------------------------------------------------------------- /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 | --------------------------------------------------------------------------------