Showing preview only (4,506K chars total). Download the full file or copy to clipboard to get everything.
Repository: ebirenbaum/ParticleSolver
Branch: master
Commit: ac90692af122
Files: 620
Total size: 4.2 MB
Directory structure:
gitextract_vkj5l6cr/
├── .gitignore
├── LICENSE
├── README.md
├── cpu/
│ ├── README
│ ├── glm/
│ │ ├── CMakeLists.txt
│ │ ├── common.hpp
│ │ ├── detail/
│ │ │ ├── _features.hpp
│ │ │ ├── _fixes.hpp
│ │ │ ├── _literals.hpp
│ │ │ ├── _noise.hpp
│ │ │ ├── _swizzle.hpp
│ │ │ ├── _swizzle_func.hpp
│ │ │ ├── _vectorize.hpp
│ │ │ ├── dummy.cpp
│ │ │ ├── func_common.hpp
│ │ │ ├── func_common.inl
│ │ │ ├── func_exponential.hpp
│ │ │ ├── func_exponential.inl
│ │ │ ├── func_geometric.hpp
│ │ │ ├── func_geometric.inl
│ │ │ ├── func_integer.hpp
│ │ │ ├── func_integer.inl
│ │ │ ├── func_matrix.hpp
│ │ │ ├── func_matrix.inl
│ │ │ ├── func_noise.hpp
│ │ │ ├── func_noise.inl
│ │ │ ├── func_packing.hpp
│ │ │ ├── func_packing.inl
│ │ │ ├── func_trigonometric.hpp
│ │ │ ├── func_trigonometric.inl
│ │ │ ├── func_vector_relational.hpp
│ │ │ ├── func_vector_relational.inl
│ │ │ ├── glm.cpp
│ │ │ ├── hint.hpp
│ │ │ ├── intrinsic_common.hpp
│ │ │ ├── intrinsic_common.inl
│ │ │ ├── intrinsic_exponential.hpp
│ │ │ ├── intrinsic_exponential.inl
│ │ │ ├── intrinsic_geometric.hpp
│ │ │ ├── intrinsic_geometric.inl
│ │ │ ├── intrinsic_integer.hpp
│ │ │ ├── intrinsic_integer.inl
│ │ │ ├── intrinsic_matrix.hpp
│ │ │ ├── intrinsic_matrix.inl
│ │ │ ├── intrinsic_trigonometric.hpp
│ │ │ ├── intrinsic_trigonometric.inl
│ │ │ ├── intrinsic_vector_relational.hpp
│ │ │ ├── intrinsic_vector_relational.inl
│ │ │ ├── precision.hpp
│ │ │ ├── precision.inl
│ │ │ ├── setup.hpp
│ │ │ ├── type_float.hpp
│ │ │ ├── type_gentype.hpp
│ │ │ ├── type_gentype.inl
│ │ │ ├── type_half.hpp
│ │ │ ├── type_half.inl
│ │ │ ├── type_int.hpp
│ │ │ ├── type_mat.hpp
│ │ │ ├── type_mat.inl
│ │ │ ├── type_mat2x2.hpp
│ │ │ ├── type_mat2x2.inl
│ │ │ ├── type_mat2x3.hpp
│ │ │ ├── type_mat2x3.inl
│ │ │ ├── type_mat2x4.hpp
│ │ │ ├── type_mat2x4.inl
│ │ │ ├── type_mat3x2.hpp
│ │ │ ├── type_mat3x2.inl
│ │ │ ├── type_mat3x3.hpp
│ │ │ ├── type_mat3x3.inl
│ │ │ ├── type_mat3x4.hpp
│ │ │ ├── type_mat3x4.inl
│ │ │ ├── type_mat4x2.hpp
│ │ │ ├── type_mat4x2.inl
│ │ │ ├── type_mat4x3.hpp
│ │ │ ├── type_mat4x3.inl
│ │ │ ├── type_mat4x4.hpp
│ │ │ ├── type_mat4x4.inl
│ │ │ ├── type_vec.hpp
│ │ │ ├── type_vec.inl
│ │ │ ├── type_vec1.hpp
│ │ │ ├── type_vec1.inl
│ │ │ ├── type_vec2.hpp
│ │ │ ├── type_vec2.inl
│ │ │ ├── type_vec3.hpp
│ │ │ ├── type_vec3.inl
│ │ │ ├── type_vec4.hpp
│ │ │ └── type_vec4.inl
│ │ ├── exponential.hpp
│ │ ├── ext.hpp
│ │ ├── fwd.hpp
│ │ ├── geometric.hpp
│ │ ├── glm.hpp
│ │ ├── gtc/
│ │ │ ├── constants.hpp
│ │ │ ├── constants.inl
│ │ │ ├── epsilon.hpp
│ │ │ ├── epsilon.inl
│ │ │ ├── matrix_access.hpp
│ │ │ ├── matrix_access.inl
│ │ │ ├── matrix_integer.hpp
│ │ │ ├── matrix_inverse.hpp
│ │ │ ├── matrix_inverse.inl
│ │ │ ├── matrix_transform.hpp
│ │ │ ├── matrix_transform.inl
│ │ │ ├── noise.hpp
│ │ │ ├── noise.inl
│ │ │ ├── packing.hpp
│ │ │ ├── packing.inl
│ │ │ ├── quaternion.hpp
│ │ │ ├── quaternion.inl
│ │ │ ├── random.hpp
│ │ │ ├── random.inl
│ │ │ ├── reciprocal.hpp
│ │ │ ├── reciprocal.inl
│ │ │ ├── type_precision.hpp
│ │ │ ├── type_precision.inl
│ │ │ ├── type_ptr.hpp
│ │ │ ├── type_ptr.inl
│ │ │ ├── ulp.hpp
│ │ │ └── ulp.inl
│ │ ├── gtx/
│ │ │ ├── associated_min_max.hpp
│ │ │ ├── associated_min_max.inl
│ │ │ ├── bit.hpp
│ │ │ ├── bit.inl
│ │ │ ├── closest_point.hpp
│ │ │ ├── closest_point.inl
│ │ │ ├── color_space.hpp
│ │ │ ├── color_space.inl
│ │ │ ├── color_space_YCoCg.hpp
│ │ │ ├── color_space_YCoCg.inl
│ │ │ ├── compatibility.hpp
│ │ │ ├── compatibility.inl
│ │ │ ├── component_wise.hpp
│ │ │ ├── component_wise.inl
│ │ │ ├── constants.hpp
│ │ │ ├── dual_quaternion.hpp
│ │ │ ├── dual_quaternion.inl
│ │ │ ├── epsilon.hpp
│ │ │ ├── euler_angles.hpp
│ │ │ ├── euler_angles.inl
│ │ │ ├── extend.hpp
│ │ │ ├── extend.inl
│ │ │ ├── extented_min_max.hpp
│ │ │ ├── extented_min_max.inl
│ │ │ ├── fast_exponential.hpp
│ │ │ ├── fast_exponential.inl
│ │ │ ├── fast_square_root.hpp
│ │ │ ├── fast_square_root.inl
│ │ │ ├── fast_trigonometry.hpp
│ │ │ ├── fast_trigonometry.inl
│ │ │ ├── gradient_paint.hpp
│ │ │ ├── gradient_paint.inl
│ │ │ ├── handed_coordinate_space.hpp
│ │ │ ├── handed_coordinate_space.inl
│ │ │ ├── inertia.hpp
│ │ │ ├── inertia.inl
│ │ │ ├── int_10_10_10_2.hpp
│ │ │ ├── int_10_10_10_2.inl
│ │ │ ├── integer.hpp
│ │ │ ├── integer.inl
│ │ │ ├── intersect.hpp
│ │ │ ├── intersect.inl
│ │ │ ├── io.hpp
│ │ │ ├── io.inl
│ │ │ ├── log_base.hpp
│ │ │ ├── log_base.inl
│ │ │ ├── matrix_cross_product.hpp
│ │ │ ├── matrix_cross_product.inl
│ │ │ ├── matrix_interpolation.hpp
│ │ │ ├── matrix_interpolation.inl
│ │ │ ├── matrix_major_storage.hpp
│ │ │ ├── matrix_major_storage.inl
│ │ │ ├── matrix_operation.hpp
│ │ │ ├── matrix_operation.inl
│ │ │ ├── matrix_query.hpp
│ │ │ ├── matrix_query.inl
│ │ │ ├── mixed_product.hpp
│ │ │ ├── mixed_product.inl
│ │ │ ├── multiple.hpp
│ │ │ ├── multiple.inl
│ │ │ ├── noise.hpp
│ │ │ ├── norm.hpp
│ │ │ ├── norm.inl
│ │ │ ├── normal.hpp
│ │ │ ├── normal.inl
│ │ │ ├── normalize_dot.hpp
│ │ │ ├── normalize_dot.inl
│ │ │ ├── number_precision.hpp
│ │ │ ├── number_precision.inl
│ │ │ ├── optimum_pow.hpp
│ │ │ ├── optimum_pow.inl
│ │ │ ├── orthonormalize.hpp
│ │ │ ├── orthonormalize.inl
│ │ │ ├── perpendicular.hpp
│ │ │ ├── perpendicular.inl
│ │ │ ├── polar_coordinates.hpp
│ │ │ ├── polar_coordinates.inl
│ │ │ ├── projection.hpp
│ │ │ ├── projection.inl
│ │ │ ├── quaternion.hpp
│ │ │ ├── quaternion.inl
│ │ │ ├── random.hpp
│ │ │ ├── raw_data.hpp
│ │ │ ├── raw_data.inl
│ │ │ ├── reciprocal.hpp
│ │ │ ├── rotate_normalized_axis.hpp
│ │ │ ├── rotate_normalized_axis.inl
│ │ │ ├── rotate_vector.hpp
│ │ │ ├── rotate_vector.inl
│ │ │ ├── scalar_relational.hpp
│ │ │ ├── scalar_relational.inl
│ │ │ ├── simd_mat4.hpp
│ │ │ ├── simd_mat4.inl
│ │ │ ├── simd_quat.hpp
│ │ │ ├── simd_quat.inl
│ │ │ ├── simd_vec4.hpp
│ │ │ ├── simd_vec4.inl
│ │ │ ├── spline.hpp
│ │ │ ├── spline.inl
│ │ │ ├── std_based_type.hpp
│ │ │ ├── std_based_type.inl
│ │ │ ├── string_cast.hpp
│ │ │ ├── string_cast.inl
│ │ │ ├── transform.hpp
│ │ │ ├── transform.inl
│ │ │ ├── transform2.hpp
│ │ │ ├── transform2.inl
│ │ │ ├── ulp.hpp
│ │ │ ├── unsigned_int.hpp
│ │ │ ├── unsigned_int.inl
│ │ │ ├── vec1.hpp
│ │ │ ├── vec1.inl
│ │ │ ├── vector_angle.hpp
│ │ │ ├── vector_angle.inl
│ │ │ ├── vector_query.hpp
│ │ │ ├── vector_query.inl
│ │ │ ├── wrap.hpp
│ │ │ └── wrap.inl
│ │ ├── integer.hpp
│ │ ├── mat2x2.hpp
│ │ ├── mat2x3.hpp
│ │ ├── mat2x4.hpp
│ │ ├── mat3x2.hpp
│ │ ├── mat3x3.hpp
│ │ ├── mat3x4.hpp
│ │ ├── mat4x2.hpp
│ │ ├── mat4x3.hpp
│ │ ├── mat4x4.hpp
│ │ ├── matrix.hpp
│ │ ├── packing.hpp
│ │ ├── trigonometric.hpp
│ │ ├── vec2.hpp
│ │ ├── vec3.hpp
│ │ ├── vec4.hpp
│ │ ├── vector_relational.hpp
│ │ └── virtrev/
│ │ └── xstream.hpp
│ ├── lib/
│ │ └── umfpack/
│ │ ├── include/
│ │ │ ├── UFconfig.h
│ │ │ ├── UMFPACK/
│ │ │ │ ├── umfpack.h
│ │ │ │ ├── umfpack_col_to_triplet.h
│ │ │ │ ├── umfpack_defaults.h
│ │ │ │ ├── umfpack_free_numeric.h
│ │ │ │ ├── umfpack_free_symbolic.h
│ │ │ │ ├── umfpack_get_determinant.h
│ │ │ │ ├── umfpack_get_lunz.h
│ │ │ │ ├── umfpack_get_numeric.h
│ │ │ │ ├── umfpack_get_symbolic.h
│ │ │ │ ├── umfpack_global.h
│ │ │ │ ├── umfpack_load_numeric.h
│ │ │ │ ├── umfpack_load_symbolic.h
│ │ │ │ ├── umfpack_numeric.h
│ │ │ │ ├── umfpack_qsymbolic.h
│ │ │ │ ├── umfpack_report_control.h
│ │ │ │ ├── umfpack_report_info.h
│ │ │ │ ├── umfpack_report_matrix.h
│ │ │ │ ├── umfpack_report_numeric.h
│ │ │ │ ├── umfpack_report_perm.h
│ │ │ │ ├── umfpack_report_status.h
│ │ │ │ ├── umfpack_report_symbolic.h
│ │ │ │ ├── umfpack_report_triplet.h
│ │ │ │ ├── umfpack_report_vector.h
│ │ │ │ ├── umfpack_save_numeric.h
│ │ │ │ ├── umfpack_save_symbolic.h
│ │ │ │ ├── umfpack_scale.h
│ │ │ │ ├── umfpack_solve.h
│ │ │ │ ├── umfpack_symbolic.h
│ │ │ │ ├── umfpack_tictoc.h
│ │ │ │ ├── umfpack_timer.h
│ │ │ │ ├── umfpack_transpose.h
│ │ │ │ ├── umfpack_triplet_to_col.h
│ │ │ │ └── umfpack_wsolve.h
│ │ │ ├── amd.h
│ │ │ └── amd_internal.h
│ │ ├── libamd.a
│ │ └── libumfpack.a
│ ├── particles.pro
│ └── src/
│ ├── constraint/
│ │ ├── boundaryconstraint.cpp
│ │ ├── boundaryconstraint.h
│ │ ├── contactconstraint.cpp
│ │ ├── contactconstraint.h
│ │ ├── distanceconstraint.cpp
│ │ ├── distanceconstraint.h
│ │ ├── gasconstraint.cpp
│ │ ├── gasconstraint.h
│ │ ├── rigidcontactconstraint.cpp
│ │ ├── rigidcontactconstraint.h
│ │ ├── smokeparticle.cpp
│ │ ├── smokeparticle.h
│ │ ├── totalfluidconstraint.cpp
│ │ ├── totalfluidconstraint.h
│ │ ├── totalshapeconstraint.cpp
│ │ └── totalshapeconstraint.h
│ ├── fluidemitter.cpp
│ ├── fluidemitter.h
│ ├── includes.h
│ ├── main.cpp
│ ├── mainwindow.cpp
│ ├── mainwindow.h
│ ├── mainwindow.ui
│ ├── opensmokeemitter.cpp
│ ├── opensmokeemitter.h
│ ├── particle.h
│ ├── simulation.cpp
│ ├── simulation.h
│ ├── solver/
│ │ ├── lineareq.cpp
│ │ ├── lineareq.h
│ │ ├── matrix.cpp
│ │ ├── matrix.h
│ │ ├── matrix.inl
│ │ ├── particle.cpp
│ │ ├── solver.cpp
│ │ └── solver.h
│ ├── view.cpp
│ └── view.h
└── gpu/
├── glm/
│ ├── CMakeLists.txt
│ ├── common.hpp
│ ├── detail/
│ │ ├── _features.hpp
│ │ ├── _fixes.hpp
│ │ ├── _literals.hpp
│ │ ├── _noise.hpp
│ │ ├── _swizzle.hpp
│ │ ├── _swizzle_func.hpp
│ │ ├── _vectorize.hpp
│ │ ├── dummy.cpp
│ │ ├── func_common.hpp
│ │ ├── func_common.inl
│ │ ├── func_exponential.hpp
│ │ ├── func_exponential.inl
│ │ ├── func_geometric.hpp
│ │ ├── func_geometric.inl
│ │ ├── func_integer.hpp
│ │ ├── func_integer.inl
│ │ ├── func_matrix.hpp
│ │ ├── func_matrix.inl
│ │ ├── func_noise.hpp
│ │ ├── func_noise.inl
│ │ ├── func_packing.hpp
│ │ ├── func_packing.inl
│ │ ├── func_trigonometric.hpp
│ │ ├── func_trigonometric.inl
│ │ ├── func_vector_relational.hpp
│ │ ├── func_vector_relational.inl
│ │ ├── glm.cpp
│ │ ├── hint.hpp
│ │ ├── intrinsic_common.hpp
│ │ ├── intrinsic_common.inl
│ │ ├── intrinsic_exponential.hpp
│ │ ├── intrinsic_exponential.inl
│ │ ├── intrinsic_geometric.hpp
│ │ ├── intrinsic_geometric.inl
│ │ ├── intrinsic_integer.hpp
│ │ ├── intrinsic_integer.inl
│ │ ├── intrinsic_matrix.hpp
│ │ ├── intrinsic_matrix.inl
│ │ ├── intrinsic_trigonometric.hpp
│ │ ├── intrinsic_trigonometric.inl
│ │ ├── intrinsic_vector_relational.hpp
│ │ ├── intrinsic_vector_relational.inl
│ │ ├── precision.hpp
│ │ ├── precision.inl
│ │ ├── setup.hpp
│ │ ├── type_float.hpp
│ │ ├── type_gentype.hpp
│ │ ├── type_gentype.inl
│ │ ├── type_half.hpp
│ │ ├── type_half.inl
│ │ ├── type_int.hpp
│ │ ├── type_mat.hpp
│ │ ├── type_mat.inl
│ │ ├── type_mat2x2.hpp
│ │ ├── type_mat2x2.inl
│ │ ├── type_mat2x3.hpp
│ │ ├── type_mat2x3.inl
│ │ ├── type_mat2x4.hpp
│ │ ├── type_mat2x4.inl
│ │ ├── type_mat3x2.hpp
│ │ ├── type_mat3x2.inl
│ │ ├── type_mat3x3.hpp
│ │ ├── type_mat3x3.inl
│ │ ├── type_mat3x4.hpp
│ │ ├── type_mat3x4.inl
│ │ ├── type_mat4x2.hpp
│ │ ├── type_mat4x2.inl
│ │ ├── type_mat4x3.hpp
│ │ ├── type_mat4x3.inl
│ │ ├── type_mat4x4.hpp
│ │ ├── type_mat4x4.inl
│ │ ├── type_vec.hpp
│ │ ├── type_vec.inl
│ │ ├── type_vec1.hpp
│ │ ├── type_vec1.inl
│ │ ├── type_vec2.hpp
│ │ ├── type_vec2.inl
│ │ ├── type_vec3.hpp
│ │ ├── type_vec3.inl
│ │ ├── type_vec4.hpp
│ │ └── type_vec4.inl
│ ├── exponential.hpp
│ ├── ext.hpp
│ ├── fwd.hpp
│ ├── geometric.hpp
│ ├── glm.hpp
│ ├── gtc/
│ │ ├── constants.hpp
│ │ ├── constants.inl
│ │ ├── epsilon.hpp
│ │ ├── epsilon.inl
│ │ ├── matrix_access.hpp
│ │ ├── matrix_access.inl
│ │ ├── matrix_integer.hpp
│ │ ├── matrix_inverse.hpp
│ │ ├── matrix_inverse.inl
│ │ ├── matrix_transform.hpp
│ │ ├── matrix_transform.inl
│ │ ├── noise.hpp
│ │ ├── noise.inl
│ │ ├── packing.hpp
│ │ ├── packing.inl
│ │ ├── quaternion.hpp
│ │ ├── quaternion.inl
│ │ ├── random.hpp
│ │ ├── random.inl
│ │ ├── reciprocal.hpp
│ │ ├── reciprocal.inl
│ │ ├── type_precision.hpp
│ │ ├── type_precision.inl
│ │ ├── type_ptr.hpp
│ │ ├── type_ptr.inl
│ │ ├── ulp.hpp
│ │ └── ulp.inl
│ ├── gtx/
│ │ ├── associated_min_max.hpp
│ │ ├── associated_min_max.inl
│ │ ├── bit.hpp
│ │ ├── bit.inl
│ │ ├── closest_point.hpp
│ │ ├── closest_point.inl
│ │ ├── color_space.hpp
│ │ ├── color_space.inl
│ │ ├── color_space_YCoCg.hpp
│ │ ├── color_space_YCoCg.inl
│ │ ├── compatibility.hpp
│ │ ├── compatibility.inl
│ │ ├── component_wise.hpp
│ │ ├── component_wise.inl
│ │ ├── constants.hpp
│ │ ├── dual_quaternion.hpp
│ │ ├── dual_quaternion.inl
│ │ ├── epsilon.hpp
│ │ ├── euler_angles.hpp
│ │ ├── euler_angles.inl
│ │ ├── extend.hpp
│ │ ├── extend.inl
│ │ ├── extented_min_max.hpp
│ │ ├── extented_min_max.inl
│ │ ├── fast_exponential.hpp
│ │ ├── fast_exponential.inl
│ │ ├── fast_square_root.hpp
│ │ ├── fast_square_root.inl
│ │ ├── fast_trigonometry.hpp
│ │ ├── fast_trigonometry.inl
│ │ ├── gradient_paint.hpp
│ │ ├── gradient_paint.inl
│ │ ├── handed_coordinate_space.hpp
│ │ ├── handed_coordinate_space.inl
│ │ ├── inertia.hpp
│ │ ├── inertia.inl
│ │ ├── int_10_10_10_2.hpp
│ │ ├── int_10_10_10_2.inl
│ │ ├── integer.hpp
│ │ ├── integer.inl
│ │ ├── intersect.hpp
│ │ ├── intersect.inl
│ │ ├── io.hpp
│ │ ├── io.inl
│ │ ├── log_base.hpp
│ │ ├── log_base.inl
│ │ ├── matrix_cross_product.hpp
│ │ ├── matrix_cross_product.inl
│ │ ├── matrix_interpolation.hpp
│ │ ├── matrix_interpolation.inl
│ │ ├── matrix_major_storage.hpp
│ │ ├── matrix_major_storage.inl
│ │ ├── matrix_operation.hpp
│ │ ├── matrix_operation.inl
│ │ ├── matrix_query.hpp
│ │ ├── matrix_query.inl
│ │ ├── mixed_product.hpp
│ │ ├── mixed_product.inl
│ │ ├── multiple.hpp
│ │ ├── multiple.inl
│ │ ├── noise.hpp
│ │ ├── norm.hpp
│ │ ├── norm.inl
│ │ ├── normal.hpp
│ │ ├── normal.inl
│ │ ├── normalize_dot.hpp
│ │ ├── normalize_dot.inl
│ │ ├── number_precision.hpp
│ │ ├── number_precision.inl
│ │ ├── optimum_pow.hpp
│ │ ├── optimum_pow.inl
│ │ ├── orthonormalize.hpp
│ │ ├── orthonormalize.inl
│ │ ├── perpendicular.hpp
│ │ ├── perpendicular.inl
│ │ ├── polar_coordinates.hpp
│ │ ├── polar_coordinates.inl
│ │ ├── projection.hpp
│ │ ├── projection.inl
│ │ ├── quaternion.hpp
│ │ ├── quaternion.inl
│ │ ├── random.hpp
│ │ ├── raw_data.hpp
│ │ ├── raw_data.inl
│ │ ├── reciprocal.hpp
│ │ ├── rotate_normalized_axis.hpp
│ │ ├── rotate_normalized_axis.inl
│ │ ├── rotate_vector.hpp
│ │ ├── rotate_vector.inl
│ │ ├── scalar_relational.hpp
│ │ ├── scalar_relational.inl
│ │ ├── simd_mat4.hpp
│ │ ├── simd_mat4.inl
│ │ ├── simd_quat.hpp
│ │ ├── simd_quat.inl
│ │ ├── simd_vec4.hpp
│ │ ├── simd_vec4.inl
│ │ ├── spline.hpp
│ │ ├── spline.inl
│ │ ├── std_based_type.hpp
│ │ ├── std_based_type.inl
│ │ ├── string_cast.hpp
│ │ ├── string_cast.inl
│ │ ├── transform.hpp
│ │ ├── transform.inl
│ │ ├── transform2.hpp
│ │ ├── transform2.inl
│ │ ├── ulp.hpp
│ │ ├── unsigned_int.hpp
│ │ ├── unsigned_int.inl
│ │ ├── vec1.hpp
│ │ ├── vec1.inl
│ │ ├── vector_angle.hpp
│ │ ├── vector_angle.inl
│ │ ├── vector_query.hpp
│ │ ├── vector_query.inl
│ │ ├── wrap.hpp
│ │ └── wrap.inl
│ ├── integer.hpp
│ ├── mat2x2.hpp
│ ├── mat2x3.hpp
│ ├── mat2x4.hpp
│ ├── mat3x2.hpp
│ ├── mat3x3.hpp
│ ├── mat3x4.hpp
│ ├── mat4x2.hpp
│ ├── mat4x3.hpp
│ ├── mat4x4.hpp
│ ├── matrix.hpp
│ ├── packing.hpp
│ ├── trigonometric.hpp
│ ├── vec2.hpp
│ ├── vec3.hpp
│ ├── vec4.hpp
│ ├── vector_relational.hpp
│ └── virtrev/
│ └── xstream.hpp
├── particles_cuda.pro
├── res/
│ └── shaders/
│ ├── shader.frag
│ └── shader.vert
├── resources.qrc
└── src/
├── cuda/
│ ├── helper_cuda.h
│ ├── helper_math.h
│ ├── integration.cu
│ ├── integration_kernel.cuh
│ ├── kernel.cuh
│ ├── kernel_impl.cuh
│ ├── shared_variables.cu
│ ├── shared_variables.cuh
│ ├── solver.cu
│ ├── solver_kernel.cuh
│ ├── util.cu
│ ├── util.cuh
│ ├── wrappers.cuh
│ └── wrappers_cuda.cu
├── debugprinting.h
├── main.cpp
├── particleapp.cpp
├── particleapp.h
├── particlesystem.cpp
├── particlesystem.h
├── rendering/
│ ├── actioncamera.cpp
│ ├── actioncamera.h
│ ├── camera.cpp
│ ├── camera.h
│ ├── orbitingcamera.cpp
│ ├── orbitingcamera.h
│ ├── renderer.cpp
│ └── renderer.h
└── ui/
├── mainwindow.cpp
├── mainwindow.h
├── mainwindow.ui
├── view.cpp
└── view.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# QT #
######
*.pro.user*
*.qmake.stash
# Compiled Source #
###################
*.o
build/
# Executables #
###############
particles_cuda
particles_cuda.app
# OS Generated Files #
######################
*.DS_Store
# Makefiles #
#############
Makefile
================================================
FILE: LICENSE
================================================
The MIT License (MIT)
Copyright (c) 2015 ebirenbaum
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
# Unified Particle Solver
#### An implementation of Macklin et. al's [Unified Particle Physics for Real-Time Applications](http://mmacklin.com/uppfrta_preprint.pdf) for both the CPU and GPU.
This physics simulation was implemented on both the CPU (leveraging the Qt framework) and GPU (using CUDA) as a final project for Brown University's graduate-level course CSCI2240: Interactive Computer Graphics by Evan Birenbaum '15, Logan Barnes '15, and Geoff Trousdale '15.
#### Overview
The simulation supports a variety of states of matter by representing the entire world as a large set of small, individual, and independent particles that are influenced by a set of constraints. The system supports the following physical phenomena with two-way interaction:
- Inter-particle collisions
- Rigid bodies with approximated stacking
- Friction
- Rope and cloth
- Fluids
- Gases
#### CPU demo scenes
The following demo scenes are built in the CPU application, labeled with appropriate key commands to bring them up:
- *1* - A collapsing sand pile demonstrating frictional effect on angle of repose
- *2* - Stiff stacks of rigid bodies
- *3* - Stable stacking of rigid bodies in the formation of a wall
- *4* - Chained rigid bodies acting as a pendulum
- *5* - A fluid caught and held by a rope
- *6* - Two fluids settling, demonstrating the Rayleigh-Taylor instability
- *7* - Solids sinking or floating based on density
- *8* - Gas particles interacting with a swinging rope
- *9* - A rigid body being stopped by friction
- *0* - Fluids trapped like a water balloon
- *D* - Gas particles emitted into a closed space
- *S* - Gas particles emitted into an open space
- *W* - I came in like a wrecking ball!
- *N* - Newton's cradle
- *.* - Resolution of interlocked rigid bodies
- *V* - A volcano erupting and settling
The following commands may also be useful:
- *T* - Toggle real-time or time-step mode
- *Space* - move forward by a time step during time-step mode
- *R* - reset the simulation
- *C* - toggle rendering of individual particles
#### GPU demo scenes
Note: This version of the program no longer uses the CUDA 7 cuSolver library allowing it to be run on CUDA 5 capable machines.
The following demo scenes are built in the GPU application, labeled with appropriate key commands to bring them up:
- *1* - A single rope demonstrating basic distance constraints
- *2* - A cloth created with a grid of distance constraints
- *3* - Two fluids settling, demonstrating the Rayleigh-Taylor instability
- *4* - A single stack of solid particles
- *5* - Multiple stacks of solid particles
- *6* - A grid of solid particles falling into a cloth net
- *7* - A giant ball of fluid being fluidy, and demonstrating surface tension
- *8* - A combo scene of solid particles, cloths, ropes, and an immovable sphere
- *9* - Hair...just hair
- *0* - Empty scene
Moving around in the scene:
- *W* - Move forward
- *A* - Move left
- *S* - Move backward
- *D* - Move right
- *Mouse* - Look around
- *Left Click* - Shoot particle into scene
- *Space* - Add fluid to scene at origin (not guaranteed to maintain stability)
#### Pretty pictures
================================================
FILE: cpu/README
================================================
================================================
FILE: cpu/glm/CMakeLists.txt
================================================
set(NAME glm_dummy)
file(GLOB ROOT_SOURCE *.cpp)
file(GLOB ROOT_INLINE *.inl)
file(GLOB ROOT_HEADER *.hpp)
file(GLOB ROOT_TEXT ../*.txt)
file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp)
file(GLOB_RECURSE CORE_INLINE ./detail/*.inl)
file(GLOB_RECURSE CORE_HEADER ./detail/*.hpp)
file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp)
file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl)
file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp)
file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
source_group("Text Files" FILES ${ROOT_TEXT})
source_group("Core Files" FILES ${CORE_SOURCE})
source_group("Core Files" FILES ${CORE_INLINE})
source_group("Core Files" FILES ${CORE_HEADER})
source_group("GTC Files" FILES ${GTC_SOURCE})
source_group("GTC Files" FILES ${GTC_INLINE})
source_group("GTC Files" FILES ${GTC_HEADER})
source_group("GTX Files" FILES ${GTX_SOURCE})
source_group("GTX Files" FILES ${GTX_INLINE})
source_group("GTX Files" FILES ${GTX_HEADER})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
add_executable(${NAME} ${ROOT_TEXT}
${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER}
${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER}
${GTC_SOURCE} ${GTC_INLINE} ${GTC_HEADER}
${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER})
#add_library(glm STATIC glm.cpp)
#add_library(glm_shared SHARED glm.cpp)
================================================
FILE: cpu/glm/common.hpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/common.hpp
/// @date 2013-12-24 / 2013-12-24
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_COMMON_INCLUDED
#define GLM_COMMON_INCLUDED
#include "detail/func_common.hpp"
#endif//GLM_COMMON_INCLUDED
================================================
FILE: cpu/glm/detail/_features.hpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_features.hpp
/// @date 2013-02-20 / 2013-02-20
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_features
#define glm_core_features
// #define GLM_CXX98_EXCEPTIONS
// #define GLM_CXX98_RTTI
// #define GLM_CXX11_RVALUE_REFERENCES
// Rvalue references - GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html
// GLM_CXX11_TRAILING_RETURN
// Rvalue references for *this - GCC not supported
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm
// GLM_CXX11_NONSTATIC_MEMBER_INIT
// Initialization of class objects by rvalues - GCC any
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html
// GLM_CXX11_NONSTATIC_MEMBER_INIT
// Non-static data member initializers - GCC 4.7
// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm
// #define GLM_CXX11_VARIADIC_TEMPLATE
// Variadic templates - GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf
//
// Extending variadic template template parameters - GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
// #define GLM_CXX11_GENERALIZED_INITIALIZERS
// Initializer lists - GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
// #define GLM_CXX11_STATIC_ASSERT
// Static assertions - GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html
// #define GLM_CXX11_AUTO_TYPE
// auto-typed variables - GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf
// #define GLM_CXX11_AUTO_TYPE
// Multi-declarator auto - GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf
// #define GLM_CXX11_AUTO_TYPE
// Removal of auto as a storage-class specifier - GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm
// #define GLM_CXX11_AUTO_TYPE
// New function declarator syntax - GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm
// #define GLM_CXX11_LAMBDAS
// New wording for C++0x lambdas - GCC 4.5
// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf
// #define GLM_CXX11_DECLTYPE
// Declared type of an expression - GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf
//
// Right angle brackets - GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html
//
// Default template arguments for function templates DR226 GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226
//
// Solving the SFINAE problem for expressions DR339 GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html
// #define GLM_CXX11_ALIAS_TEMPLATE
// Template aliases N2258 GCC 4.7
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
//
// Extern templates N1987 Yes
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm
// #define GLM_CXX11_NULLPTR
// Null pointer constant N2431 GCC 4.6
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
// #define GLM_CXX11_STRONG_ENUMS
// Strongly-typed enums N2347 GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf
//
// Forward declarations for enums N2764 GCC 4.6
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf
//
// Generalized attributes N2761 GCC 4.8
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf
//
// Generalized constant expressions N2235 GCC 4.6
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
//
// Alignment support N2341 GCC 4.8
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
// #define GLM_CXX11_DELEGATING_CONSTRUCTORS
// Delegating constructors N1986 GCC 4.7
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
//
// Inheriting constructors N2540 GCC 4.8
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm
// #define GLM_CXX11_EXPLICIT_CONVERSIONS
// Explicit conversion operators N2437 GCC 4.5
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
//
// New character types N2249 GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html
//
// Unicode string literals N2442 GCC 4.5
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
//
// Raw string literals N2442 GCC 4.5
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
//
// Universal character name literals N2170 GCC 4.5
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html
// #define GLM_CXX11_USER_LITERALS
// User-defined literals N2765 GCC 4.7
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf
//
// Standard Layout Types N2342 GCC 4.5
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm
// #define GLM_CXX11_DEFAULTED_FUNCTIONS
// #define GLM_CXX11_DELETED_FUNCTIONS
// Defaulted and deleted functions N2346 GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm
//
// Extended friend declarations N1791 GCC 4.7
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
//
// Extending sizeof N2253 GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html
// #define GLM_CXX11_INLINE_NAMESPACES
// Inline namespaces N2535 GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm
// #define GLM_CXX11_UNRESTRICTED_UNIONS
// Unrestricted unions N2544 GCC 4.6
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
// #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
// Local and unnamed types as template arguments N2657 GCC 4.5
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm
// #define GLM_CXX11_RANGE_FOR
// Range-based for N2930 GCC 4.6
// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html
// #define GLM_CXX11_OVERRIDE_CONTROL
// Explicit virtual overrides N2928 N3206 N3272 GCC 4.7
// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm
//
// Minimal support for garbage collection and reachability-based leak detection N2670 No
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm
// #define GLM_CXX11_NOEXCEPT
// Allowing move constructors to throw [noexcept] N3050 GCC 4.6 (core language only)
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html
//
// Defining move special member functions N3053 GCC 4.6
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html
//
// Sequence points N2239 Yes
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
//
// Atomic operations N2427 GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
//
// Strong Compare and Exchange N2748 GCC 4.5
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
//
// Bidirectional Fences N2752 GCC 4.8
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm
//
// Memory model N2429 GCC 4.8
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm
//
// Data-dependency ordering: atomics and memory model N2664 GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm
//
// Propagating exceptions N2179 GCC 4.4
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html
//
// Abandoning a process and at_quick_exit N2440 GCC 4.8
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm
//
// Allow atomics use in signal handlers N2547 Yes
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm
//
// Thread-local storage N2659 GCC 4.8
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm
//
// Dynamic initialization and destruction with concurrency N2660 GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm
//
// __func__ predefined identifier N2340 GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm
//
// C99 preprocessor N1653 GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
//
// long long N1811 GCC 4.3
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf
//
// Extended integral types N1988 Yes
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf
#if(GLM_COMPILER & GLM_COMPILER_GCC)
# if(GLM_COMPILER >= GLM_COMPILER_GCC43)
# define GLM_CXX11_STATIC_ASSERT
# endif
#elif(GLM_COMPILER & GLM_COMPILER_CLANG)
# if(__has_feature(cxx_exceptions))
# define GLM_CXX98_EXCEPTIONS
# endif
# if(__has_feature(cxx_rtti))
# define GLM_CXX98_RTTI
# endif
# if(__has_feature(cxx_access_control_sfinae))
# define GLM_CXX11_ACCESS_CONTROL_SFINAE
# endif
# if(__has_feature(cxx_alias_templates))
# define GLM_CXX11_ALIAS_TEMPLATE
# endif
# if(__has_feature(cxx_alignas))
# define GLM_CXX11_ALIGNAS
# endif
# if(__has_feature(cxx_attributes))
# define GLM_CXX11_ATTRIBUTES
# endif
# if(__has_feature(cxx_constexpr))
# define GLM_CXX11_CONSTEXPR
# endif
# if(__has_feature(cxx_decltype))
# define GLM_CXX11_DECLTYPE
# endif
# if(__has_feature(cxx_default_function_template_args))
# define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS
# endif
# if(__has_feature(cxx_defaulted_functions))
# define GLM_CXX11_DEFAULTED_FUNCTIONS
# endif
# if(__has_feature(cxx_delegating_constructors))
# define GLM_CXX11_DELEGATING_CONSTRUCTORS
# endif
# if(__has_feature(cxx_deleted_functions))
# define GLM_CXX11_DELETED_FUNCTIONS
# endif
# if(__has_feature(cxx_explicit_conversions))
# define GLM_CXX11_EXPLICIT_CONVERSIONS
# endif
# if(__has_feature(cxx_generalized_initializers))
# define GLM_CXX11_GENERALIZED_INITIALIZERS
# endif
# if(__has_feature(cxx_implicit_moves))
# define GLM_CXX11_IMPLICIT_MOVES
# endif
# if(__has_feature(cxx_inheriting_constructors))
# define GLM_CXX11_INHERITING_CONSTRUCTORS
# endif
# if(__has_feature(cxx_inline_namespaces))
# define GLM_CXX11_INLINE_NAMESPACES
# endif
# if(__has_feature(cxx_lambdas))
# define GLM_CXX11_LAMBDAS
# endif
# if(__has_feature(cxx_local_type_template_args))
# define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
# endif
# if(__has_feature(cxx_noexcept))
# define GLM_CXX11_NOEXCEPT
# endif
# if(__has_feature(cxx_nonstatic_member_init))
# define GLM_CXX11_NONSTATIC_MEMBER_INIT
# endif
# if(__has_feature(cxx_nullptr))
# define GLM_CXX11_NULLPTR
# endif
# if(__has_feature(cxx_override_control))
# define GLM_CXX11_OVERRIDE_CONTROL
# endif
# if(__has_feature(cxx_reference_qualified_functions))
# define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS
# endif
# if(__has_feature(cxx_range_for))
# define GLM_CXX11_RANGE_FOR
# endif
# if(__has_feature(cxx_raw_string_literals))
# define GLM_CXX11_RAW_STRING_LITERALS
# endif
# if(__has_feature(cxx_rvalue_references))
# define GLM_CXX11_RVALUE_REFERENCES
# endif
# if(__has_feature(cxx_static_assert))
# define GLM_CXX11_STATIC_ASSERT
# endif
# if(__has_feature(cxx_auto_type))
# define GLM_CXX11_AUTO_TYPE
# endif
# if(__has_feature(cxx_strong_enums))
# define GLM_CXX11_STRONG_ENUMS
# endif
# if(__has_feature(cxx_trailing_return))
# define GLM_CXX11_TRAILING_RETURN
# endif
# if(__has_feature(cxx_unicode_literals))
# define GLM_CXX11_UNICODE_LITERALS
# endif
# if(__has_feature(cxx_unrestricted_unions))
# define GLM_CXX11_UNRESTRICTED_UNIONS
# endif
# if(__has_feature(cxx_user_literals))
# define GLM_CXX11_USER_LITERALS
# endif
# if(__has_feature(cxx_variadic_templates))
# define GLM_CXX11_VARIADIC_TEMPLATES
# endif
#endif//(GLM_COMPILER & GLM_COMPILER_CLANG)
#endif//glm_core_features
================================================
FILE: cpu/glm/detail/_fixes.hpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_fixes.hpp
/// @date 2011-02-21 / 2011-11-22
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#include <cmath>
//! Workaround for compatibility with other libraries
#ifdef max
#undef max
#endif
//! Workaround for compatibility with other libraries
#ifdef min
#undef min
#endif
//! Workaround for Android
#ifdef isnan
#undef isnan
#endif
//! Workaround for Android
#ifdef isinf
#undef isinf
#endif
//! Workaround for Chrone Native Client
#ifdef log2
#undef log2
#endif
================================================
FILE: cpu/glm/detail/_literals.hpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_literals.hpp
/// @date 2013-05-06 / 2013-05-06
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_literals
#define glm_core_literals
namespace glm
{
#define GLM_CXX11_USER_LITERALS
#ifdef GLM_CXX11_USER_LITERALS
/*
GLM_FUNC_QUALIFIER detail::half operator "" _h(long double const s)
{
return detail::half(s);
}
GLM_FUNC_QUALIFIER float operator "" _f(long double const s)
{
return static_cast<float>(s);
}
*/
#endif//GLM_CXX11_USER_LITERALS
}//namespace glm
#endif//glm_core_literals
================================================
FILE: cpu/glm/detail/_noise.hpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/detail/_noise.hpp
/// @date 2013-12-24 / 2013-12-24
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_DETAIL_NOISE_INCLUDED
#define GLM_DETAIL_NOISE_INCLUDED
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER T mod289(T const & x)
{
return x - floor(x * static_cast<T>(1.0) / static_cast<T>(289.0)) * static_cast<T>(289.0);
}
template <typename T>
GLM_FUNC_QUALIFIER T permute(T const & x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P> permute(tvec2<T, P> const & x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P> permute(tvec3<T, P> const & x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> permute(tvec4<T, P> const & x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}
/*
template <typename T, precision P, template<typename> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> permute(vecType<T, P> const & x)
{
return mod289(((x * T(34)) + T(1)) * x);
}
*/
template <typename T>
GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> taylorInvSqrt(detail::tvec2<T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> taylorInvSqrt(detail::tvec3<T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> taylorInvSqrt(detail::tvec4<T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
/*
template <typename T, precision P, template<typename> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> taylorInvSqrt(vecType<T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
*/
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> fade(detail::tvec2<T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> fade(detail::tvec3<T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> fade(detail::tvec4<T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
}
/*
template <typename T, precision P, template <typename> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fade(vecType<T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
}
*/
}//namespace detail
}//namespace glm
#endif//GLM_DETAIL_NOISE_INCLUDED
================================================
FILE: cpu/glm/detail/_swizzle.hpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_swizzle.hpp
/// @date 2006-04-20 / 2011-02-16
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_swizzle
#define glm_core_swizzle
namespace glm{
namespace detail
{
// Internal class for implementing swizzle operators
template <typename T, int N>
struct _swizzle_base0
{
typedef T value_type;
protected:
GLM_FUNC_QUALIFIER value_type& elem (size_t i) { return (reinterpret_cast<value_type*>(_buffer))[i]; }
GLM_FUNC_QUALIFIER const value_type& elem (size_t i) const { return (reinterpret_cast<const value_type*>(_buffer))[i]; }
// Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
// The size 1 buffer is assumed to aligned to the actual members so that the
// elem()
char _buffer[1];
};
template <typename T, precision P, typename V, int E0, int E1, int E2, int E3, int N>
struct _swizzle_base1 : public _swizzle_base0<T, N>
{
};
template <typename T, precision P, typename V, int E0, int E1>
struct _swizzle_base1<T, P, V,E0,E1,-1,-2,2> : public _swizzle_base0<T, 2>
{
GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1)); }
};
template <typename T, precision P, typename V, int E0, int E1, int E2>
struct _swizzle_base1<T, P, V,E0,E1,E2,-1,3> : public _swizzle_base0<T, 3>
{
GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); }
};
template <typename T, precision P, typename V, int E0, int E1, int E2, int E3>
struct _swizzle_base1<T, P, V,E0,E1,E2,E3,4> : public _swizzle_base0<T, 4>
{
GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
};
// Internal class for implementing swizzle operators
/*
Template parameters:
ValueType = type of scalar values (e.g. float, double)
VecType = class the swizzle is applies to (e.g. tvec3<float>)
N = number of components in the vector (e.g. 3)
E0...3 = what index the n-th element of this swizzle refers to in the unswizzled vec
DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
containing duplicate elements so that they cannot be used as r-values).
*/
template <typename ValueType, precision P, typename VecType, int N, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
struct _swizzle_base2 : public _swizzle_base1<ValueType, P, VecType,E0,E1,E2,E3,N>
{
typedef VecType vec_type;
typedef ValueType value_type;
GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t)
{
for (int i = 0; i < N; ++i)
(*this)[i] = t;
return *this;
}
GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e = t; }
};
_apply_op(that, op());
return *this;
}
GLM_FUNC_QUALIFIER void operator -= (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e -= t; }
};
_apply_op(that, op());
}
GLM_FUNC_QUALIFIER void operator += (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e += t; }
};
_apply_op(that, op());
}
GLM_FUNC_QUALIFIER void operator *= (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e *= t; }
};
_apply_op(that, op());
}
GLM_FUNC_QUALIFIER void operator /= (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e /= t; }
};
_apply_op(that, op());
}
GLM_FUNC_QUALIFIER value_type& operator[] (size_t i)
{
#ifndef __CUDA_ARCH__
static
#endif
const int offset_dst[4] = { E0, E1, E2, E3 };
return this->elem(offset_dst[i]);
}
GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const
{
#ifndef __CUDA_ARCH__
static
#endif
const int offset_dst[4] = { E0, E1, E2, E3 };
return this->elem(offset_dst[i]);
}
protected:
template <typename T>
GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op)
{
// Make a copy of the data in this == &that.
// The copier should optimize out the copy in cases where the function is
// properly inlined and the copy is not necessary.
ValueType t[N];
for (int i = 0; i < N; ++i)
t[i] = that[i];
for (int i = 0; i < N; ++i)
op( (*this)[i], t[i] );
}
};
// Specialization for swizzles containing duplicate elements. These cannot be modified.
template <typename ValueType, precision P, typename VecType, int N, int E0, int E1, int E2, int E3>
struct _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,1> : public _swizzle_base1<ValueType, P, VecType,E0,E1,E2,E3,N>
{
typedef VecType vec_type;
typedef ValueType value_type;
struct Stub {};
GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; }
GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const
{
#ifndef __CUDA_ARCH__
static
#endif
const int offset_dst[4] = { E0, E1, E2, E3 };
return this->elem(offset_dst[i]);
}
};
template <int N,typename ValueType, precision P, typename VecType, int E0,int E1,int E2,int E3>
struct _swizzle : public _swizzle_base2<ValueType, P, VecType, N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)>
{
typedef _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)> base_type;
using base_type::operator=;
GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); }
};
//
// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
//
#define _GLM_SWIZZLE_TEMPLATE1 template <int N, typename T, precision P, typename V, int E0, int E1, int E2, int E3>
#define _GLM_SWIZZLE_TEMPLATE2 template <int N, typename T, precision P, typename V, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
#define _GLM_SWIZZLE_TYPE1 _swizzle<N, T, P, V, E0, E1, E2, E3>
#define _GLM_SWIZZLE_TYPE2 _swizzle<N, T, P, V, F0, F1, F2, F3>
//
// Wrapper for a binary operator (e.g. u.yy + v.zy)
//
#define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
_GLM_SWIZZLE_TEMPLATE2 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
{ \
return a() OPERAND b(); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b) \
{ \
return a() OPERAND b; \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \
return a OPERAND b(); \
}
//
// Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
//
#define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \
{ \
return a() OPERAND b; \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \
return a OPERAND b(); \
}
//
// Macro for wrapping a function taking one argument (e.g. abs())
//
#define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a) \
{ \
return FUNCTION(a()); \
}
//
// Macro for wrapping a function taking two vector arguments (e.g. dot()).
//
#define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \
_GLM_SWIZZLE_TEMPLATE2 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
{ \
return FUNCTION(a(), b()); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \
return FUNCTION(a(), b()); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b) \
{ \
return FUNCTION(a(), b); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \
return FUNCTION(a, b()); \
}
//
// Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
//
#define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION) \
_GLM_SWIZZLE_TEMPLATE2 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c) \
{ \
return FUNCTION(a(), b(), c); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \
{ \
return FUNCTION(a(), b(), c); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
{ \
return FUNCTION(a(), b, c); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \
{ \
return FUNCTION(a, b(), c); \
}
}//namespace detail
}//namespace glm
namespace glm
{
namespace detail
{
_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
}
//
// Swizzles are distinct types from the unswizzled type. The below macros will
// provide template specializations for the swizzle types for the given functions
// so that the compiler does not have any ambiguity to choosing how to handle
// the function.
//
// The alternative is to use the operator()() when calling the function in order
// to explicitly convert the swizzled type to the unswizzled type.
//
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, abs);
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acos);
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acosh);
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, all);
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, any);
//_GLM_SWIZZLE_FUNCTION_2_ARGS(value_type, dot);
//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, cross);
//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, step);
//_GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
}
#define _GLM_SWIZZLE2_2_MEMBERS(T, P, V, E0,E1) \
struct { _swizzle<2, T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
struct { _swizzle<2, T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
struct { _swizzle<2, T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
struct { _swizzle<2, T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; };
#define _GLM_SWIZZLE2_3_MEMBERS(T, P, V, E0,E1) \
struct { _swizzle<3,T, P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
struct { _swizzle<3,T, P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
struct { _swizzle<3,T, P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
struct { _swizzle<3,T, P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
struct { _swizzle<3,T, P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
struct { _swizzle<3,T, P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
struct { _swizzle<3,T, P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
struct { _swizzle<3,T, P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; };
#define _GLM_SWIZZLE2_4_MEMBERS(T, P, V, E0,E1) \
struct { _swizzle<4,T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; };
#define _GLM_SWIZZLE3_2_MEMBERS(T, P, V, E0,E1,E2) \
struct { _swizzle<2,T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
struct { _swizzle<2,T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
struct { _swizzle<2,T, P, V<T, P>, 0,2,-1,-2> E0 ## E2; }; \
struct { _swizzle<2,T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
struct { _swizzle<2,T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; \
struct { _swizzle<2,T, P, V<T, P>, 1,2,-1,-2> E1 ## E2; }; \
struct { _swizzle<2,T, P, V<T, P>, 2,0,-1,-2> E2 ## E0; }; \
struct { _swizzle<2,T, P, V<T, P>, 2,1,-1,-2> E2 ## E1; }; \
struct { _swizzle<2,T, P, V<T, P>, 2,2,-1,-2> E2 ## E2; };
#define _GLM_SWIZZLE3_3_MEMBERS(T, P, V ,E0,E1,E2) \
struct { _swizzle<3,T,P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,0,2,-1> E0 ## E0 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,1,2,-1> E0 ## E1 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,2,0,-1> E0 ## E2 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,2,1,-1> E0 ## E2 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,2,2,-1> E0 ## E2 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,0,2,-1> E1 ## E0 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,1,2,-1> E1 ## E1 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,2,0,-1> E1 ## E2 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,2,1,-1> E1 ## E2 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,2,2,-1> E1 ## E2 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,0,0,-1> E2 ## E0 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,0,1,-1> E2 ## E0 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,0,2,-1> E2 ## E0 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,1,0,-1> E2 ## E1 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,1,1,-1> E2 ## E1 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,1,2,-1> E2 ## E1 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,2,0,-1> E2 ## E2 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,2,1,-1> E2 ## E2 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,2,2,-1> E2 ## E2 ## E2; };
#define _GLM_SWIZZLE3_4_MEMBERS(T, P, V, E0,E1,E2) \
struct { _swizzle<4,T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
struct { _swizzle<4,T, P, V<T, P>, 2,2,2,2> E2 ## E2 ## E2 ## E2; };
#define _GLM_SWIZZLE4_2_MEMBERS(T, P, V, E0,E1,E2,E3) \
struct { _swizzle<2,T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
struct { _swizzle<2,T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
struct { _swizzle<2,T, P, V<T, P>, 0,2,-1,-2> E0 ## E2; }; \
struct { _swizzle<2,T, P, V<T, P>, 0,3,-1,-2> E0 ## E3; }; \
struct { _swizzle<2,T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
struct { _swizzle<2,T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; \
struct { _swizzle<2,T, P, V<T, P>, 1,2,-1,-2> E1 ## E2; }; \
struct { _swizzle<2,T, P, V<T, P>, 1,3,-1,-2> E1 ## E3; }; \
struct { _swizzle<2,T, P, V<T, P>, 2,0,-1,-2> E2 ## E0; }; \
struct { _swizzle<2,T, P, V<T, P>, 2,1,-1,-2> E2 ## E1; }; \
struct { _swizzle<2,T, P, V<T, P>, 2,2,-1,-2> E2 ## E2; }; \
struct { _swizzle<2,T, P, V<T, P>, 2,3,-1,-2> E2 ## E3; }; \
struct { _swizzle<2,T, P, V<T, P>, 3,0,-1,-2> E3 ## E0; }; \
struct { _swizzle<2,T, P, V<T, P>, 3,1,-1,-2> E3 ## E1; }; \
struct { _swizzle<2,T, P, V<T, P>, 3,2,-1,-2> E3 ## E2; }; \
struct { _swizzle<2,T, P, V<T, P>, 3,3,-1,-2> E3 ## E3; };
#define _GLM_SWIZZLE4_3_MEMBERS(T,P, V, E0,E1,E2,E3) \
struct { _swizzle<3,T,P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,0,2,-1> E0 ## E0 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,0,3,-1> E0 ## E0 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,1,2,-1> E0 ## E1 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,1,3,-1> E0 ## E1 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,2,0,-1> E0 ## E2 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,2,1,-1> E0 ## E2 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,2,2,-1> E0 ## E2 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,2,3,-1> E0 ## E2 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,3,0,-1> E0 ## E3 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,3,1,-1> E0 ## E3 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,3,2,-1> E0 ## E3 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 0,3,3,-1> E0 ## E3 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,0,2,-1> E1 ## E0 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,0,3,-1> E1 ## E0 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,1,2,-1> E1 ## E1 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,1,3,-1> E1 ## E1 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,2,0,-1> E1 ## E2 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,2,1,-1> E1 ## E2 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,2,2,-1> E1 ## E2 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,2,3,-1> E1 ## E2 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,3,0,-1> E1 ## E3 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,3,1,-1> E1 ## E3 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,3,2,-1> E1 ## E3 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 1,3,3,-1> E1 ## E3 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,0,0,-1> E2 ## E0 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,0,1,-1> E2 ## E0 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,0,2,-1> E2 ## E0 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,0,3,-1> E2 ## E0 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,1,0,-1> E2 ## E1 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,1,1,-1> E2 ## E1 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,1,2,-1> E2 ## E1 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,1,3,-1> E2 ## E1 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,2,0,-1> E2 ## E2 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,2,1,-1> E2 ## E2 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,2,2,-1> E2 ## E2 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,2,3,-1> E2 ## E2 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,3,0,-1> E2 ## E3 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,3,1,-1> E2 ## E3 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,3,2,-1> E2 ## E3 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 2,3,3,-1> E2 ## E3 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,0,0,-1> E3 ## E0 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,0,1,-1> E3 ## E0 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,0,2,-1> E3 ## E0 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,0,3,-1> E3 ## E0 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,1,0,-1> E3 ## E1 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,1,1,-1> E3 ## E1 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,1,2,-1> E3 ## E1 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,1,3,-1> E3 ## E1 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,2,0,-1> E3 ## E2 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,2,1,-1> E3 ## E2 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,2,2,-1> E3 ## E2 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,2,3,-1> E3 ## E2 ## E3; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,3,0,-1> E3 ## E3 ## E0; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,3,1,-1> E3 ## E3 ## E1; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,3,2,-1> E3 ## E3 ## E2; }; \
struct { _swizzle<3,T,P, V<T, P>, 3,3,3,-1> E3 ## E3 ## E3; };
#define _GLM_SWIZZLE4_4_MEMBERS(T, P, V, E0,E1,E2,E3) \
struct { _swizzle<4, T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
#endif//glm_core_swizzle
================================================
FILE: cpu/glm/detail/_swizzle_func.hpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_swizzle_func.hpp
/// @date 2011-10-16 / 2011-10-16
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_swizzle_func
#define glm_core_swizzle_func
#define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B); \
}
#define GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C); \
}
#define GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C ## D() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D); \
}
#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
template <typename TMPL_TYPE> \
SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B); \
}
#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
template <typename TMPL_TYPE> \
SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C); \
}
#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
template <typename TMPL_TYPE> \
SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C ## D() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D); \
}
#define GLM_MUTABLE
#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, x, y) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, r, g) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, s, t)
//GLM_SWIZZLE_GEN_REF_FROM_VEC2(valType, detail::vec2, detail::ref2)
#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B)
#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B, A)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE) \
GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, x, y, z) \
GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, r, g, b) \
GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, s, t, p)
//GLM_SWIZZLE_GEN_REF_FROM_VEC3(valType, detail::vec3, detail::ref2, detail::ref3)
#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, C)
#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B)
#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C, A)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
//GLM_SWIZZLE_GEN_REF_FROM_VEC4(valType, detail::vec4, detail::ref2, detail::ref3, detail::ref4)
#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B)
#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B)
#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t)
//GLM_SWIZZLE_GEN_VEC_FROM_VEC2(valType, detail::vec2, detail::vec2, detail::vec3, detail::vec4)
#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C)
#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C)
#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p)
//GLM_SWIZZLE_GEN_VEC_FROM_VEC3(valType, detail::vec3, detail::vec2, detail::vec3, detail::vec4)
#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D)
#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D)
#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, D)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
//GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)
#endif//glm_core_swizzle_func
================================================
FILE: cpu/glm/detail/_vectorize.hpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_vectorize.hpp
/// @date 2011-10-14 / 2011-10-14
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_CORE_DETAIL_INCLUDED
#define GLM_CORE_DETAIL_INCLUDED
#include "type_vec1.hpp"
#include "type_vec2.hpp"
#include "type_vec3.hpp"
#include "type_vec4.hpp"
#define VECTORIZE1_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec1<T, P> func( \
detail::tvec1<T, P> const & v) \
{ \
return detail::tvec1<T, P>( \
func(v.x)); \
}
#define VECTORIZE2_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec2<T, P> func( \
detail::tvec2<T, P> const & v) \
{ \
return detail::tvec2<T, P>( \
func(v.x), \
func(v.y)); \
}
#define VECTORIZE3_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec3<T, P> func( \
detail::tvec3<T, P> const & v) \
{ \
return detail::tvec3<T, P>( \
func(v.x), \
func(v.y), \
func(v.z)); \
}
#define VECTORIZE4_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec4<T, P> func( \
detail::tvec4<T, P> const & v) \
{ \
return detail::tvec4<T, P>( \
func(v.x), \
func(v.y), \
func(v.z), \
func(v.w)); \
}
#define VECTORIZE_VEC(func) \
VECTORIZE1_VEC(func) \
VECTORIZE2_VEC(func) \
VECTORIZE3_VEC(func) \
VECTORIZE4_VEC(func)
#define VECTORIZE1_VEC_SCA(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec1<T, P> func \
( \
detail::tvec1<T, P> const & x, \
T const & y \
) \
{ \
return detail::tvec1<T, P>( \
func(x.x, y)); \
}
#define VECTORIZE2_VEC_SCA(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec2<T, P> func \
( \
detail::tvec2<T, P> const & x, \
T const & y \
) \
{ \
return detail::tvec2<T, P>( \
func(x.x, y), \
func(x.y, y)); \
}
#define VECTORIZE3_VEC_SCA(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec3<T, P> func \
( \
detail::tvec3<T, P> const & x, \
T const & y \
) \
{ \
return detail::tvec3<T, P>( \
func(x.x, y), \
func(x.y, y), \
func(x.z, y)); \
}
#define VECTORIZE4_VEC_SCA(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec4<T, P> func \
( \
detail::tvec4<T, P> const & x, \
T const & y \
) \
{ \
return detail::tvec4<T, P>( \
func(x.x, y), \
func(x.y, y), \
func(x.z, y), \
func(x.w, y)); \
}
#define VECTORIZE_VEC_SCA(func) \
VECTORIZE1_VEC_SCA(func) \
VECTORIZE2_VEC_SCA(func) \
VECTORIZE3_VEC_SCA(func) \
VECTORIZE4_VEC_SCA(func)
#define VECTORIZE2_VEC_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec2<T, P> func \
( \
detail::tvec2<T, P> const & x, \
detail::tvec2<T, P> const & y \
) \
{ \
return detail::tvec2<T, P>( \
func(x.x, y.x), \
func(x.y, y.y)); \
}
#define VECTORIZE3_VEC_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec3<T, P> func \
( \
detail::tvec3<T, P> const & x, \
detail::tvec3<T, P> const & y \
) \
{ \
return detail::tvec3<T, P>( \
func(x.x, y.x), \
func(x.y, y.y), \
func(x.z, y.z)); \
}
#define VECTORIZE4_VEC_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec4<T, P> func \
( \
detail::tvec4<T, P> const & x, \
detail::tvec4<T, P> const & y \
) \
{ \
return detail::tvec4<T, P>( \
func(x.x, y.x), \
func(x.y, y.y), \
func(x.z, y.z), \
func(x.w, y.w)); \
}
#define VECTORIZE_VEC_VEC(func) \
VECTORIZE2_VEC_VEC(func) \
VECTORIZE3_VEC_VEC(func) \
VECTORIZE4_VEC_VEC(func)
namespace glm{
namespace detail
{
template<bool C>
struct If
{
template<typename F, typename T>
static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
{
return functor(val);
}
};
template<>
struct If<false>
{
template<typename F, typename T>
static GLM_FUNC_QUALIFIER T apply(F, const T& val)
{
return val;
}
};
}//namespace detail
}//namespace glm
#endif//GLM_CORE_DETAIL_INCLUDED
================================================
FILE: cpu/glm/detail/dummy.cpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/dummy.cpp
/// @date 2011-01-19 / 2011-06-15
/// @author Christophe Riccio
///
/// GLM is a header only library. There is nothing to compile.
/// dummy.cpp exist only a wordaround for CMake file.
///////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#define GLM_MESSAGES
#include "../glm.hpp"
#include <limits>
/*
#if(GLM_ARCH & GLM_ARCH_SSE2)
struct float4
{
union
{
struct {float r, g, b, a;};
struct {float s, t, p, q;};
struct {float x, y, z, w;};
__m128 data;
};
};
int test_simd()
{
float4 f;
return 0;
}
#endif//GLM_ARCH
*/
template <class T = int>
class C;
template <class T>
class C
{
public:
T value;
};
int main()
{
/*
# if(GLM_ARCH & GLM_ARCH_SSE2)
test_simd();
# endif
*/
C<> c;
return 0;
}
================================================
FILE: cpu/glm/detail/func_common.hpp
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_common.hpp
/// @date 2008-03-08 / 2010-01-26
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
///
/// @defgroup core_func_common Common functions
/// @ingroup core
///
/// These all operate component-wise. The description is per component.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_FUNC_COMMON_INCLUDED
#define GLM_FUNC_COMMON_INCLUDED
#include "setup.hpp"
#include "precision.hpp"
#include "type_int.hpp"
#include "_fixes.hpp"
namespace glm
{
/// @addtogroup core_func_common
/// @{
/// Returns x if x >= 0; otherwise, it returns -x.
///
/// @tparam genType floating-point or signed integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType abs(genType const & x);
/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
///
/// @tparam genType Floating-point or signed integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType sign(genType const & x);
/// Returns a value equal to the nearest integer that is less then or equal to x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType floor(genType const & x);
/// Returns a value equal to the nearest integer to x
/// whose absolute value is not larger than the absolute value of x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType trunc(genType const & x);
/// Returns a value equal to the nearest integer to x.
/// The fraction 0.5 will round in a direction chosen by the
/// implementation, presumably the direction that is fastest.
/// This includes the possibility that round(x) returns the
/// same value as roundEven(x) for all values of x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType round(genType const & x);
/// Returns a value equal to the nearest integer to x.
/// A fractional part of 0.5 will round toward the nearest even
/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
template <typename genType>
GLM_FUNC_DECL genType roundEven(genType const & x);
/// Returns a value equal to the nearest integer
/// that is greater than or equal to x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType ceil(genType const & x);
/// Return x - floor(x).
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType fract(genType const & x);
/// Modulus. Returns x - y * floor(x / y)
/// for each component in x using the floating point value y.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType mod(
genType const & x,
genType const & y);
/// Modulus. Returns x - y * floor(x / y)
/// for each component in x using the floating point value y.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType mod(
genType const & x,
typename genType::value_type const & y);
/// Returns the fractional part of x and sets i to the integer
/// part (as a whole number floating point value). Both the
/// return value and the output parameter will have the same
/// sign as x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType modf(
genType const & x,
genType & i);
/// Returns y if y < x; otherwise, it returns x.
///
/// @tparam genType Floating-point or integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a><<<<<<< HEAD
template <typename genType>
GLM_FUNC_DECL genType min(
genType const & x,
genType const & y);
template <typename genType>
GLM_FUNC_DECL genType min(
genType const & x,
typename genType::value_type const & y);
/// Returns y if x < y; otherwise, it returns x.
///
/// @tparam genType Floating-point or integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType max(
genType const & x,
genType const & y);
template <typename genType>
GLM_FUNC_DECL genType max(
genType const & x,
typename genType::value_type const & y);
/// Returns min(max(x, minVal), maxVal) for each component in x
/// using the floating-point values minVal and maxVal.
///
/// @tparam genType Floating-point or integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType clamp(
genType const & x,
genType const & minVal,
genType const & maxVal);
template <typename genType, precision P>
GLM_FUNC_DECL genType clamp(
genType const & x,
typename genType::value_type const & minVal,
typename genType::value_type const & maxVal);
/// If genTypeU is a floating scalar or vector:
/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
/// x and y using the floating-point value a.
/// The value for a is not restricted to the range [0, 1].
///
/// If genTypeU is a boolean scalar or vector:
/// Selects which vector each returned component comes
/// from. For a component of <a> that is false, the
/// corresponding component of x is returned. For a
/// component of a that is true, the corresponding
/// component of y is returned. Components of x and y that
/// are not selected are allowed to be invalid floating point
/// values and will have no effect on the results. Thus, this
/// provides different functionality than
/// genType mix(genType x, genType y, genType(a))
/// where a is a Boolean vector.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mix.xml">GLSL mix man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
///
/// @param[in] x Value to interpolate.
/// @param[in] y Value to interpolate.
/// @param[in] a Interpolant.
///
/// @tparam genTypeT Floating point scalar or vector.
/// @tparam genTypeU Floating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT.
///
/// @code
/// #include <glm/glm.hpp>
/// ...
/// float a;
/// bool b;
/// glm::dvec3 e;
/// glm::dvec3 f;
/// glm::vec4 g;
/// glm::vec4 h;
/// ...
/// glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors.
/// glm::vec4 s = glm::mix(g, h, b); // Teturns g or h;
/// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
/// @endcode
template <typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> mix(
vecType<T, P> const & x,
vecType<T, P> const & y,
vecType<U, P> const & a);
template <typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> mix(
vecType<T, P> const & x,
vecType<T, P> const & y,
U const & a);
template <typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeT mix(
genTypeT const & x,
genTypeT const & y,
genTypeU const & a);
/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType step(
genType const & edge,
genType const & x);
/// Returns 0.0 if x < edge, otherwise it returns 1.0.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <template <typename, precision> class vecType, typename T, precision P>
GLM_FUNC_DECL vecType<T, P> step(
T const & edge,
vecType<T, P> const & x);
/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
/// performs smooth Hermite interpolation between 0 and 1
/// when edge0 < x < edge1. This is useful in cases where
/// you would want a threshold function with a smooth
/// transition. This is equivalent to:
/// genType t;
/// t = clamp ((x - edge0) / (edge1 - edge0), 0, 1);
/// return t * t * (3 - 2 * t);
/// Results are undefined if edge0 >= edge1.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType smoothstep(
genType const & edge0,
genType const & edge1,
genType const & x);
template <typename genType>
GLM_FUNC_DECL genType smoothstep(
typename genType::value_type const & edge0,
typename genType::value_type const & edge1,
genType const & x);
/// Returns true if x holds a NaN (not a number)
/// representation in the underlying implementation's set of
/// floating point representations. Returns false otherwise,
/// including for implementations with no NaN
/// representations.
///
/// /!\ When using compiler fast math, this function may fail.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
/// Returns true if x holds a positive infinity or negative
/// infinity representation in the underlying implementation's
/// set of floating point representations. Returns false
/// otherwise, including for implementations with no infinity
/// representations.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
/// Returns a signed integer value representing
/// the encoding of a floating-point value. The floating-point
/// value's bit-level representation is preserved.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
GLM_FUNC_DECL int floatBitsToInt(float const & v);
/// Returns a signed integer value representing
/// the encoding of a floating-point value. The floatingpoint
/// value's bit-level representation is preserved.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <template <typename, precision> class vecType, precision P>
GLM_FUNC_DECL vecType<int, P> floatBitsToInt(vecType<float, P> const & v);
/// Returns a unsigned integer value representing
/// the encoding of a floating-point value. The floatingpoint
/// value's bit-level representation is preserved.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
GLM_FUNC_DECL uint floatBitsToUint(float const & v);
/// Returns a unsigned integer value representing
/// the encoding of a floating-point value. The floatingpoint
/// value's bit-level representation is preserved.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <template <typename, precision> class vecType, precision P>
GLM_FUNC_DECL vecType<uint, P> floatBitsToUint(vecType<float, P> const & v);
/// Returns a floating-point value corresponding to a signed
/// integer encoding of a floating-point value.
/// If an inf or NaN is passed in, it will not signal, and the
/// resulting floating point value is unspecified. Otherwise,
/// the bit-level representation is preserved.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
GLM_FUNC_DECL float intBitsToFloat(int const & v);
/// Returns a floating-point value corresponding to a signed
/// integer encoding of a floating-point value.
/// If an inf or NaN is passed in, it will not signal, and the
/// resulting floating point value is unspecified. Otherwise,
/// the bit-level representation is preserved.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <template <typename, precision> class vecType, precision P>
GLM_FUNC_DECL vecType<float, P> intBitsToFloat(vecType<int, P> const & v);
/// Returns a floating-point value corresponding to a
/// unsigned integer encoding of a floating-point value.
/// If an inf or NaN is passed in, it will not signal, and the
/// resulting floating point value is unspecified. Otherwise,
/// the bit-level representation is preserved.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
GLM_FUNC_DECL float uintBitsToFloat(uint const & v);
/// Returns a floating-point value corresponding to a
/// unsigned integer encoding of a floating-point value.
/// If an inf or NaN is passed in, it will not signal, and the
/// resulting floating point value is unspecified. Otherwise,
/// the bit-level representation is preserved.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <template <typename, precision> class vecType, precision P>
GLM_FUNC_DECL vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v);
/// Computes and returns a * b + c.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
/// Splits x into a floating-point significand in the range
/// [0.5, 1.0) and an integral exponent of two, such that:
/// x = significand * exp(2, exponent)
///
/// The significand is returned by the function and the
/// exponent is returned in the parameter exp. For a
/// floating-point value of zero, the significant and exponent
/// are both zero. For a floating-point value that is an
/// infinity or is not a number, the results are undefined.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genIType>
GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
/// Builds a floating-point number from x and the
/// corresponding integral exponent of two in exp, returning:
/// significand * exp(2, exponent)
///
/// If this product is too large to be represented in the
/// floating-point type, the result is undefined.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>;
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genIType>
GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
/// @}
}//namespace glm
#include "func_common.inl"
#endif//GLM_FUNC_COMMON_INCLUDED
================================================
FILE: cpu/glm/detail/func_common.inl
================================================
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_common.inl
/// @date 2008-08-03 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#include "func_vector_relational.hpp"
#include "type_vec2.hpp"
#include "type_vec3.hpp"
#include "type_vec4.hpp"
#include "_vectorize.hpp"
#include <limits>
namespace glm{
namespace detail
{
template <typename genFIType, bool /*signed*/>
struct compute_abs
{};
template <typename genFIType>
struct compute_abs<genFIType, true>
{
GLM_FUNC_QUALIFIER static genFIType call(genFIType const & x)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed,
"'abs' only accept floating-point and integer scalar or vector inputs");
return x >= genFIType(0) ? x : -x;
// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
}
};
template <typename genFIType>
struct compute_abs<genFIType, false>
{
GLM_FUNC_QUALIFIER static genFIType call(genFIType const & x)
{
GLM_STATIC_ASSERT(
!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer,
"'abs' only accept floating-point and integer scalar or vector inputs");
return x;
}
};
template <typename T, typename U, precision P, template <class, precision> class vecType>
struct compute_mix_vector
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
{
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
}
};
template <typename T, precision P, template <class, precision> class vecType>
struct compute_mix_vector<T, bool, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<bool, P> const & a)
{
vecType<T, P> Result;
for(length_t i = 0; i < x.length(); ++i)
Result[i] = a[i] ? y[i] : x[i];
return Result;
}
};
template <typename T, typename U, precision P, template <class, precision> class vecType>
struct compute_mix_scalar
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, U const & a)
{
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
}
};
template <typename T, precision P, template <class, precision> class vecType>
struct compute_mix_scalar<T, bool, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, bool const & a)
{
return a ? y : x;
}
};
template <typename T, typename U>
struct compute_mix
{
GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, U const & a)
{
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
return static_cast<T>(static_cast<U>(x) + a * static_cast<U>(y - x));
}
};
template <typename T>
struct compute_mix<T, bool>
{
GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, bool const & a)
{
return a ? y : x;
}
};
}//namespace detail
// abs
template <typename genFIType>
GLM_FUNC_QUALIFIER genFIType abs
(
genFIType const & x
)
{
return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
}
VECTORIZE_VEC(abs)
// sign
//Try something like based on x >> 31 to get the sign bit
template <typename genFIType>
GLM_FUNC_QUALIFIER genFIType sign
(
genFIType const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genFIType>::is_iec559 ||
(std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer), "'sign' only accept signed inputs");
genFIType result;
if(x > genFIType(0))
result = genFIType(1);
else if(x < genFIType(0))
result = genFIType(-1);
else
result = genFIType(0);
return result;
}
VECTORIZE_VEC(sign)
// floor
template <typename genType>
GLM_FUNC_QUALIFIER genType floor(genType const & x)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'floor' only accept floating-point inputs");
return ::std::floor(x);
}
VECTORIZE_VEC(floor)
// trunc
template <typename genType>
GLM_FUNC_QUALIFIER genType trunc(genType const & x)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'trunc' only accept floating-point inputs");
// TODO, add C++11 std::trunk
return x < 0 ? -floor(-x) : floor(x);
}
VECTORIZE_VEC(trunc)
// round
template <typename genType>
GLM_FUNC_QUALIFIER genType round(genType const& x)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'round' only accept floating-point inputs");
// TODO, add C++11 std::round
return x < 0 ? genType(int(x - genType(0.5))) : genType(int(x + genType(0.5)));
}
VECTORIZE_VEC(round)
/*
// roundEven
template <typename genType>
GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
return genType(int(x + genType(int(x) % 2)));
}
*/
// roundEven
template <typename genType>
GLM_FUNC_QUALIFIER genType roundEven(genType const & x)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'roundEven' only accept floating-point inputs");
int Integer = static_cast<int>(x);
genType IntegerPart = static_cast<genType>(Integer);
genType FractionalPart = fract(x);
if(FractionalPart > static_cast<genType>(0.5) || FractionalPart < static_cast<genType>(0.5))
{
return round(x);
}
else if((Integer % 2) == 0)
{
return IntegerPart;
}
else if(x <= static_cast<genType>(0)) // Work around...
{
return IntegerPart - static_cast<genType>(1);
}
else
{
return IntegerPart + static_cast<genType>(1);
}
//else // Bug on MinGW 4.5.2
//{
// return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0));
//}
}
VECTORIZE_VEC(roundEven)
// ceil
template <typename genType>
GLM_FUNC_QUALIFIER genType ceil(genType const & x)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'ceil' only accept floating-point inputs");
return ::std::ceil(x);
}
VECTORIZE_VEC(ceil)
// fract
template <typename genType>
GLM_FUNC_QUALIFIER genType fract
(
genType const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'fract' only accept floating-point inputs");
return x - floor(x);
}
VECTORIZE_VEC(fract)
// mod
template <typename genType>
GLM_FUNC_QUALIFIER genType mod
(
genType const & x,
genType const & y
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'mod' only accept floating-point inputs");
return x - y * floor(x / y);
}
VECTORIZE_VEC_SCA(mod)
VECTORIZE_VEC_VEC(mod)
// modf
template <typename genType>
GLM_FUNC_QUALIFIER genType modf
(
genType const & x,
genType & i
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'modf' only accept floating-point inputs");
return std::modf(x, &i);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> modf
(
detail::tvec2<T, P> const & x,
detail::tvec2<T, P> & i
)
{
return detail::tvec2<T, P>(
modf(x.x, i.x),
modf(x.y, i.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> modf
(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> & i
)
{
return detail::tvec3<T, P>(
modf(x.x, i.x),
modf(x.y, i.y),
modf(x.z, i.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> modf
(
detail::tvec4<T, P> const & x,
detail::tvec4<T, P> & i
)
{
return detail::tvec4<T, P>(
modf(x.x, i.x),
modf(x.y, i.y),
modf(x.z, i.z),
modf(x.w, i.w));
}
//// Only valid if (INT_MIN <= x-y <= INT_MAX)
//// min(x,y)
//r = y + ((x - y) & ((x - y) >> (sizeof(int) *
//CHAR_BIT - 1)));
//// max(x,y)
//r = x - ((x - y) & ((x - y) >> (sizeof(int) *
//CHAR_BIT - 1)));
// min
template <typename genType>
GLM_FUNC_QUALIFIER genType min
(
genType const & x,
genType const & y
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer,
"'min' only accept floating-point or integer inputs");
return x < y ? x : y;
}
VECTORIZE_VEC_SCA(min)
VECTORIZE_VEC_VEC(min)
// max
template <typename genType>
GLM_FUNC_QUALIFIER genType max
(
genType const & x,
genType const & y
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer,
"'max' only accept floating-point or integer inputs");
return x > y ? x : y;
}
VECTORIZE_VEC_SCA(max)
VECTORIZE_VEC_VEC(max)
// clamp
template <typename genType>
GLM_FUNC_QUALIFIER genType clamp
(
genType const & x,
genType const & minVal,
genType const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return min(maxVal, max(minVal, x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> clamp
(
detail::tvec2<T, P> const & x,
T const & minVal,
T const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec2<T, P>(
clamp(x.x, minVal, maxVal),
clamp(x.y, minVal, maxVal));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> clamp
(
detail::tvec3<T, P> const & x,
T const & minVal,
T const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec3<T, P>(
clamp(x.x, minVal, maxVal),
clamp(x.y, minVal, maxVal),
clamp(x.z, minVal, maxVal));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> clamp
(
detail::tvec4<T, P> const & x,
T const & minVal,
T const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec4<T, P>(
clamp(x.x, minVal, maxVal),
clamp(x.y, minVal, maxVal),
clamp(x.z, minVal, maxVal),
clamp(x.w, minVal, maxVal));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> clamp
(
detail::tvec2<T, P> const & x,
detail::tvec2<T, P> const & minVal,
detail::tvec2<T, P> const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec2<T, P>(
clamp(x.x, minVal.x, maxVal.x),
clamp(x.y, minVal.y, maxVal.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> clamp
(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & minVal,
detail::tvec3<T, P> const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec3<T, P>(
clamp(x.x, minVal.x, maxVal.x),
clamp(x.y, minVal.y, maxVal.y),
clamp(x.z, minVal.z, maxVal.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> clamp
(
detail::tvec4<T, P> const & x,
detail::tvec4<T, P> const & minVal,
detail::tvec4<T, P> const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec4<T, P>(
clamp(x.x, minVal.x, maxVal.x),
clamp(x.y, minVal.y, maxVal.y),
clamp(x.z, minVal.z, maxVal.z),
clamp(x.w, minVal.w, maxVal.w));
}
template <typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> mix
(
vecType<T, P> const & x,
vecType<T, P> const & y,
vecType<U, P> const & a
)
{
return detail::compute_mix_vector<T, U, P, vecType>::call(x, y, a);
}
template <typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> mix
(
vecType<T, P> const & x,
vecType<T, P> const & y,
U const & a
)
{
return detail::compute_mix_scalar<T, U, P, vecType>::call(x, y, a);
}
template <typename genTypeT, typename genTypeU>
GLM_FUNC_QUALIFIER genTypeT mix
(
genTypeT const & x,
genTypeT const & y,
genTypeU const & a
)
{
return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a);
}
// step
template <typename genType>
GLM_FUNC_QUALIFIER genType step
(
genType const & edge,
genType const & x
)
{
return mix(genType(1), genType(0), glm::lessThan(x, edge));
}
template <template <typename, precision> class vecType, typename T, precision P>
GLM_FUNC_QUALIFIER vecType<T, P> step
(
T const & edge,
vecType<T, P> const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559,
"'step' only accept floating-point inputs");
return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, vecType<T, P>(edge)));
}
// smoothstep
template <typename genType>
GLM_FUNC_QUALIFIER genType smoothstep
(
genType const & edge0,
genType const & edge1,
genType const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'smoothstep' only accept floating-point inputs");
genType tmp = clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1));
return tmp * tmp * (genType(3) - genType(2) * tmp);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> smoothstep
(
T const & edge0,
T const & edge1,
detail::tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec2<T, P>(
smoothstep(edge0, edge1, x.x),
smoothstep(edge0, edge1, x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> smoothstep
(
T const & edge0,
T const & edge1,
detail::tvec3<T, P> const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec3<T, P>(
smoothstep(edge0, edge1, x.x),
smoothstep(edge0, edge1, x.y),
smoothstep(edge0, edge1, x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> smoothstep
(
T const & edge0,
T const & edge1,
detail::tvec4<T, P> const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec4<T, P>(
smoothstep(edge0, edge1, x.x),
smoothstep(edge0, edge1, x.y),
smoothstep(edge0, edge1, x.z),
smoothstep(edge0, edge1, x.w));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> smoothstep
(
detail::tvec2<T, P> const & edge0,
detail::tvec2<T, P> const & edge1,
detail::tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec2<T, P>(
smoothstep(edge0.x, edge1.x, x.x),
smoothstep(edge0.y, edge1.y, x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> smoothstep
(
detail::tvec3<T, P> const & edge0,
detail::tvec3<T, P> const & edge1,
detail::tvec3<T, P> const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec3<T, P>(
smoothstep(edge0.x, edge1.x, x.x),
smoothstep(edge0.y, edge1.y, x.y),
smoothstep(edge0.z, edge1.z, x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> smoothstep
(
detail::tvec4<T, P> const & edge0,
detail::tvec4<T, P> const & edge1,
detail::tvec4<T, P> const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec4<T, P>(
smoothstep(edge0.x, edge1.x, x.x),
smoothstep(edge0.y, edge1.y, x.y),
smoothstep(edge0.z, edge1.z, x.z),
smoothstep(edge0.w, edge1.w, x.w));
}
// TODO: Not working on MinGW...
template <typename genType>
GLM_FUNC_QUALIFIER bool isnan(genType const & x)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genType>::is_iec559,
"'isnan' only accept floating-point inputs");
# if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_INTEL))
return _isnan(x) != 0;
# elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG))
# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
return _isnan(x) != 0;
# else
return std::isnan(x);
# endif
# elif(GLM_COMPILER & GLM_COMPILER_CUDA)
return isnan(x) != 0;
# else
return std::isnan(x);
# endif
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isnan
(
detail::tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559,
"'isnan' only accept floating-point inputs");
return typename detail::tvec2<T, P>::bool_type(
isnan(x.x),
isnan(x.y));
}
template <typename T, precisi
gitextract_vkj5l6cr/
├── .gitignore
├── LICENSE
├── README.md
├── cpu/
│ ├── README
│ ├── glm/
│ │ ├── CMakeLists.txt
│ │ ├── common.hpp
│ │ ├── detail/
│ │ │ ├── _features.hpp
│ │ │ ├── _fixes.hpp
│ │ │ ├── _literals.hpp
│ │ │ ├── _noise.hpp
│ │ │ ├── _swizzle.hpp
│ │ │ ├── _swizzle_func.hpp
│ │ │ ├── _vectorize.hpp
│ │ │ ├── dummy.cpp
│ │ │ ├── func_common.hpp
│ │ │ ├── func_common.inl
│ │ │ ├── func_exponential.hpp
│ │ │ ├── func_exponential.inl
│ │ │ ├── func_geometric.hpp
│ │ │ ├── func_geometric.inl
│ │ │ ├── func_integer.hpp
│ │ │ ├── func_integer.inl
│ │ │ ├── func_matrix.hpp
│ │ │ ├── func_matrix.inl
│ │ │ ├── func_noise.hpp
│ │ │ ├── func_noise.inl
│ │ │ ├── func_packing.hpp
│ │ │ ├── func_packing.inl
│ │ │ ├── func_trigonometric.hpp
│ │ │ ├── func_trigonometric.inl
│ │ │ ├── func_vector_relational.hpp
│ │ │ ├── func_vector_relational.inl
│ │ │ ├── glm.cpp
│ │ │ ├── hint.hpp
│ │ │ ├── intrinsic_common.hpp
│ │ │ ├── intrinsic_common.inl
│ │ │ ├── intrinsic_exponential.hpp
│ │ │ ├── intrinsic_exponential.inl
│ │ │ ├── intrinsic_geometric.hpp
│ │ │ ├── intrinsic_geometric.inl
│ │ │ ├── intrinsic_integer.hpp
│ │ │ ├── intrinsic_integer.inl
│ │ │ ├── intrinsic_matrix.hpp
│ │ │ ├── intrinsic_matrix.inl
│ │ │ ├── intrinsic_trigonometric.hpp
│ │ │ ├── intrinsic_trigonometric.inl
│ │ │ ├── intrinsic_vector_relational.hpp
│ │ │ ├── intrinsic_vector_relational.inl
│ │ │ ├── precision.hpp
│ │ │ ├── precision.inl
│ │ │ ├── setup.hpp
│ │ │ ├── type_float.hpp
│ │ │ ├── type_gentype.hpp
│ │ │ ├── type_gentype.inl
│ │ │ ├── type_half.hpp
│ │ │ ├── type_half.inl
│ │ │ ├── type_int.hpp
│ │ │ ├── type_mat.hpp
│ │ │ ├── type_mat.inl
│ │ │ ├── type_mat2x2.hpp
│ │ │ ├── type_mat2x2.inl
│ │ │ ├── type_mat2x3.hpp
│ │ │ ├── type_mat2x3.inl
│ │ │ ├── type_mat2x4.hpp
│ │ │ ├── type_mat2x4.inl
│ │ │ ├── type_mat3x2.hpp
│ │ │ ├── type_mat3x2.inl
│ │ │ ├── type_mat3x3.hpp
│ │ │ ├── type_mat3x3.inl
│ │ │ ├── type_mat3x4.hpp
│ │ │ ├── type_mat3x4.inl
│ │ │ ├── type_mat4x2.hpp
│ │ │ ├── type_mat4x2.inl
│ │ │ ├── type_mat4x3.hpp
│ │ │ ├── type_mat4x3.inl
│ │ │ ├── type_mat4x4.hpp
│ │ │ ├── type_mat4x4.inl
│ │ │ ├── type_vec.hpp
│ │ │ ├── type_vec.inl
│ │ │ ├── type_vec1.hpp
│ │ │ ├── type_vec1.inl
│ │ │ ├── type_vec2.hpp
│ │ │ ├── type_vec2.inl
│ │ │ ├── type_vec3.hpp
│ │ │ ├── type_vec3.inl
│ │ │ ├── type_vec4.hpp
│ │ │ └── type_vec4.inl
│ │ ├── exponential.hpp
│ │ ├── ext.hpp
│ │ ├── fwd.hpp
│ │ ├── geometric.hpp
│ │ ├── glm.hpp
│ │ ├── gtc/
│ │ │ ├── constants.hpp
│ │ │ ├── constants.inl
│ │ │ ├── epsilon.hpp
│ │ │ ├── epsilon.inl
│ │ │ ├── matrix_access.hpp
│ │ │ ├── matrix_access.inl
│ │ │ ├── matrix_integer.hpp
│ │ │ ├── matrix_inverse.hpp
│ │ │ ├── matrix_inverse.inl
│ │ │ ├── matrix_transform.hpp
│ │ │ ├── matrix_transform.inl
│ │ │ ├── noise.hpp
│ │ │ ├── noise.inl
│ │ │ ├── packing.hpp
│ │ │ ├── packing.inl
│ │ │ ├── quaternion.hpp
│ │ │ ├── quaternion.inl
│ │ │ ├── random.hpp
│ │ │ ├── random.inl
│ │ │ ├── reciprocal.hpp
│ │ │ ├── reciprocal.inl
│ │ │ ├── type_precision.hpp
│ │ │ ├── type_precision.inl
│ │ │ ├── type_ptr.hpp
│ │ │ ├── type_ptr.inl
│ │ │ ├── ulp.hpp
│ │ │ └── ulp.inl
│ │ ├── gtx/
│ │ │ ├── associated_min_max.hpp
│ │ │ ├── associated_min_max.inl
│ │ │ ├── bit.hpp
│ │ │ ├── bit.inl
│ │ │ ├── closest_point.hpp
│ │ │ ├── closest_point.inl
│ │ │ ├── color_space.hpp
│ │ │ ├── color_space.inl
│ │ │ ├── color_space_YCoCg.hpp
│ │ │ ├── color_space_YCoCg.inl
│ │ │ ├── compatibility.hpp
│ │ │ ├── compatibility.inl
│ │ │ ├── component_wise.hpp
│ │ │ ├── component_wise.inl
│ │ │ ├── constants.hpp
│ │ │ ├── dual_quaternion.hpp
│ │ │ ├── dual_quaternion.inl
│ │ │ ├── epsilon.hpp
│ │ │ ├── euler_angles.hpp
│ │ │ ├── euler_angles.inl
│ │ │ ├── extend.hpp
│ │ │ ├── extend.inl
│ │ │ ├── extented_min_max.hpp
│ │ │ ├── extented_min_max.inl
│ │ │ ├── fast_exponential.hpp
│ │ │ ├── fast_exponential.inl
│ │ │ ├── fast_square_root.hpp
│ │ │ ├── fast_square_root.inl
│ │ │ ├── fast_trigonometry.hpp
│ │ │ ├── fast_trigonometry.inl
│ │ │ ├── gradient_paint.hpp
│ │ │ ├── gradient_paint.inl
│ │ │ ├── handed_coordinate_space.hpp
│ │ │ ├── handed_coordinate_space.inl
│ │ │ ├── inertia.hpp
│ │ │ ├── inertia.inl
│ │ │ ├── int_10_10_10_2.hpp
│ │ │ ├── int_10_10_10_2.inl
│ │ │ ├── integer.hpp
│ │ │ ├── integer.inl
│ │ │ ├── intersect.hpp
│ │ │ ├── intersect.inl
│ │ │ ├── io.hpp
│ │ │ ├── io.inl
│ │ │ ├── log_base.hpp
│ │ │ ├── log_base.inl
│ │ │ ├── matrix_cross_product.hpp
│ │ │ ├── matrix_cross_product.inl
│ │ │ ├── matrix_interpolation.hpp
│ │ │ ├── matrix_interpolation.inl
│ │ │ ├── matrix_major_storage.hpp
│ │ │ ├── matrix_major_storage.inl
│ │ │ ├── matrix_operation.hpp
│ │ │ ├── matrix_operation.inl
│ │ │ ├── matrix_query.hpp
│ │ │ ├── matrix_query.inl
│ │ │ ├── mixed_product.hpp
│ │ │ ├── mixed_product.inl
│ │ │ ├── multiple.hpp
│ │ │ ├── multiple.inl
│ │ │ ├── noise.hpp
│ │ │ ├── norm.hpp
│ │ │ ├── norm.inl
│ │ │ ├── normal.hpp
│ │ │ ├── normal.inl
│ │ │ ├── normalize_dot.hpp
│ │ │ ├── normalize_dot.inl
│ │ │ ├── number_precision.hpp
│ │ │ ├── number_precision.inl
│ │ │ ├── optimum_pow.hpp
│ │ │ ├── optimum_pow.inl
│ │ │ ├── orthonormalize.hpp
│ │ │ ├── orthonormalize.inl
│ │ │ ├── perpendicular.hpp
│ │ │ ├── perpendicular.inl
│ │ │ ├── polar_coordinates.hpp
│ │ │ ├── polar_coordinates.inl
│ │ │ ├── projection.hpp
│ │ │ ├── projection.inl
│ │ │ ├── quaternion.hpp
│ │ │ ├── quaternion.inl
│ │ │ ├── random.hpp
│ │ │ ├── raw_data.hpp
│ │ │ ├── raw_data.inl
│ │ │ ├── reciprocal.hpp
│ │ │ ├── rotate_normalized_axis.hpp
│ │ │ ├── rotate_normalized_axis.inl
│ │ │ ├── rotate_vector.hpp
│ │ │ ├── rotate_vector.inl
│ │ │ ├── scalar_relational.hpp
│ │ │ ├── scalar_relational.inl
│ │ │ ├── simd_mat4.hpp
│ │ │ ├── simd_mat4.inl
│ │ │ ├── simd_quat.hpp
│ │ │ ├── simd_quat.inl
│ │ │ ├── simd_vec4.hpp
│ │ │ ├── simd_vec4.inl
│ │ │ ├── spline.hpp
│ │ │ ├── spline.inl
│ │ │ ├── std_based_type.hpp
│ │ │ ├── std_based_type.inl
│ │ │ ├── string_cast.hpp
│ │ │ ├── string_cast.inl
│ │ │ ├── transform.hpp
│ │ │ ├── transform.inl
│ │ │ ├── transform2.hpp
│ │ │ ├── transform2.inl
│ │ │ ├── ulp.hpp
│ │ │ ├── unsigned_int.hpp
│ │ │ ├── unsigned_int.inl
│ │ │ ├── vec1.hpp
│ │ │ ├── vec1.inl
│ │ │ ├── vector_angle.hpp
│ │ │ ├── vector_angle.inl
│ │ │ ├── vector_query.hpp
│ │ │ ├── vector_query.inl
│ │ │ ├── wrap.hpp
│ │ │ └── wrap.inl
│ │ ├── integer.hpp
│ │ ├── mat2x2.hpp
│ │ ├── mat2x3.hpp
│ │ ├── mat2x4.hpp
│ │ ├── mat3x2.hpp
│ │ ├── mat3x3.hpp
│ │ ├── mat3x4.hpp
│ │ ├── mat4x2.hpp
│ │ ├── mat4x3.hpp
│ │ ├── mat4x4.hpp
│ │ ├── matrix.hpp
│ │ ├── packing.hpp
│ │ ├── trigonometric.hpp
│ │ ├── vec2.hpp
│ │ ├── vec3.hpp
│ │ ├── vec4.hpp
│ │ ├── vector_relational.hpp
│ │ └── virtrev/
│ │ └── xstream.hpp
│ ├── lib/
│ │ └── umfpack/
│ │ ├── include/
│ │ │ ├── UFconfig.h
│ │ │ ├── UMFPACK/
│ │ │ │ ├── umfpack.h
│ │ │ │ ├── umfpack_col_to_triplet.h
│ │ │ │ ├── umfpack_defaults.h
│ │ │ │ ├── umfpack_free_numeric.h
│ │ │ │ ├── umfpack_free_symbolic.h
│ │ │ │ ├── umfpack_get_determinant.h
│ │ │ │ ├── umfpack_get_lunz.h
│ │ │ │ ├── umfpack_get_numeric.h
│ │ │ │ ├── umfpack_get_symbolic.h
│ │ │ │ ├── umfpack_global.h
│ │ │ │ ├── umfpack_load_numeric.h
│ │ │ │ ├── umfpack_load_symbolic.h
│ │ │ │ ├── umfpack_numeric.h
│ │ │ │ ├── umfpack_qsymbolic.h
│ │ │ │ ├── umfpack_report_control.h
│ │ │ │ ├── umfpack_report_info.h
│ │ │ │ ├── umfpack_report_matrix.h
│ │ │ │ ├── umfpack_report_numeric.h
│ │ │ │ ├── umfpack_report_perm.h
│ │ │ │ ├── umfpack_report_status.h
│ │ │ │ ├── umfpack_report_symbolic.h
│ │ │ │ ├── umfpack_report_triplet.h
│ │ │ │ ├── umfpack_report_vector.h
│ │ │ │ ├── umfpack_save_numeric.h
│ │ │ │ ├── umfpack_save_symbolic.h
│ │ │ │ ├── umfpack_scale.h
│ │ │ │ ├── umfpack_solve.h
│ │ │ │ ├── umfpack_symbolic.h
│ │ │ │ ├── umfpack_tictoc.h
│ │ │ │ ├── umfpack_timer.h
│ │ │ │ ├── umfpack_transpose.h
│ │ │ │ ├── umfpack_triplet_to_col.h
│ │ │ │ └── umfpack_wsolve.h
│ │ │ ├── amd.h
│ │ │ └── amd_internal.h
│ │ ├── libamd.a
│ │ └── libumfpack.a
│ ├── particles.pro
│ └── src/
│ ├── constraint/
│ │ ├── boundaryconstraint.cpp
│ │ ├── boundaryconstraint.h
│ │ ├── contactconstraint.cpp
│ │ ├── contactconstraint.h
│ │ ├── distanceconstraint.cpp
│ │ ├── distanceconstraint.h
│ │ ├── gasconstraint.cpp
│ │ ├── gasconstraint.h
│ │ ├── rigidcontactconstraint.cpp
│ │ ├── rigidcontactconstraint.h
│ │ ├── smokeparticle.cpp
│ │ ├── smokeparticle.h
│ │ ├── totalfluidconstraint.cpp
│ │ ├── totalfluidconstraint.h
│ │ ├── totalshapeconstraint.cpp
│ │ └── totalshapeconstraint.h
│ ├── fluidemitter.cpp
│ ├── fluidemitter.h
│ ├── includes.h
│ ├── main.cpp
│ ├── mainwindow.cpp
│ ├── mainwindow.h
│ ├── mainwindow.ui
│ ├── opensmokeemitter.cpp
│ ├── opensmokeemitter.h
│ ├── particle.h
│ ├── simulation.cpp
│ ├── simulation.h
│ ├── solver/
│ │ ├── lineareq.cpp
│ │ ├── lineareq.h
│ │ ├── matrix.cpp
│ │ ├── matrix.h
│ │ ├── matrix.inl
│ │ ├── particle.cpp
│ │ ├── solver.cpp
│ │ └── solver.h
│ ├── view.cpp
│ └── view.h
└── gpu/
├── glm/
│ ├── CMakeLists.txt
│ ├── common.hpp
│ ├── detail/
│ │ ├── _features.hpp
│ │ ├── _fixes.hpp
│ │ ├── _literals.hpp
│ │ ├── _noise.hpp
│ │ ├── _swizzle.hpp
│ │ ├── _swizzle_func.hpp
│ │ ├── _vectorize.hpp
│ │ ├── dummy.cpp
│ │ ├── func_common.hpp
│ │ ├── func_common.inl
│ │ ├── func_exponential.hpp
│ │ ├── func_exponential.inl
│ │ ├── func_geometric.hpp
│ │ ├── func_geometric.inl
│ │ ├── func_integer.hpp
│ │ ├── func_integer.inl
│ │ ├── func_matrix.hpp
│ │ ├── func_matrix.inl
│ │ ├── func_noise.hpp
│ │ ├── func_noise.inl
│ │ ├── func_packing.hpp
│ │ ├── func_packing.inl
│ │ ├── func_trigonometric.hpp
│ │ ├── func_trigonometric.inl
│ │ ├── func_vector_relational.hpp
│ │ ├── func_vector_relational.inl
│ │ ├── glm.cpp
│ │ ├── hint.hpp
│ │ ├── intrinsic_common.hpp
│ │ ├── intrinsic_common.inl
│ │ ├── intrinsic_exponential.hpp
│ │ ├── intrinsic_exponential.inl
│ │ ├── intrinsic_geometric.hpp
│ │ ├── intrinsic_geometric.inl
│ │ ├── intrinsic_integer.hpp
│ │ ├── intrinsic_integer.inl
│ │ ├── intrinsic_matrix.hpp
│ │ ├── intrinsic_matrix.inl
│ │ ├── intrinsic_trigonometric.hpp
│ │ ├── intrinsic_trigonometric.inl
│ │ ├── intrinsic_vector_relational.hpp
│ │ ├── intrinsic_vector_relational.inl
│ │ ├── precision.hpp
│ │ ├── precision.inl
│ │ ├── setup.hpp
│ │ ├── type_float.hpp
│ │ ├── type_gentype.hpp
│ │ ├── type_gentype.inl
│ │ ├── type_half.hpp
│ │ ├── type_half.inl
│ │ ├── type_int.hpp
│ │ ├── type_mat.hpp
│ │ ├── type_mat.inl
│ │ ├── type_mat2x2.hpp
│ │ ├── type_mat2x2.inl
│ │ ├── type_mat2x3.hpp
│ │ ├── type_mat2x3.inl
│ │ ├── type_mat2x4.hpp
│ │ ├── type_mat2x4.inl
│ │ ├── type_mat3x2.hpp
│ │ ├── type_mat3x2.inl
│ │ ├── type_mat3x3.hpp
│ │ ├── type_mat3x3.inl
│ │ ├── type_mat3x4.hpp
│ │ ├── type_mat3x4.inl
│ │ ├── type_mat4x2.hpp
│ │ ├── type_mat4x2.inl
│ │ ├── type_mat4x3.hpp
│ │ ├── type_mat4x3.inl
│ │ ├── type_mat4x4.hpp
│ │ ├── type_mat4x4.inl
│ │ ├── type_vec.hpp
│ │ ├── type_vec.inl
│ │ ├── type_vec1.hpp
│ │ ├── type_vec1.inl
│ │ ├── type_vec2.hpp
│ │ ├── type_vec2.inl
│ │ ├── type_vec3.hpp
│ │ ├── type_vec3.inl
│ │ ├── type_vec4.hpp
│ │ └── type_vec4.inl
│ ├── exponential.hpp
│ ├── ext.hpp
│ ├── fwd.hpp
│ ├── geometric.hpp
│ ├── glm.hpp
│ ├── gtc/
│ │ ├── constants.hpp
│ │ ├── constants.inl
│ │ ├── epsilon.hpp
│ │ ├── epsilon.inl
│ │ ├── matrix_access.hpp
│ │ ├── matrix_access.inl
│ │ ├── matrix_integer.hpp
│ │ ├── matrix_inverse.hpp
│ │ ├── matrix_inverse.inl
│ │ ├── matrix_transform.hpp
│ │ ├── matrix_transform.inl
│ │ ├── noise.hpp
│ │ ├── noise.inl
│ │ ├── packing.hpp
│ │ ├── packing.inl
│ │ ├── quaternion.hpp
│ │ ├── quaternion.inl
│ │ ├── random.hpp
│ │ ├── random.inl
│ │ ├── reciprocal.hpp
│ │ ├── reciprocal.inl
│ │ ├── type_precision.hpp
│ │ ├── type_precision.inl
│ │ ├── type_ptr.hpp
│ │ ├── type_ptr.inl
│ │ ├── ulp.hpp
│ │ └── ulp.inl
│ ├── gtx/
│ │ ├── associated_min_max.hpp
│ │ ├── associated_min_max.inl
│ │ ├── bit.hpp
│ │ ├── bit.inl
│ │ ├── closest_point.hpp
│ │ ├── closest_point.inl
│ │ ├── color_space.hpp
│ │ ├── color_space.inl
│ │ ├── color_space_YCoCg.hpp
│ │ ├── color_space_YCoCg.inl
│ │ ├── compatibility.hpp
│ │ ├── compatibility.inl
│ │ ├── component_wise.hpp
│ │ ├── component_wise.inl
│ │ ├── constants.hpp
│ │ ├── dual_quaternion.hpp
│ │ ├── dual_quaternion.inl
│ │ ├── epsilon.hpp
│ │ ├── euler_angles.hpp
│ │ ├── euler_angles.inl
│ │ ├── extend.hpp
│ │ ├── extend.inl
│ │ ├── extented_min_max.hpp
│ │ ├── extented_min_max.inl
│ │ ├── fast_exponential.hpp
│ │ ├── fast_exponential.inl
│ │ ├── fast_square_root.hpp
│ │ ├── fast_square_root.inl
│ │ ├── fast_trigonometry.hpp
│ │ ├── fast_trigonometry.inl
│ │ ├── gradient_paint.hpp
│ │ ├── gradient_paint.inl
│ │ ├── handed_coordinate_space.hpp
│ │ ├── handed_coordinate_space.inl
│ │ ├── inertia.hpp
│ │ ├── inertia.inl
│ │ ├── int_10_10_10_2.hpp
│ │ ├── int_10_10_10_2.inl
│ │ ├── integer.hpp
│ │ ├── integer.inl
│ │ ├── intersect.hpp
│ │ ├── intersect.inl
│ │ ├── io.hpp
│ │ ├── io.inl
│ │ ├── log_base.hpp
│ │ ├── log_base.inl
│ │ ├── matrix_cross_product.hpp
│ │ ├── matrix_cross_product.inl
│ │ ├── matrix_interpolation.hpp
│ │ ├── matrix_interpolation.inl
│ │ ├── matrix_major_storage.hpp
│ │ ├── matrix_major_storage.inl
│ │ ├── matrix_operation.hpp
│ │ ├── matrix_operation.inl
│ │ ├── matrix_query.hpp
│ │ ├── matrix_query.inl
│ │ ├── mixed_product.hpp
│ │ ├── mixed_product.inl
│ │ ├── multiple.hpp
│ │ ├── multiple.inl
│ │ ├── noise.hpp
│ │ ├── norm.hpp
│ │ ├── norm.inl
│ │ ├── normal.hpp
│ │ ├── normal.inl
│ │ ├── normalize_dot.hpp
│ │ ├── normalize_dot.inl
│ │ ├── number_precision.hpp
│ │ ├── number_precision.inl
│ │ ├── optimum_pow.hpp
│ │ ├── optimum_pow.inl
│ │ ├── orthonormalize.hpp
│ │ ├── orthonormalize.inl
│ │ ├── perpendicular.hpp
│ │ ├── perpendicular.inl
│ │ ├── polar_coordinates.hpp
│ │ ├── polar_coordinates.inl
│ │ ├── projection.hpp
│ │ ├── projection.inl
│ │ ├── quaternion.hpp
│ │ ├── quaternion.inl
│ │ ├── random.hpp
│ │ ├── raw_data.hpp
│ │ ├── raw_data.inl
│ │ ├── reciprocal.hpp
│ │ ├── rotate_normalized_axis.hpp
│ │ ├── rotate_normalized_axis.inl
│ │ ├── rotate_vector.hpp
│ │ ├── rotate_vector.inl
│ │ ├── scalar_relational.hpp
│ │ ├── scalar_relational.inl
│ │ ├── simd_mat4.hpp
│ │ ├── simd_mat4.inl
│ │ ├── simd_quat.hpp
│ │ ├── simd_quat.inl
│ │ ├── simd_vec4.hpp
│ │ ├── simd_vec4.inl
│ │ ├── spline.hpp
│ │ ├── spline.inl
│ │ ├── std_based_type.hpp
│ │ ├── std_based_type.inl
│ │ ├── string_cast.hpp
│ │ ├── string_cast.inl
│ │ ├── transform.hpp
│ │ ├── transform.inl
│ │ ├── transform2.hpp
│ │ ├── transform2.inl
│ │ ├── ulp.hpp
│ │ ├── unsigned_int.hpp
│ │ ├── unsigned_int.inl
│ │ ├── vec1.hpp
│ │ ├── vec1.inl
│ │ ├── vector_angle.hpp
│ │ ├── vector_angle.inl
│ │ ├── vector_query.hpp
│ │ ├── vector_query.inl
│ │ ├── wrap.hpp
│ │ └── wrap.inl
│ ├── integer.hpp
│ ├── mat2x2.hpp
│ ├── mat2x3.hpp
│ ├── mat2x4.hpp
│ ├── mat3x2.hpp
│ ├── mat3x3.hpp
│ ├── mat3x4.hpp
│ ├── mat4x2.hpp
│ ├── mat4x3.hpp
│ ├── mat4x4.hpp
│ ├── matrix.hpp
│ ├── packing.hpp
│ ├── trigonometric.hpp
│ ├── vec2.hpp
│ ├── vec3.hpp
│ ├── vec4.hpp
│ ├── vector_relational.hpp
│ └── virtrev/
│ └── xstream.hpp
├── particles_cuda.pro
├── res/
│ └── shaders/
│ ├── shader.frag
│ └── shader.vert
├── resources.qrc
└── src/
├── cuda/
│ ├── helper_cuda.h
│ ├── helper_math.h
│ ├── integration.cu
│ ├── integration_kernel.cuh
│ ├── kernel.cuh
│ ├── kernel_impl.cuh
│ ├── shared_variables.cu
│ ├── shared_variables.cuh
│ ├── solver.cu
│ ├── solver_kernel.cuh
│ ├── util.cu
│ ├── util.cuh
│ ├── wrappers.cuh
│ └── wrappers_cuda.cu
├── debugprinting.h
├── main.cpp
├── particleapp.cpp
├── particleapp.h
├── particlesystem.cpp
├── particlesystem.h
├── rendering/
│ ├── actioncamera.cpp
│ ├── actioncamera.h
│ ├── camera.cpp
│ ├── camera.h
│ ├── orbitingcamera.cpp
│ ├── orbitingcamera.h
│ ├── renderer.cpp
│ └── renderer.h
└── ui/
├── mainwindow.cpp
├── mainwindow.h
├── mainwindow.ui
├── view.cpp
└── view.h
SYMBOL INDEX (1154 symbols across 283 files)
FILE: cpu/glm/detail/_literals.hpp
type glm (line 32) | namespace glm
FILE: cpu/glm/detail/_noise.hpp
type glm (line 32) | namespace glm{
type detail (line 33) | namespace detail
function GLM_FUNC_QUALIFIER (line 36) | GLM_FUNC_QUALIFIER T mod289(T const & x)
function GLM_FUNC_QUALIFIER (line 42) | GLM_FUNC_QUALIFIER T permute(T const & x)
function GLM_FUNC_QUALIFIER (line 48) | GLM_FUNC_QUALIFIER tvec2<T, P> permute(tvec2<T, P> const & x)
function GLM_FUNC_QUALIFIER (line 54) | GLM_FUNC_QUALIFIER tvec3<T, P> permute(tvec3<T, P> const & x)
function GLM_FUNC_QUALIFIER (line 60) | GLM_FUNC_QUALIFIER tvec4<T, P> permute(tvec4<T, P> const & x)
function GLM_FUNC_QUALIFIER (line 72) | GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
function GLM_FUNC_QUALIFIER (line 78) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> taylorInvSqrt(detail::tvec2<T...
function GLM_FUNC_QUALIFIER (line 84) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> taylorInvSqrt(detail::tvec3<T...
function GLM_FUNC_QUALIFIER (line 90) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> taylorInvSqrt(detail::tvec4<T...
function GLM_FUNC_QUALIFIER (line 103) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> fade(detail::tvec2<T, P> cons...
function GLM_FUNC_QUALIFIER (line 109) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> fade(detail::tvec3<T, P> cons...
function GLM_FUNC_QUALIFIER (line 115) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> fade(detail::tvec4<T, P> cons...
FILE: cpu/glm/detail/_swizzle.hpp
type glm (line 32) | namespace glm{
type detail (line 33) | namespace detail
type _swizzle_base0 (line 37) | struct _swizzle_base0
method GLM_FUNC_QUALIFIER (line 42) | GLM_FUNC_QUALIFIER value_type& elem (size_t i) { r...
method GLM_FUNC_QUALIFIER (line 43) | GLM_FUNC_QUALIFIER const value_type& elem (size_t i) const { r...
type _swizzle_base1 (line 52) | struct _swizzle_base1 : public _swizzle_base0<T, N>
type _swizzle_base1<T, P, V,E0,E1,-1,-2,2> (line 57) | struct _swizzle_base1<T, P, V,E0,E1,-1,-2,2> : public _swizzle_base0...
method GLM_FUNC_QUALIFIER (line 59) | GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0...
type _swizzle_base1<T, P, V,E0,E1,E2,-1,3> (line 63) | struct _swizzle_base1<T, P, V,E0,E1,E2,-1,3> : public _swizzle_base0...
method GLM_FUNC_QUALIFIER (line 65) | GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0...
type _swizzle_base1<T, P, V,E0,E1,E2,E3,4> (line 69) | struct _swizzle_base1<T, P, V,E0,E1,E2,E3,4> : public _swizzle_base0...
method GLM_FUNC_QUALIFIER (line 71) | GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0...
type _swizzle_base2 (line 87) | struct _swizzle_base2 : public _swizzle_base1<ValueType, P, VecType,...
method GLM_FUNC_QUALIFIER (line 92) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t)
method GLM_FUNC_QUALIFIER (line 99) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that)
method GLM_FUNC_QUALIFIER (line 108) | GLM_FUNC_QUALIFIER void operator -= (const VecType& that)
method GLM_FUNC_QUALIFIER (line 116) | GLM_FUNC_QUALIFIER void operator += (const VecType& that)
method GLM_FUNC_QUALIFIER (line 124) | GLM_FUNC_QUALIFIER void operator *= (const VecType& that)
method GLM_FUNC_QUALIFIER (line 132) | GLM_FUNC_QUALIFIER void operator /= (const VecType& that)
method GLM_FUNC_QUALIFIER (line 140) | GLM_FUNC_QUALIFIER value_type& operator[] (size_t i)
method GLM_FUNC_QUALIFIER (line 158) | GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op)
type _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,1> (line 173) | struct _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,1> : publi...
type Stub (line 178) | struct Stub {}
method GLM_FUNC_QUALIFIER (line 179) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { retu...
type _swizzle (line 192) | struct _swizzle : public _swizzle_base2<ValueType, P, VecType, N,E0,...
method GLM_FUNC_QUALIFIER (line 198) | GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); }
FILE: cpu/glm/detail/_vectorize.hpp
type glm (line 192) | namespace glm{
type detail (line 193) | namespace detail
type If (line 196) | struct If
method GLM_FUNC_QUALIFIER (line 199) | static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
type If<false> (line 206) | struct If<false>
method GLM_FUNC_QUALIFIER (line 209) | static GLM_FUNC_QUALIFIER T apply(F, const T& val)
FILE: cpu/glm/detail/dummy.cpp
class C (line 62) | class C
class C (line 65) | class C
function main (line 71) | int main()
FILE: cpu/glm/detail/func_common.hpp
type glm (line 44) | namespace glm
FILE: cpu/glm/detail/func_exponential.hpp
type glm (line 45) | namespace glm
FILE: cpu/glm/detail/func_geometric.hpp
type glm (line 41) | namespace glm
FILE: cpu/glm/detail/func_integer.hpp
type glm (line 43) | namespace glm
FILE: cpu/glm/detail/func_matrix.hpp
type glm (line 60) | namespace glm{
type detail (line 61) | namespace detail
type outerProduct_trait<T, P, tvec2, tvec2> (line 64) | struct outerProduct_trait<T, P, tvec2, tvec2>
type outerProduct_trait<T, P, tvec2, tvec3> (line 70) | struct outerProduct_trait<T, P, tvec2, tvec3>
type outerProduct_trait<T, P, tvec2, tvec4> (line 76) | struct outerProduct_trait<T, P, tvec2, tvec4>
type outerProduct_trait<T, P, tvec3, tvec2> (line 82) | struct outerProduct_trait<T, P, tvec3, tvec2>
type outerProduct_trait<T, P, tvec3, tvec3> (line 88) | struct outerProduct_trait<T, P, tvec3, tvec3>
type outerProduct_trait<T, P, tvec3, tvec4> (line 94) | struct outerProduct_trait<T, P, tvec3, tvec4>
type outerProduct_trait<T, P, tvec4, tvec2> (line 100) | struct outerProduct_trait<T, P, tvec4, tvec2>
type outerProduct_trait<T, P, tvec4, tvec3> (line 106) | struct outerProduct_trait<T, P, tvec4, tvec3>
type outerProduct_trait<T, P, tvec4, tvec4> (line 112) | struct outerProduct_trait<T, P, tvec4, tvec4>
FILE: cpu/glm/detail/func_noise.hpp
type glm (line 46) | namespace glm
FILE: cpu/glm/detail/func_packing.hpp
type glm (line 42) | namespace glm
FILE: cpu/glm/detail/func_trigonometric.hpp
type glm (line 43) | namespace glm
FILE: cpu/glm/detail/func_vector_relational.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/detail/glm.cpp
type glm (line 33) | namespace glm{
type detail (line 34) | namespace detail
type tvec2<uint8, lowp> (line 75) | struct tvec2<uint8, lowp>
type tvec2<uint16, lowp> (line 76) | struct tvec2<uint16, lowp>
type tvec2<uint32, lowp> (line 77) | struct tvec2<uint32, lowp>
type tvec2<uint64, lowp> (line 78) | struct tvec2<uint64, lowp>
type tvec2<int8, lowp> (line 79) | struct tvec2<int8, lowp>
type tvec2<int16, lowp> (line 80) | struct tvec2<int16, lowp>
type tvec2<int32, lowp> (line 81) | struct tvec2<int32, lowp>
type tvec2<int64, lowp> (line 82) | struct tvec2<int64, lowp>
type tvec2<float32, lowp> (line 83) | struct tvec2<float32, lowp>
type tvec2<float64, lowp> (line 84) | struct tvec2<float64, lowp>
type tvec2<uint8, mediump> (line 86) | struct tvec2<uint8, mediump>
type tvec2<uint16, mediump> (line 87) | struct tvec2<uint16, mediump>
type tvec2<uint32, mediump> (line 88) | struct tvec2<uint32, mediump>
type tvec2<uint64, mediump> (line 89) | struct tvec2<uint64, mediump>
type tvec2<int8, mediump> (line 90) | struct tvec2<int8, mediump>
type tvec2<int16, mediump> (line 91) | struct tvec2<int16, mediump>
type tvec2<int32, mediump> (line 92) | struct tvec2<int32, mediump>
type tvec2<int64, mediump> (line 93) | struct tvec2<int64, mediump>
type tvec2<float32, mediump> (line 94) | struct tvec2<float32, mediump>
type tvec2<float64, mediump> (line 95) | struct tvec2<float64, mediump>
type tvec2<uint8, highp> (line 97) | struct tvec2<uint8, highp>
type tvec2<uint16, highp> (line 98) | struct tvec2<uint16, highp>
type tvec2<uint32, highp> (line 99) | struct tvec2<uint32, highp>
type tvec2<uint64, highp> (line 100) | struct tvec2<uint64, highp>
type tvec2<int8, highp> (line 101) | struct tvec2<int8, highp>
type tvec2<int16, highp> (line 102) | struct tvec2<int16, highp>
type tvec2<int32, highp> (line 103) | struct tvec2<int32, highp>
type tvec2<int64, highp> (line 104) | struct tvec2<int64, highp>
type tvec2<float32, highp> (line 105) | struct tvec2<float32, highp>
type tvec2<float64, highp> (line 106) | struct tvec2<float64, highp>
type tvec3<uint8, lowp> (line 109) | struct tvec3<uint8, lowp>
type tvec3<uint16, lowp> (line 110) | struct tvec3<uint16, lowp>
type tvec3<uint32, lowp> (line 111) | struct tvec3<uint32, lowp>
type tvec3<uint64, lowp> (line 112) | struct tvec3<uint64, lowp>
type tvec3<int8, lowp> (line 113) | struct tvec3<int8, lowp>
type tvec3<int16, lowp> (line 114) | struct tvec3<int16, lowp>
type tvec3<int32, lowp> (line 115) | struct tvec3<int32, lowp>
type tvec3<int64, lowp> (line 116) | struct tvec3<int64, lowp>
type tvec3<float32, lowp> (line 117) | struct tvec3<float32, lowp>
type tvec3<float64, lowp> (line 118) | struct tvec3<float64, lowp>
type tvec3<uint8, mediump> (line 120) | struct tvec3<uint8, mediump>
type tvec3<uint16, mediump> (line 121) | struct tvec3<uint16, mediump>
type tvec3<uint32, mediump> (line 122) | struct tvec3<uint32, mediump>
type tvec3<uint64, mediump> (line 123) | struct tvec3<uint64, mediump>
type tvec3<int8, mediump> (line 124) | struct tvec3<int8, mediump>
type tvec3<int16, mediump> (line 125) | struct tvec3<int16, mediump>
type tvec3<int32, mediump> (line 126) | struct tvec3<int32, mediump>
type tvec3<int64, mediump> (line 127) | struct tvec3<int64, mediump>
type tvec3<float32, mediump> (line 128) | struct tvec3<float32, mediump>
type tvec3<float64, mediump> (line 129) | struct tvec3<float64, mediump>
type tvec3<uint8, highp> (line 131) | struct tvec3<uint8, highp>
type tvec3<uint16, highp> (line 132) | struct tvec3<uint16, highp>
type tvec3<uint32, highp> (line 133) | struct tvec3<uint32, highp>
type tvec3<uint64, highp> (line 134) | struct tvec3<uint64, highp>
type tvec3<int8, highp> (line 135) | struct tvec3<int8, highp>
type tvec3<int16, highp> (line 136) | struct tvec3<int16, highp>
type tvec3<int32, highp> (line 137) | struct tvec3<int32, highp>
type tvec3<int64, highp> (line 138) | struct tvec3<int64, highp>
type tvec3<float32, highp> (line 139) | struct tvec3<float32, highp>
type tvec3<float64, highp> (line 140) | struct tvec3<float64, highp>
type tvec4<uint8, lowp> (line 143) | struct tvec4<uint8, lowp>
type tvec4<uint16, lowp> (line 144) | struct tvec4<uint16, lowp>
type tvec4<uint32, lowp> (line 145) | struct tvec4<uint32, lowp>
type tvec4<uint64, lowp> (line 146) | struct tvec4<uint64, lowp>
type tvec4<int8, lowp> (line 147) | struct tvec4<int8, lowp>
type tvec4<int16, lowp> (line 148) | struct tvec4<int16, lowp>
type tvec4<int32, lowp> (line 149) | struct tvec4<int32, lowp>
type tvec4<int64, lowp> (line 150) | struct tvec4<int64, lowp>
type tvec4<float32, lowp> (line 151) | struct tvec4<float32, lowp>
type tvec4<float64, lowp> (line 152) | struct tvec4<float64, lowp>
type tvec4<uint8, mediump> (line 154) | struct tvec4<uint8, mediump>
type tvec4<uint16, mediump> (line 155) | struct tvec4<uint16, mediump>
type tvec4<uint32, mediump> (line 156) | struct tvec4<uint32, mediump>
type tvec4<uint64, mediump> (line 157) | struct tvec4<uint64, mediump>
type tvec4<int8, mediump> (line 158) | struct tvec4<int8, mediump>
type tvec4<int16, mediump> (line 159) | struct tvec4<int16, mediump>
type tvec4<int32, mediump> (line 160) | struct tvec4<int32, mediump>
type tvec4<int64, mediump> (line 161) | struct tvec4<int64, mediump>
type tvec4<float32, mediump> (line 162) | struct tvec4<float32, mediump>
type tvec4<float64, mediump> (line 163) | struct tvec4<float64, mediump>
type tvec4<uint8, highp> (line 165) | struct tvec4<uint8, highp>
type tvec4<uint16, highp> (line 166) | struct tvec4<uint16, highp>
type tvec4<uint32, highp> (line 167) | struct tvec4<uint32, highp>
type tvec4<uint64, highp> (line 168) | struct tvec4<uint64, highp>
type tvec4<int8, highp> (line 169) | struct tvec4<int8, highp>
type tvec4<int16, highp> (line 170) | struct tvec4<int16, highp>
type tvec4<int32, highp> (line 171) | struct tvec4<int32, highp>
type tvec4<int64, highp> (line 172) | struct tvec4<int64, highp>
type tvec4<float32, highp> (line 173) | struct tvec4<float32, highp>
type tvec4<float64, highp> (line 174) | struct tvec4<float64, highp>
type tmat2x2<float32, lowp> (line 177) | struct tmat2x2<float32, lowp>
type tmat2x2<float64, lowp> (line 178) | struct tmat2x2<float64, lowp>
type tmat2x2<float32, mediump> (line 180) | struct tmat2x2<float32, mediump>
type tmat2x2<float64, mediump> (line 181) | struct tmat2x2<float64, mediump>
type tmat2x2<float32, highp> (line 183) | struct tmat2x2<float32, highp>
type tmat2x2<float64, highp> (line 184) | struct tmat2x2<float64, highp>
type tmat2x3<float32, lowp> (line 187) | struct tmat2x3<float32, lowp>
type tmat2x3<float64, lowp> (line 188) | struct tmat2x3<float64, lowp>
type tmat2x3<float32, mediump> (line 190) | struct tmat2x3<float32, mediump>
type tmat2x3<float64, mediump> (line 191) | struct tmat2x3<float64, mediump>
type tmat2x3<float32, highp> (line 193) | struct tmat2x3<float32, highp>
type tmat2x3<float64, highp> (line 194) | struct tmat2x3<float64, highp>
type tmat2x4<float32, lowp> (line 197) | struct tmat2x4<float32, lowp>
type tmat2x4<float64, lowp> (line 198) | struct tmat2x4<float64, lowp>
type tmat2x4<float32, mediump> (line 200) | struct tmat2x4<float32, mediump>
type tmat2x4<float64, mediump> (line 201) | struct tmat2x4<float64, mediump>
type tmat2x4<float32, highp> (line 203) | struct tmat2x4<float32, highp>
type tmat2x4<float64, highp> (line 204) | struct tmat2x4<float64, highp>
type tmat3x2<float32, lowp> (line 207) | struct tmat3x2<float32, lowp>
type tmat3x2<float64, lowp> (line 208) | struct tmat3x2<float64, lowp>
type tmat3x2<float32, mediump> (line 210) | struct tmat3x2<float32, mediump>
type tmat3x2<float64, mediump> (line 211) | struct tmat3x2<float64, mediump>
type tmat3x2<float32, highp> (line 213) | struct tmat3x2<float32, highp>
type tmat3x2<float64, highp> (line 214) | struct tmat3x2<float64, highp>
type tmat3x3<float32, lowp> (line 217) | struct tmat3x3<float32, lowp>
type tmat3x3<float64, lowp> (line 218) | struct tmat3x3<float64, lowp>
type tmat3x3<float32, mediump> (line 220) | struct tmat3x3<float32, mediump>
type tmat3x3<float64, mediump> (line 221) | struct tmat3x3<float64, mediump>
type tmat3x3<float32, highp> (line 223) | struct tmat3x3<float32, highp>
type tmat3x3<float64, highp> (line 224) | struct tmat3x3<float64, highp>
type tmat3x4<float32, lowp> (line 227) | struct tmat3x4<float32, lowp>
type tmat3x4<float64, lowp> (line 228) | struct tmat3x4<float64, lowp>
type tmat3x4<float32, mediump> (line 230) | struct tmat3x4<float32, mediump>
type tmat3x4<float64, mediump> (line 231) | struct tmat3x4<float64, mediump>
type tmat3x4<float32, highp> (line 233) | struct tmat3x4<float32, highp>
type tmat3x4<float64, highp> (line 234) | struct tmat3x4<float64, highp>
type tmat4x2<float32, lowp> (line 237) | struct tmat4x2<float32, lowp>
type tmat4x2<float64, lowp> (line 238) | struct tmat4x2<float64, lowp>
type tmat4x2<float32, mediump> (line 240) | struct tmat4x2<float32, mediump>
type tmat4x2<float64, mediump> (line 241) | struct tmat4x2<float64, mediump>
type tmat4x2<float32, highp> (line 243) | struct tmat4x2<float32, highp>
type tmat4x2<float64, highp> (line 244) | struct tmat4x2<float64, highp>
type tmat4x3<float32, lowp> (line 247) | struct tmat4x3<float32, lowp>
type tmat4x3<float64, lowp> (line 248) | struct tmat4x3<float64, lowp>
type tmat4x3<float32, mediump> (line 250) | struct tmat4x3<float32, mediump>
type tmat4x3<float64, mediump> (line 251) | struct tmat4x3<float64, mediump>
type tmat4x3<float32, highp> (line 253) | struct tmat4x3<float32, highp>
type tmat4x3<float64, highp> (line 254) | struct tmat4x3<float64, highp>
type tmat4x4<float32, lowp> (line 257) | struct tmat4x4<float32, lowp>
type tmat4x4<float64, lowp> (line 258) | struct tmat4x4<float64, lowp>
type tmat4x4<float32, mediump> (line 260) | struct tmat4x4<float32, mediump>
type tmat4x4<float64, mediump> (line 261) | struct tmat4x4<float64, mediump>
type tmat4x4<float32, highp> (line 263) | struct tmat4x4<float32, highp>
type tmat4x4<float64, highp> (line 264) | struct tmat4x4<float64, highp>
type tquat<float32, lowp> (line 267) | struct tquat<float32, lowp>
type tquat<float64, lowp> (line 268) | struct tquat<float64, lowp>
type tquat<float32, mediump> (line 270) | struct tquat<float32, mediump>
type tquat<float64, mediump> (line 271) | struct tquat<float64, mediump>
type tquat<float32, highp> (line 273) | struct tquat<float32, highp>
type tquat<float64, highp> (line 274) | struct tquat<float64, highp>
type tdualquat<float32, lowp> (line 277) | struct tdualquat<float32, lowp>
type tdualquat<float64, lowp> (line 278) | struct tdualquat<float64, lowp>
type tdualquat<float32, mediump> (line 280) | struct tdualquat<float32, mediump>
type tdualquat<float64, mediump> (line 281) | struct tdualquat<float64, mediump>
type tdualquat<float32, highp> (line 283) | struct tdualquat<float32, highp>
type tdualquat<float64, highp> (line 284) | struct tdualquat<float64, highp>
FILE: cpu/glm/detail/hint.hpp
type glm (line 32) | namespace glm
class dont_care (line 35) | class dont_care {}
class nicest (line 36) | class nicest {}
class fastest (line 37) | class fastest {}
FILE: cpu/glm/detail/intrinsic_common.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: cpu/glm/detail/intrinsic_exponential.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: cpu/glm/detail/intrinsic_geometric.hpp
type glm (line 40) | namespace glm{
type detail (line 41) | namespace detail
FILE: cpu/glm/detail/intrinsic_integer.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: cpu/glm/detail/intrinsic_matrix.hpp
type glm (line 40) | namespace glm{
type detail (line 41) | namespace detail
FILE: cpu/glm/detail/intrinsic_trigonometric.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: cpu/glm/detail/intrinsic_vector_relational.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: cpu/glm/detail/precision.hpp
type glm (line 32) | namespace glm
type precision (line 34) | enum precision
FILE: cpu/glm/detail/setup.hpp
function _mm_cvtss_f32 (line 635) | inline float _mm_cvtss_f32(__m128 A) { return A.m128_f32[0]; }
function __m128 (line 636) | inline __m128 _mm_castpd_ps(__m128d PD) { union { __m128 ps; __m128d pd;...
function __m128d (line 637) | inline __m128d _mm_castps_pd(__m128 PS) { union { __m128 ps; __m128d pd;...
function __m128i (line 638) | inline __m128i _mm_castps_si128(__m128 PS) { union { __m128 ps; __m128i ...
function __m128 (line 639) | inline __m128 _mm_castsi128_ps(__m128i PI) { union { __m128 ps; __m128i ...
type glm (line 736) | namespace glm
FILE: cpu/glm/detail/type_float.hpp
type glm (line 34) | namespace glm{
type detail (line 35) | namespace detail
FILE: cpu/glm/detail/type_gentype.hpp
type glm (line 32) | namespace glm
type profile (line 34) | enum profile
type detail (line 43) | namespace detail
type genType (line 50) | struct genType
type ctor (line 53) | enum ctor{null}
method value_const_pointer (line 77) | value_const_pointer value_address() const{return value_pointer(thi...
method value_pointer (line 78) | value_pointer value_address(){return value_pointer(this);}
FILE: cpu/glm/detail/type_half.hpp
type glm (line 34) | namespace glm{
type detail (line 35) | namespace detail
FILE: cpu/glm/detail/type_int.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: cpu/glm/detail/type_mat.hpp
type glm (line 34) | namespace glm{
type detail (line 35) | namespace detail
type tvec2 (line 37) | struct tvec2
type tvec3 (line 38) | struct tvec3
type tvec4 (line 39) | struct tvec4
type tmat2x2 (line 40) | struct tmat2x2
type tmat2x3 (line 41) | struct tmat2x3
type tmat2x4 (line 42) | struct tmat2x4
type tmat3x2 (line 43) | struct tmat3x2
type tmat3x3 (line 44) | struct tmat3x3
type tmat3x4 (line 45) | struct tmat3x4
type tmat4x2 (line 46) | struct tmat4x2
type tmat4x3 (line 47) | struct tmat4x3
type tmat4x4 (line 48) | struct tmat4x4
type outerProduct_trait (line 51) | struct outerProduct_trait{}
type compute_inverse (line 54) | struct compute_inverse{}
FILE: cpu/glm/detail/type_mat2x2.hpp
type glm (line 37) | namespace glm{
type detail (line 38) | namespace detail
type tmat2x2 (line 41) | struct tmat2x2
type ctor (line 43) | enum ctor{_null}
FILE: cpu/glm/detail/type_mat2x3.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat2x3 (line 42) | struct tmat2x3
type ctor (line 44) | enum ctor{_null}
FILE: cpu/glm/detail/type_mat2x4.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat2x4 (line 42) | struct tmat2x4
type ctor (line 44) | enum ctor{_null}
FILE: cpu/glm/detail/type_mat3x2.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat3x2 (line 42) | struct tmat3x2
type ctor (line 44) | enum ctor{_null}
FILE: cpu/glm/detail/type_mat3x3.hpp
type glm (line 37) | namespace glm{
type detail (line 38) | namespace detail
type tmat3x3 (line 41) | struct tmat3x3
type ctor (line 43) | enum ctor{_null}
FILE: cpu/glm/detail/type_mat3x4.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat3x4 (line 42) | struct tmat3x4
type ctor (line 44) | enum ctor{_null}
FILE: cpu/glm/detail/type_mat4x2.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat4x2 (line 42) | struct tmat4x2
type ctor (line 44) | enum ctor{_null}
FILE: cpu/glm/detail/type_mat4x3.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat4x3 (line 42) | struct tmat4x3
type ctor (line 44) | enum ctor{_null}
FILE: cpu/glm/detail/type_mat4x4.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat4x4 (line 42) | struct tmat4x4
type ctor (line 44) | enum ctor{_null}
FILE: cpu/glm/detail/type_vec.hpp
type glm (line 35) | namespace glm{
type detail (line 36) | namespace detail
type tvec1 (line 38) | struct tvec1
type tvec2 (line 39) | struct tvec2
type tvec3 (line 40) | struct tvec3
type tvec4 (line 41) | struct tvec4
FILE: cpu/glm/detail/type_vec1.hpp
type glm (line 43) | namespace glm{
type detail (line 44) | namespace detail
type tvec1 (line 47) | struct tvec1
type ctor (line 52) | enum ctor{_null}
FILE: cpu/glm/detail/type_vec2.hpp
type ctor (line 52) | enum ctor{_null}
function GLM_FUNC_DECL (line 123) | GLM_FUNC_DECL tvec2(_swizzle<2,T, P, tvec2<T, P>, E0, E1,-1,-2> const & ...
FILE: cpu/glm/detail/type_vec3.hpp
type ctor (line 52) | enum ctor{_null}
function GLM_FUNC_DECL (line 151) | GLM_FUNC_DECL tvec3(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const...
function GLM_FUNC_DECL (line 157) | GLM_FUNC_DECL tvec3(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const...
function GLM_FUNC_DECL (line 163) | GLM_FUNC_DECL tvec3(T const & s, _swizzle<2, T, P, tvec2<T, P>, E0, E1, ...
FILE: cpu/glm/detail/type_vec4.hpp
type ctor (line 53) | enum ctor{_null}
function GLM_FUNC_DECL (line 164) | GLM_FUNC_DECL tvec4(_swizzle<4, T, P, tvec4<T, P>, E0, E1, E2, E3> const...
function GLM_FUNC_DECL (line 170) | GLM_FUNC_DECL tvec4(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const...
function GLM_FUNC_DECL (line 176) | GLM_FUNC_DECL tvec4(T const & x, T const & y, _swizzle<2, T, P, tvec2<T,...
function GLM_FUNC_DECL (line 182) | GLM_FUNC_DECL tvec4(T const & x, _swizzle<2, T, P, tvec2<T, P>, E0, E1, ...
function GLM_FUNC_DECL (line 188) | GLM_FUNC_DECL tvec4(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const...
function GLM_FUNC_DECL (line 194) | GLM_FUNC_DECL tvec4(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const...
function GLM_FUNC_DECL (line 200) | GLM_FUNC_DECL tvec4(T const & x, _swizzle<3, T, P, tvec3<T, P>, E0, E1, ...
FILE: cpu/glm/fwd.hpp
type glm (line 39) | namespace glm{
type detail (line 40) | namespace detail
type tquat (line 42) | struct tquat
type glm (line 125) | namespace glm
type detail (line 40) | namespace detail
type tquat (line 42) | struct tquat
FILE: cpu/glm/gtc/constants.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtc/epsilon.hpp
type glm (line 51) | namespace glm
FILE: cpu/glm/gtc/matrix_access.hpp
type glm (line 47) | namespace glm
FILE: cpu/glm/gtc/matrix_integer.hpp
type glm (line 55) | namespace glm
FILE: cpu/glm/gtc/matrix_inverse.hpp
type glm (line 47) | namespace glm
FILE: cpu/glm/gtc/matrix_transform.hpp
type glm (line 59) | namespace glm
FILE: cpu/glm/gtc/noise.hpp
type glm (line 52) | namespace glm
FILE: cpu/glm/gtc/packing.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtc/quaternion.hpp
type glm (line 54) | namespace glm{
type detail (line 55) | namespace detail
type tquat (line 58) | struct tquat
type ctor (line 60) | enum ctor{null}
FILE: cpu/glm/gtc/random.hpp
type glm (line 51) | namespace glm
FILE: cpu/glm/gtc/reciprocal.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtc/type_precision.hpp
type glm (line 65) | namespace glm
FILE: cpu/glm/gtc/type_ptr.hpp
type glm (line 82) | namespace glm
FILE: cpu/glm/gtc/ulp.hpp
type glm (line 51) | namespace glm
FILE: cpu/glm/gtx/associated_min_max.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/bit.hpp
type glm (line 51) | namespace glm
FILE: cpu/glm/gtx/closest_point.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/color_space.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/color_space_YCoCg.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/compatibility.hpp
type glm (line 59) | namespace glm
function GLM_FUNC_QUALIFIER (line 64) | GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}
function GLM_FUNC_QUALIFIER (line 65) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>&...
function GLM_FUNC_QUALIFIER (line 67) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>&...
function GLM_FUNC_QUALIFIER (line 68) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>&...
function GLM_FUNC_QUALIFIER (line 69) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>&...
function GLM_FUNC_QUALIFIER (line 70) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>&...
function GLM_FUNC_QUALIFIER (line 71) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>&...
function GLM_FUNC_QUALIFIER (line 73) | GLM_FUNC_QUALIFIER T slerp(detail::tquat<T, P> const & x, detail::tqua...
function GLM_FUNC_QUALIFIER (line 75) | GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}
function GLM_FUNC_QUALIFIER (line 76) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> saturate(const detail::tvec2<T,...
function GLM_FUNC_QUALIFIER (line 77) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturate(const detail::tvec3<T,...
function GLM_FUNC_QUALIFIER (line 78) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturate(const detail::tvec4<T,...
function GLM_FUNC_QUALIFIER (line 80) | GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}
function GLM_FUNC_QUALIFIER (line 81) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> atan2(const detail::tvec2<T, P>...
function GLM_FUNC_QUALIFIER (line 82) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> atan2(const detail::tvec3<T, P>...
function GLM_FUNC_QUALIFIER (line 83) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> atan2(const detail::tvec4<T, P>...
FILE: cpu/glm/gtx/component_wise.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/dual_quaternion.hpp
type glm (line 53) | namespace glm{
type detail (line 54) | namespace detail
type tdualquat (line 57) | struct tdualquat
type ctor (line 59) | enum ctor{null}
FILE: cpu/glm/gtx/euler_angles.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/extend.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/extented_min_max.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/fast_exponential.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/fast_square_root.hpp
type glm (line 50) | namespace glm
FILE: cpu/glm/gtx/fast_trigonometry.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/gradient_paint.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/handed_coordinate_space.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/inertia.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/int_10_10_10_2.hpp
type glm (line 35) | namespace glm
FILE: cpu/glm/gtx/integer.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/intersect.hpp
type glm (line 50) | namespace glm
FILE: cpu/glm/gtx/io.hpp
type glm (line 53) | namespace glm
type io (line 58) | namespace io
class precision_guard (line 61) | class precision_guard {
class format_guard (line 75) | class format_guard
type order_t (line 78) | enum order_t { column_major, row_major, }
type detail (line 115) | namespace detail
FILE: cpu/glm/gtx/log_base.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/matrix_cross_product.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/matrix_interpolation.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/matrix_major_storage.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/matrix_operation.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/matrix_query.hpp
type glm (line 51) | namespace glm
FILE: cpu/glm/gtx/mixed_product.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/multiple.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/norm.hpp
type glm (line 50) | namespace glm
FILE: cpu/glm/gtx/normal.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/normalize_dot.hpp
type glm (line 50) | namespace glm
FILE: cpu/glm/gtx/number_precision.hpp
type glm (line 51) | namespace glm{
type gtx (line 52) | namespace gtx
FILE: cpu/glm/gtx/optimum_pow.hpp
type glm (line 48) | namespace glm{
type gtx (line 49) | namespace gtx
FILE: cpu/glm/gtx/orthonormalize.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/perpendicular.hpp
type glm (line 50) | namespace glm
FILE: cpu/glm/gtx/polar_coordinates.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/projection.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/quaternion.hpp
type glm (line 52) | namespace glm
function toMat3 (line 150) | detail::tmat3x3<T, P> toMat3(
function toMat4 (line 157) | detail::tmat4x4<T, P> toMat4(
function toQuat (line 164) | detail::tquat<T, P> toQuat(
function toQuat (line 171) | detail::tquat<T, P> toQuat(
FILE: cpu/glm/gtx/raw_data.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/rotate_normalized_axis.hpp
type glm (line 52) | namespace glm
FILE: cpu/glm/gtx/rotate_vector.hpp
type glm (line 50) | namespace glm
FILE: cpu/glm/gtx/scalar_relational.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/simd_mat4.hpp
type ctor (line 64) | enum ctor{_null}
FILE: cpu/glm/gtx/simd_quat.hpp
type ctor (line 75) | enum ctor{null}
FILE: cpu/glm/gtx/simd_vec4.hpp
type glm (line 65) | namespace glm
type comp (line 67) | enum comp
type ctor (line 92) | enum ctor{null}
FILE: cpu/glm/gtx/spline.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/std_based_type.hpp
type glm (line 49) | namespace glm
FILE: cpu/glm/gtx/string_cast.hpp
type glm (line 54) | namespace glm
FILE: cpu/glm/gtx/transform.hpp
type glm (line 52) | namespace glm
FILE: cpu/glm/gtx/transform2.hpp
type glm (line 50) | namespace glm
FILE: cpu/glm/gtx/vec1.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/gtx/vector_angle.hpp
type glm (line 53) | namespace glm
FILE: cpu/glm/gtx/vector_query.hpp
type glm (line 50) | namespace glm
FILE: cpu/glm/gtx/wrap.hpp
type glm (line 48) | namespace glm
FILE: cpu/glm/mat2x2.hpp
type glm (line 34) | namespace glm
FILE: cpu/glm/mat2x3.hpp
type glm (line 34) | namespace glm
FILE: cpu/glm/mat2x4.hpp
type glm (line 34) | namespace glm
FILE: cpu/glm/mat3x2.hpp
type glm (line 34) | namespace glm
FILE: cpu/glm/mat3x3.hpp
type glm (line 34) | namespace glm
FILE: cpu/glm/mat3x4.hpp
type glm (line 34) | namespace glm
FILE: cpu/glm/mat4x2.hpp
type glm (line 34) | namespace glm
FILE: cpu/glm/mat4x3.hpp
type glm (line 34) | namespace glm
FILE: cpu/glm/mat4x4.hpp
type glm (line 34) | namespace glm
FILE: cpu/src/constraint/boundaryconstraint.h
function class (line 7) | class BoundaryConstraint : public Constraint
FILE: cpu/src/constraint/contactconstraint.h
function class (line 7) | class ContactConstraint : public Constraint
FILE: cpu/src/constraint/distanceconstraint.h
function class (line 7) | class DistanceConstraint : public Constraint
FILE: cpu/src/constraint/gasconstraint.h
function class (line 25) | class GasConstraint : public Constraint
FILE: cpu/src/constraint/rigidcontactconstraint.h
function class (line 6) | class RigidContactConstraint : public Constraint
FILE: cpu/src/constraint/smokeparticle.h
function class (line 4) | class SmokeParticle
FILE: cpu/src/constraint/totalfluidconstraint.h
function class (line 34) | class TotalFluidConstraint : public Constraint
FILE: cpu/src/constraint/totalshapeconstraint.h
function class (line 6) | class TotalShapeConstraint : public Constraint
FILE: cpu/src/fluidemitter.h
function class (line 13) | class FluidEmitter
FILE: cpu/src/includes.h
function frand (line 25) | inline float frand() { return (double)rand() / (double)RAND_MAX; }
function urand (line 26) | inline float urand(double a, double b) { return a + (b - a) * frand(); }
function printVec (line 30) | inline void printVec(const glm::dvec2 v) {
FILE: cpu/src/main.cpp
function main (line 4) | int main(int argc, char *argv[])
FILE: cpu/src/mainwindow.h
function namespace (line 6) | namespace Ui {
function class (line 10) | class MainWindow : public QMainWindow
FILE: cpu/src/opensmokeemitter.h
function class (line 13) | class OpenSmokeEmitter
FILE: cpu/src/particle.h
type Phase (line 10) | enum Phase {
type Body (line 17) | struct Body
type SDFData (line 18) | struct SDFData
type Particle (line 21) | struct Particle
function init (line 37) | void init(double mass) {
function setStatic (line 54) | inline void setStatic() { imass = 0.; }
function glm (line 56) | inline glm::dvec2 guess(double seconds) {
function confirmGuess (line 60) | inline void confirmGuess() {
function scaleMass (line 67) | void scaleMass() {
function glm (line 76) | inline glm::dvec2 getP(bool stabile) { return stabile ? p : ep; }
type SDFData (line 82) | struct SDFData {
type ConstraintGroup (line 96) | enum ConstraintGroup {
function class (line 105) | class Constraint
type Body (line 126) | struct Body
FILE: cpu/src/simulation.cpp
function Body (line 371) | Body *Simulation::createRigidBody(QList<Particle *> *verts, QList<SDFDat...
function GasConstraint (line 408) | GasConstraint *Simulation::createGas(QList<Particle *> *verts, double de...
function TotalFluidConstraint (line 431) | TotalFluidConstraint *Simulation::createFluid(QList<Particle *> *verts, ...
FILE: cpu/src/simulation.h
type SimulationType (line 24) | enum SimulationType {
function class (line 45) | class Simulation
FILE: cpu/src/solver/lineareq.cpp
type SparseMatrixElement (line 20) | struct SparseMatrixElement {
method SparseMatrixElement (line 25) | inline SparseMatrixElement() {
method SparseMatrixElement (line 31) | inline SparseMatrixElement(unsigned r, unsigned c, double v) {
FILE: cpu/src/solver/lineareq.h
type LinearData (line 27) | struct LinearData {
function SparseMatrix (line 135) | inline const SparseMatrix *getA() const {
FILE: cpu/src/solver/matrix.cpp
function SparseMatrix (line 16) | SparseMatrix SparseMatrix::getTranspose() const {
FILE: cpu/src/solver/matrix.h
type map (line 21) | typedef map<int, double> SparseColArray;
type SparseColArray (line 22) | typedef SparseColArray::iterator SparseColArrayIterator;
type SparseColArray (line 23) | typedef SparseColArray::const_iterator SparseColArrayConstIterator;
type map (line 25) | typedef map<int, SparseColArray > SparseArray;
type SparseArray (line 26) | typedef SparseArray::iterator SparseArrayIterator;
type SparseArray (line 27) | typedef SparseArray::const_iterator SparseArrayConstIterator;
function class (line 29) | class SparseMatrix {
function SparseMatrix (line 68) | static inline SparseMatrix identity(int n) {
function getM (line 82) | inline int getM() const;
FILE: cpu/src/solver/particle.cpp
function SDFData (line 3) | SDFData Particle::getSDFData(QList<Body *> *bodies, int idx)
FILE: cpu/src/solver/solver.h
function class (line 10) | class Solver
FILE: cpu/src/view.h
function class (line 9) | class View : public QGLWidget
FILE: gpu/glm/detail/_literals.hpp
type glm (line 32) | namespace glm
FILE: gpu/glm/detail/_noise.hpp
type glm (line 32) | namespace glm{
type detail (line 33) | namespace detail
function GLM_FUNC_QUALIFIER (line 36) | GLM_FUNC_QUALIFIER T mod289(T const & x)
function GLM_FUNC_QUALIFIER (line 42) | GLM_FUNC_QUALIFIER T permute(T const & x)
function GLM_FUNC_QUALIFIER (line 48) | GLM_FUNC_QUALIFIER tvec2<T, P> permute(tvec2<T, P> const & x)
function GLM_FUNC_QUALIFIER (line 54) | GLM_FUNC_QUALIFIER tvec3<T, P> permute(tvec3<T, P> const & x)
function GLM_FUNC_QUALIFIER (line 60) | GLM_FUNC_QUALIFIER tvec4<T, P> permute(tvec4<T, P> const & x)
function GLM_FUNC_QUALIFIER (line 72) | GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
function GLM_FUNC_QUALIFIER (line 78) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> taylorInvSqrt(detail::tvec2<T...
function GLM_FUNC_QUALIFIER (line 84) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> taylorInvSqrt(detail::tvec3<T...
function GLM_FUNC_QUALIFIER (line 90) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> taylorInvSqrt(detail::tvec4<T...
function GLM_FUNC_QUALIFIER (line 103) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> fade(detail::tvec2<T, P> cons...
function GLM_FUNC_QUALIFIER (line 109) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> fade(detail::tvec3<T, P> cons...
function GLM_FUNC_QUALIFIER (line 115) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> fade(detail::tvec4<T, P> cons...
FILE: gpu/glm/detail/_swizzle.hpp
type glm (line 32) | namespace glm{
type detail (line 33) | namespace detail
type _swizzle_base0 (line 37) | struct _swizzle_base0
method GLM_FUNC_QUALIFIER (line 42) | GLM_FUNC_QUALIFIER value_type& elem (size_t i) { r...
method GLM_FUNC_QUALIFIER (line 43) | GLM_FUNC_QUALIFIER const value_type& elem (size_t i) const { r...
type _swizzle_base1 (line 52) | struct _swizzle_base1 : public _swizzle_base0<T, N>
type _swizzle_base1<T, P, V,E0,E1,-1,-2,2> (line 57) | struct _swizzle_base1<T, P, V,E0,E1,-1,-2,2> : public _swizzle_base0...
method GLM_FUNC_QUALIFIER (line 59) | GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0...
type _swizzle_base1<T, P, V,E0,E1,E2,-1,3> (line 63) | struct _swizzle_base1<T, P, V,E0,E1,E2,-1,3> : public _swizzle_base0...
method GLM_FUNC_QUALIFIER (line 65) | GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0...
type _swizzle_base1<T, P, V,E0,E1,E2,E3,4> (line 69) | struct _swizzle_base1<T, P, V,E0,E1,E2,E3,4> : public _swizzle_base0...
method GLM_FUNC_QUALIFIER (line 71) | GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0...
type _swizzle_base2 (line 87) | struct _swizzle_base2 : public _swizzle_base1<ValueType, P, VecType,...
method GLM_FUNC_QUALIFIER (line 92) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t)
method GLM_FUNC_QUALIFIER (line 99) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that)
method GLM_FUNC_QUALIFIER (line 108) | GLM_FUNC_QUALIFIER void operator -= (const VecType& that)
method GLM_FUNC_QUALIFIER (line 116) | GLM_FUNC_QUALIFIER void operator += (const VecType& that)
method GLM_FUNC_QUALIFIER (line 124) | GLM_FUNC_QUALIFIER void operator *= (const VecType& that)
method GLM_FUNC_QUALIFIER (line 132) | GLM_FUNC_QUALIFIER void operator /= (const VecType& that)
method GLM_FUNC_QUALIFIER (line 140) | GLM_FUNC_QUALIFIER value_type& operator[] (size_t i)
method GLM_FUNC_QUALIFIER (line 158) | GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op)
type _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,1> (line 173) | struct _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,1> : publi...
type Stub (line 178) | struct Stub {}
method GLM_FUNC_QUALIFIER (line 179) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { retu...
type _swizzle (line 192) | struct _swizzle : public _swizzle_base2<ValueType, P, VecType, N,E0,...
method GLM_FUNC_QUALIFIER (line 198) | GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); }
FILE: gpu/glm/detail/_vectorize.hpp
type glm (line 192) | namespace glm{
type detail (line 193) | namespace detail
type If (line 196) | struct If
method GLM_FUNC_QUALIFIER (line 199) | static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
type If<false> (line 206) | struct If<false>
method GLM_FUNC_QUALIFIER (line 209) | static GLM_FUNC_QUALIFIER T apply(F, const T& val)
FILE: gpu/glm/detail/dummy.cpp
class C (line 62) | class C
class C (line 65) | class C
function main (line 71) | int main()
FILE: gpu/glm/detail/func_common.hpp
type glm (line 44) | namespace glm
FILE: gpu/glm/detail/func_exponential.hpp
type glm (line 45) | namespace glm
FILE: gpu/glm/detail/func_geometric.hpp
type glm (line 41) | namespace glm
FILE: gpu/glm/detail/func_integer.hpp
type glm (line 43) | namespace glm
FILE: gpu/glm/detail/func_matrix.hpp
type glm (line 60) | namespace glm{
type detail (line 61) | namespace detail
type outerProduct_trait<T, P, tvec2, tvec2> (line 64) | struct outerProduct_trait<T, P, tvec2, tvec2>
type outerProduct_trait<T, P, tvec2, tvec3> (line 70) | struct outerProduct_trait<T, P, tvec2, tvec3>
type outerProduct_trait<T, P, tvec2, tvec4> (line 76) | struct outerProduct_trait<T, P, tvec2, tvec4>
type outerProduct_trait<T, P, tvec3, tvec2> (line 82) | struct outerProduct_trait<T, P, tvec3, tvec2>
type outerProduct_trait<T, P, tvec3, tvec3> (line 88) | struct outerProduct_trait<T, P, tvec3, tvec3>
type outerProduct_trait<T, P, tvec3, tvec4> (line 94) | struct outerProduct_trait<T, P, tvec3, tvec4>
type outerProduct_trait<T, P, tvec4, tvec2> (line 100) | struct outerProduct_trait<T, P, tvec4, tvec2>
type outerProduct_trait<T, P, tvec4, tvec3> (line 106) | struct outerProduct_trait<T, P, tvec4, tvec3>
type outerProduct_trait<T, P, tvec4, tvec4> (line 112) | struct outerProduct_trait<T, P, tvec4, tvec4>
FILE: gpu/glm/detail/func_noise.hpp
type glm (line 46) | namespace glm
FILE: gpu/glm/detail/func_packing.hpp
type glm (line 42) | namespace glm
FILE: gpu/glm/detail/func_trigonometric.hpp
type glm (line 43) | namespace glm
FILE: gpu/glm/detail/func_vector_relational.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/detail/glm.cpp
type glm (line 33) | namespace glm{
type detail (line 34) | namespace detail
type tvec2<uint8, lowp> (line 75) | struct tvec2<uint8, lowp>
type tvec2<uint16, lowp> (line 76) | struct tvec2<uint16, lowp>
type tvec2<uint32, lowp> (line 77) | struct tvec2<uint32, lowp>
type tvec2<uint64, lowp> (line 78) | struct tvec2<uint64, lowp>
type tvec2<int8, lowp> (line 79) | struct tvec2<int8, lowp>
type tvec2<int16, lowp> (line 80) | struct tvec2<int16, lowp>
type tvec2<int32, lowp> (line 81) | struct tvec2<int32, lowp>
type tvec2<int64, lowp> (line 82) | struct tvec2<int64, lowp>
type tvec2<float32, lowp> (line 83) | struct tvec2<float32, lowp>
type tvec2<float64, lowp> (line 84) | struct tvec2<float64, lowp>
type tvec2<uint8, mediump> (line 86) | struct tvec2<uint8, mediump>
type tvec2<uint16, mediump> (line 87) | struct tvec2<uint16, mediump>
type tvec2<uint32, mediump> (line 88) | struct tvec2<uint32, mediump>
type tvec2<uint64, mediump> (line 89) | struct tvec2<uint64, mediump>
type tvec2<int8, mediump> (line 90) | struct tvec2<int8, mediump>
type tvec2<int16, mediump> (line 91) | struct tvec2<int16, mediump>
type tvec2<int32, mediump> (line 92) | struct tvec2<int32, mediump>
type tvec2<int64, mediump> (line 93) | struct tvec2<int64, mediump>
type tvec2<float32, mediump> (line 94) | struct tvec2<float32, mediump>
type tvec2<float64, mediump> (line 95) | struct tvec2<float64, mediump>
type tvec2<uint8, highp> (line 97) | struct tvec2<uint8, highp>
type tvec2<uint16, highp> (line 98) | struct tvec2<uint16, highp>
type tvec2<uint32, highp> (line 99) | struct tvec2<uint32, highp>
type tvec2<uint64, highp> (line 100) | struct tvec2<uint64, highp>
type tvec2<int8, highp> (line 101) | struct tvec2<int8, highp>
type tvec2<int16, highp> (line 102) | struct tvec2<int16, highp>
type tvec2<int32, highp> (line 103) | struct tvec2<int32, highp>
type tvec2<int64, highp> (line 104) | struct tvec2<int64, highp>
type tvec2<float32, highp> (line 105) | struct tvec2<float32, highp>
type tvec2<float64, highp> (line 106) | struct tvec2<float64, highp>
type tvec3<uint8, lowp> (line 109) | struct tvec3<uint8, lowp>
type tvec3<uint16, lowp> (line 110) | struct tvec3<uint16, lowp>
type tvec3<uint32, lowp> (line 111) | struct tvec3<uint32, lowp>
type tvec3<uint64, lowp> (line 112) | struct tvec3<uint64, lowp>
type tvec3<int8, lowp> (line 113) | struct tvec3<int8, lowp>
type tvec3<int16, lowp> (line 114) | struct tvec3<int16, lowp>
type tvec3<int32, lowp> (line 115) | struct tvec3<int32, lowp>
type tvec3<int64, lowp> (line 116) | struct tvec3<int64, lowp>
type tvec3<float32, lowp> (line 117) | struct tvec3<float32, lowp>
type tvec3<float64, lowp> (line 118) | struct tvec3<float64, lowp>
type tvec3<uint8, mediump> (line 120) | struct tvec3<uint8, mediump>
type tvec3<uint16, mediump> (line 121) | struct tvec3<uint16, mediump>
type tvec3<uint32, mediump> (line 122) | struct tvec3<uint32, mediump>
type tvec3<uint64, mediump> (line 123) | struct tvec3<uint64, mediump>
type tvec3<int8, mediump> (line 124) | struct tvec3<int8, mediump>
type tvec3<int16, mediump> (line 125) | struct tvec3<int16, mediump>
type tvec3<int32, mediump> (line 126) | struct tvec3<int32, mediump>
type tvec3<int64, mediump> (line 127) | struct tvec3<int64, mediump>
type tvec3<float32, mediump> (line 128) | struct tvec3<float32, mediump>
type tvec3<float64, mediump> (line 129) | struct tvec3<float64, mediump>
type tvec3<uint8, highp> (line 131) | struct tvec3<uint8, highp>
type tvec3<uint16, highp> (line 132) | struct tvec3<uint16, highp>
type tvec3<uint32, highp> (line 133) | struct tvec3<uint32, highp>
type tvec3<uint64, highp> (line 134) | struct tvec3<uint64, highp>
type tvec3<int8, highp> (line 135) | struct tvec3<int8, highp>
type tvec3<int16, highp> (line 136) | struct tvec3<int16, highp>
type tvec3<int32, highp> (line 137) | struct tvec3<int32, highp>
type tvec3<int64, highp> (line 138) | struct tvec3<int64, highp>
type tvec3<float32, highp> (line 139) | struct tvec3<float32, highp>
type tvec3<float64, highp> (line 140) | struct tvec3<float64, highp>
type tvec4<uint8, lowp> (line 143) | struct tvec4<uint8, lowp>
type tvec4<uint16, lowp> (line 144) | struct tvec4<uint16, lowp>
type tvec4<uint32, lowp> (line 145) | struct tvec4<uint32, lowp>
type tvec4<uint64, lowp> (line 146) | struct tvec4<uint64, lowp>
type tvec4<int8, lowp> (line 147) | struct tvec4<int8, lowp>
type tvec4<int16, lowp> (line 148) | struct tvec4<int16, lowp>
type tvec4<int32, lowp> (line 149) | struct tvec4<int32, lowp>
type tvec4<int64, lowp> (line 150) | struct tvec4<int64, lowp>
type tvec4<float32, lowp> (line 151) | struct tvec4<float32, lowp>
type tvec4<float64, lowp> (line 152) | struct tvec4<float64, lowp>
type tvec4<uint8, mediump> (line 154) | struct tvec4<uint8, mediump>
type tvec4<uint16, mediump> (line 155) | struct tvec4<uint16, mediump>
type tvec4<uint32, mediump> (line 156) | struct tvec4<uint32, mediump>
type tvec4<uint64, mediump> (line 157) | struct tvec4<uint64, mediump>
type tvec4<int8, mediump> (line 158) | struct tvec4<int8, mediump>
type tvec4<int16, mediump> (line 159) | struct tvec4<int16, mediump>
type tvec4<int32, mediump> (line 160) | struct tvec4<int32, mediump>
type tvec4<int64, mediump> (line 161) | struct tvec4<int64, mediump>
type tvec4<float32, mediump> (line 162) | struct tvec4<float32, mediump>
type tvec4<float64, mediump> (line 163) | struct tvec4<float64, mediump>
type tvec4<uint8, highp> (line 165) | struct tvec4<uint8, highp>
type tvec4<uint16, highp> (line 166) | struct tvec4<uint16, highp>
type tvec4<uint32, highp> (line 167) | struct tvec4<uint32, highp>
type tvec4<uint64, highp> (line 168) | struct tvec4<uint64, highp>
type tvec4<int8, highp> (line 169) | struct tvec4<int8, highp>
type tvec4<int16, highp> (line 170) | struct tvec4<int16, highp>
type tvec4<int32, highp> (line 171) | struct tvec4<int32, highp>
type tvec4<int64, highp> (line 172) | struct tvec4<int64, highp>
type tvec4<float32, highp> (line 173) | struct tvec4<float32, highp>
type tvec4<float64, highp> (line 174) | struct tvec4<float64, highp>
type tmat2x2<float32, lowp> (line 177) | struct tmat2x2<float32, lowp>
type tmat2x2<float64, lowp> (line 178) | struct tmat2x2<float64, lowp>
type tmat2x2<float32, mediump> (line 180) | struct tmat2x2<float32, mediump>
type tmat2x2<float64, mediump> (line 181) | struct tmat2x2<float64, mediump>
type tmat2x2<float32, highp> (line 183) | struct tmat2x2<float32, highp>
type tmat2x2<float64, highp> (line 184) | struct tmat2x2<float64, highp>
type tmat2x3<float32, lowp> (line 187) | struct tmat2x3<float32, lowp>
type tmat2x3<float64, lowp> (line 188) | struct tmat2x3<float64, lowp>
type tmat2x3<float32, mediump> (line 190) | struct tmat2x3<float32, mediump>
type tmat2x3<float64, mediump> (line 191) | struct tmat2x3<float64, mediump>
type tmat2x3<float32, highp> (line 193) | struct tmat2x3<float32, highp>
type tmat2x3<float64, highp> (line 194) | struct tmat2x3<float64, highp>
type tmat2x4<float32, lowp> (line 197) | struct tmat2x4<float32, lowp>
type tmat2x4<float64, lowp> (line 198) | struct tmat2x4<float64, lowp>
type tmat2x4<float32, mediump> (line 200) | struct tmat2x4<float32, mediump>
type tmat2x4<float64, mediump> (line 201) | struct tmat2x4<float64, mediump>
type tmat2x4<float32, highp> (line 203) | struct tmat2x4<float32, highp>
type tmat2x4<float64, highp> (line 204) | struct tmat2x4<float64, highp>
type tmat3x2<float32, lowp> (line 207) | struct tmat3x2<float32, lowp>
type tmat3x2<float64, lowp> (line 208) | struct tmat3x2<float64, lowp>
type tmat3x2<float32, mediump> (line 210) | struct tmat3x2<float32, mediump>
type tmat3x2<float64, mediump> (line 211) | struct tmat3x2<float64, mediump>
type tmat3x2<float32, highp> (line 213) | struct tmat3x2<float32, highp>
type tmat3x2<float64, highp> (line 214) | struct tmat3x2<float64, highp>
type tmat3x3<float32, lowp> (line 217) | struct tmat3x3<float32, lowp>
type tmat3x3<float64, lowp> (line 218) | struct tmat3x3<float64, lowp>
type tmat3x3<float32, mediump> (line 220) | struct tmat3x3<float32, mediump>
type tmat3x3<float64, mediump> (line 221) | struct tmat3x3<float64, mediump>
type tmat3x3<float32, highp> (line 223) | struct tmat3x3<float32, highp>
type tmat3x3<float64, highp> (line 224) | struct tmat3x3<float64, highp>
type tmat3x4<float32, lowp> (line 227) | struct tmat3x4<float32, lowp>
type tmat3x4<float64, lowp> (line 228) | struct tmat3x4<float64, lowp>
type tmat3x4<float32, mediump> (line 230) | struct tmat3x4<float32, mediump>
type tmat3x4<float64, mediump> (line 231) | struct tmat3x4<float64, mediump>
type tmat3x4<float32, highp> (line 233) | struct tmat3x4<float32, highp>
type tmat3x4<float64, highp> (line 234) | struct tmat3x4<float64, highp>
type tmat4x2<float32, lowp> (line 237) | struct tmat4x2<float32, lowp>
type tmat4x2<float64, lowp> (line 238) | struct tmat4x2<float64, lowp>
type tmat4x2<float32, mediump> (line 240) | struct tmat4x2<float32, mediump>
type tmat4x2<float64, mediump> (line 241) | struct tmat4x2<float64, mediump>
type tmat4x2<float32, highp> (line 243) | struct tmat4x2<float32, highp>
type tmat4x2<float64, highp> (line 244) | struct tmat4x2<float64, highp>
type tmat4x3<float32, lowp> (line 247) | struct tmat4x3<float32, lowp>
type tmat4x3<float64, lowp> (line 248) | struct tmat4x3<float64, lowp>
type tmat4x3<float32, mediump> (line 250) | struct tmat4x3<float32, mediump>
type tmat4x3<float64, mediump> (line 251) | struct tmat4x3<float64, mediump>
type tmat4x3<float32, highp> (line 253) | struct tmat4x3<float32, highp>
type tmat4x3<float64, highp> (line 254) | struct tmat4x3<float64, highp>
type tmat4x4<float32, lowp> (line 257) | struct tmat4x4<float32, lowp>
type tmat4x4<float64, lowp> (line 258) | struct tmat4x4<float64, lowp>
type tmat4x4<float32, mediump> (line 260) | struct tmat4x4<float32, mediump>
type tmat4x4<float64, mediump> (line 261) | struct tmat4x4<float64, mediump>
type tmat4x4<float32, highp> (line 263) | struct tmat4x4<float32, highp>
type tmat4x4<float64, highp> (line 264) | struct tmat4x4<float64, highp>
type tquat<float32, lowp> (line 267) | struct tquat<float32, lowp>
type tquat<float64, lowp> (line 268) | struct tquat<float64, lowp>
type tquat<float32, mediump> (line 270) | struct tquat<float32, mediump>
type tquat<float64, mediump> (line 271) | struct tquat<float64, mediump>
type tquat<float32, highp> (line 273) | struct tquat<float32, highp>
type tquat<float64, highp> (line 274) | struct tquat<float64, highp>
type tdualquat<float32, lowp> (line 277) | struct tdualquat<float32, lowp>
type tdualquat<float64, lowp> (line 278) | struct tdualquat<float64, lowp>
type tdualquat<float32, mediump> (line 280) | struct tdualquat<float32, mediump>
type tdualquat<float64, mediump> (line 281) | struct tdualquat<float64, mediump>
type tdualquat<float32, highp> (line 283) | struct tdualquat<float32, highp>
type tdualquat<float64, highp> (line 284) | struct tdualquat<float64, highp>
FILE: gpu/glm/detail/hint.hpp
type glm (line 32) | namespace glm
class dont_care (line 35) | class dont_care {}
class nicest (line 36) | class nicest {}
class fastest (line 37) | class fastest {}
FILE: gpu/glm/detail/intrinsic_common.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: gpu/glm/detail/intrinsic_exponential.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: gpu/glm/detail/intrinsic_geometric.hpp
type glm (line 40) | namespace glm{
type detail (line 41) | namespace detail
FILE: gpu/glm/detail/intrinsic_integer.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: gpu/glm/detail/intrinsic_matrix.hpp
type glm (line 40) | namespace glm{
type detail (line 41) | namespace detail
FILE: gpu/glm/detail/intrinsic_trigonometric.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: gpu/glm/detail/intrinsic_vector_relational.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: gpu/glm/detail/precision.hpp
type glm (line 32) | namespace glm
type precision (line 34) | enum precision
FILE: gpu/glm/detail/setup.hpp
function _mm_cvtss_f32 (line 635) | inline float _mm_cvtss_f32(__m128 A) { return A.m128_f32[0]; }
function __m128 (line 636) | inline __m128 _mm_castpd_ps(__m128d PD) { union { __m128 ps; __m128d pd;...
function __m128d (line 637) | inline __m128d _mm_castps_pd(__m128 PS) { union { __m128 ps; __m128d pd;...
function __m128i (line 638) | inline __m128i _mm_castps_si128(__m128 PS) { union { __m128 ps; __m128i ...
function __m128 (line 639) | inline __m128 _mm_castsi128_ps(__m128i PI) { union { __m128 ps; __m128i ...
type glm (line 736) | namespace glm
FILE: gpu/glm/detail/type_float.hpp
type glm (line 34) | namespace glm{
type detail (line 35) | namespace detail
FILE: gpu/glm/detail/type_gentype.hpp
type glm (line 32) | namespace glm
type profile (line 34) | enum profile
type detail (line 43) | namespace detail
type genType (line 50) | struct genType
type ctor (line 53) | enum ctor{null}
method value_const_pointer (line 77) | value_const_pointer value_address() const{return value_pointer(thi...
method value_pointer (line 78) | value_pointer value_address(){return value_pointer(this);}
FILE: gpu/glm/detail/type_half.hpp
type glm (line 34) | namespace glm{
type detail (line 35) | namespace detail
FILE: gpu/glm/detail/type_int.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
FILE: gpu/glm/detail/type_mat.hpp
type glm (line 34) | namespace glm{
type detail (line 35) | namespace detail
type tvec2 (line 37) | struct tvec2
type tvec3 (line 38) | struct tvec3
type tvec4 (line 39) | struct tvec4
type tmat2x2 (line 40) | struct tmat2x2
type tmat2x3 (line 41) | struct tmat2x3
type tmat2x4 (line 42) | struct tmat2x4
type tmat3x2 (line 43) | struct tmat3x2
type tmat3x3 (line 44) | struct tmat3x3
type tmat3x4 (line 45) | struct tmat3x4
type tmat4x2 (line 46) | struct tmat4x2
type tmat4x3 (line 47) | struct tmat4x3
type tmat4x4 (line 48) | struct tmat4x4
type outerProduct_trait (line 51) | struct outerProduct_trait{}
type compute_inverse (line 54) | struct compute_inverse{}
FILE: gpu/glm/detail/type_mat2x2.hpp
type glm (line 37) | namespace glm{
type detail (line 38) | namespace detail
type tmat2x2 (line 41) | struct tmat2x2
type ctor (line 43) | enum ctor{_null}
FILE: gpu/glm/detail/type_mat2x3.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat2x3 (line 42) | struct tmat2x3
type ctor (line 44) | enum ctor{_null}
FILE: gpu/glm/detail/type_mat2x4.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat2x4 (line 42) | struct tmat2x4
type ctor (line 44) | enum ctor{_null}
FILE: gpu/glm/detail/type_mat3x2.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat3x2 (line 42) | struct tmat3x2
type ctor (line 44) | enum ctor{_null}
FILE: gpu/glm/detail/type_mat3x3.hpp
type glm (line 37) | namespace glm{
type detail (line 38) | namespace detail
type tmat3x3 (line 41) | struct tmat3x3
type ctor (line 43) | enum ctor{_null}
FILE: gpu/glm/detail/type_mat3x4.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat3x4 (line 42) | struct tmat3x4
type ctor (line 44) | enum ctor{_null}
FILE: gpu/glm/detail/type_mat4x2.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat4x2 (line 42) | struct tmat4x2
type ctor (line 44) | enum ctor{_null}
FILE: gpu/glm/detail/type_mat4x3.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat4x3 (line 42) | struct tmat4x3
type ctor (line 44) | enum ctor{_null}
FILE: gpu/glm/detail/type_mat4x4.hpp
type glm (line 38) | namespace glm{
type detail (line 39) | namespace detail
type tmat4x4 (line 42) | struct tmat4x4
type ctor (line 44) | enum ctor{_null}
FILE: gpu/glm/detail/type_vec.hpp
type glm (line 35) | namespace glm{
type detail (line 36) | namespace detail
type tvec1 (line 38) | struct tvec1
type tvec2 (line 39) | struct tvec2
type tvec3 (line 40) | struct tvec3
type tvec4 (line 41) | struct tvec4
FILE: gpu/glm/detail/type_vec1.hpp
type glm (line 43) | namespace glm{
type detail (line 44) | namespace detail
type tvec1 (line 47) | struct tvec1
type ctor (line 52) | enum ctor{_null}
FILE: gpu/glm/detail/type_vec2.hpp
type ctor (line 52) | enum ctor{_null}
function GLM_FUNC_DECL (line 123) | GLM_FUNC_DECL tvec2(_swizzle<2,T, P, tvec2<T, P>, E0, E1,-1,-2> const & ...
FILE: gpu/glm/detail/type_vec3.hpp
type ctor (line 52) | enum ctor{_null}
function GLM_FUNC_DECL (line 151) | GLM_FUNC_DECL tvec3(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const...
function GLM_FUNC_DECL (line 157) | GLM_FUNC_DECL tvec3(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const...
function GLM_FUNC_DECL (line 163) | GLM_FUNC_DECL tvec3(T const & s, _swizzle<2, T, P, tvec2<T, P>, E0, E1, ...
FILE: gpu/glm/detail/type_vec4.hpp
type ctor (line 53) | enum ctor{_null}
function GLM_FUNC_DECL (line 164) | GLM_FUNC_DECL tvec4(_swizzle<4, T, P, tvec4<T, P>, E0, E1, E2, E3> const...
function GLM_FUNC_DECL (line 170) | GLM_FUNC_DECL tvec4(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const...
function GLM_FUNC_DECL (line 176) | GLM_FUNC_DECL tvec4(T const & x, T const & y, _swizzle<2, T, P, tvec2<T,...
function GLM_FUNC_DECL (line 182) | GLM_FUNC_DECL tvec4(T const & x, _swizzle<2, T, P, tvec2<T, P>, E0, E1, ...
function GLM_FUNC_DECL (line 188) | GLM_FUNC_DECL tvec4(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const...
function GLM_FUNC_DECL (line 194) | GLM_FUNC_DECL tvec4(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const...
function GLM_FUNC_DECL (line 200) | GLM_FUNC_DECL tvec4(T const & x, _swizzle<3, T, P, tvec3<T, P>, E0, E1, ...
FILE: gpu/glm/fwd.hpp
type glm (line 39) | namespace glm{
type detail (line 40) | namespace detail
type tquat (line 42) | struct tquat
type glm (line 125) | namespace glm
type detail (line 40) | namespace detail
type tquat (line 42) | struct tquat
FILE: gpu/glm/gtc/constants.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtc/epsilon.hpp
type glm (line 51) | namespace glm
FILE: gpu/glm/gtc/matrix_access.hpp
type glm (line 47) | namespace glm
FILE: gpu/glm/gtc/matrix_integer.hpp
type glm (line 55) | namespace glm
FILE: gpu/glm/gtc/matrix_inverse.hpp
type glm (line 47) | namespace glm
FILE: gpu/glm/gtc/matrix_transform.hpp
type glm (line 59) | namespace glm
FILE: gpu/glm/gtc/noise.hpp
type glm (line 52) | namespace glm
FILE: gpu/glm/gtc/packing.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtc/quaternion.hpp
type glm (line 54) | namespace glm{
type detail (line 55) | namespace detail
type tquat (line 58) | struct tquat
type ctor (line 60) | enum ctor{null}
FILE: gpu/glm/gtc/random.hpp
type glm (line 51) | namespace glm
FILE: gpu/glm/gtc/reciprocal.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtc/type_precision.hpp
type glm (line 65) | namespace glm
FILE: gpu/glm/gtc/type_ptr.hpp
type glm (line 82) | namespace glm
FILE: gpu/glm/gtc/ulp.hpp
type glm (line 51) | namespace glm
FILE: gpu/glm/gtx/associated_min_max.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/bit.hpp
type glm (line 51) | namespace glm
FILE: gpu/glm/gtx/closest_point.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/color_space.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/color_space_YCoCg.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/compatibility.hpp
type glm (line 59) | namespace glm
function GLM_FUNC_QUALIFIER (line 64) | GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}
function GLM_FUNC_QUALIFIER (line 65) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>&...
function GLM_FUNC_QUALIFIER (line 67) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>&...
function GLM_FUNC_QUALIFIER (line 68) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>&...
function GLM_FUNC_QUALIFIER (line 69) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>&...
function GLM_FUNC_QUALIFIER (line 70) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>&...
function GLM_FUNC_QUALIFIER (line 71) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>&...
function GLM_FUNC_QUALIFIER (line 73) | GLM_FUNC_QUALIFIER T slerp(detail::tquat<T, P> const & x, detail::tqua...
function GLM_FUNC_QUALIFIER (line 75) | GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}
function GLM_FUNC_QUALIFIER (line 76) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> saturate(const detail::tvec2<T,...
function GLM_FUNC_QUALIFIER (line 77) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturate(const detail::tvec3<T,...
function GLM_FUNC_QUALIFIER (line 78) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturate(const detail::tvec4<T,...
function GLM_FUNC_QUALIFIER (line 80) | GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}
function GLM_FUNC_QUALIFIER (line 81) | GLM_FUNC_QUALIFIER detail::tvec2<T, P> atan2(const detail::tvec2<T, P>...
function GLM_FUNC_QUALIFIER (line 82) | GLM_FUNC_QUALIFIER detail::tvec3<T, P> atan2(const detail::tvec3<T, P>...
function GLM_FUNC_QUALIFIER (line 83) | GLM_FUNC_QUALIFIER detail::tvec4<T, P> atan2(const detail::tvec4<T, P>...
FILE: gpu/glm/gtx/component_wise.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/dual_quaternion.hpp
type glm (line 53) | namespace glm{
type detail (line 54) | namespace detail
type tdualquat (line 57) | struct tdualquat
type ctor (line 59) | enum ctor{null}
FILE: gpu/glm/gtx/euler_angles.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/extend.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/extented_min_max.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/fast_exponential.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/fast_square_root.hpp
type glm (line 50) | namespace glm
FILE: gpu/glm/gtx/fast_trigonometry.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/gradient_paint.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/handed_coordinate_space.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/inertia.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/int_10_10_10_2.hpp
type glm (line 35) | namespace glm
FILE: gpu/glm/gtx/integer.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/intersect.hpp
type glm (line 50) | namespace glm
FILE: gpu/glm/gtx/io.hpp
type glm (line 53) | namespace glm
type io (line 58) | namespace io
class precision_guard (line 61) | class precision_guard {
class format_guard (line 75) | class format_guard
type order_t (line 78) | enum order_t { column_major, row_major, }
type detail (line 115) | namespace detail
FILE: gpu/glm/gtx/log_base.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/matrix_cross_product.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/matrix_interpolation.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/matrix_major_storage.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/matrix_operation.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/matrix_query.hpp
type glm (line 51) | namespace glm
FILE: gpu/glm/gtx/mixed_product.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/multiple.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/norm.hpp
type glm (line 50) | namespace glm
FILE: gpu/glm/gtx/normal.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/normalize_dot.hpp
type glm (line 50) | namespace glm
FILE: gpu/glm/gtx/number_precision.hpp
type glm (line 51) | namespace glm{
type gtx (line 52) | namespace gtx
FILE: gpu/glm/gtx/optimum_pow.hpp
type glm (line 48) | namespace glm{
type gtx (line 49) | namespace gtx
FILE: gpu/glm/gtx/orthonormalize.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/perpendicular.hpp
type glm (line 50) | namespace glm
FILE: gpu/glm/gtx/polar_coordinates.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/projection.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/quaternion.hpp
type glm (line 52) | namespace glm
function toMat3 (line 150) | detail::tmat3x3<T, P> toMat3(
function toMat4 (line 157) | detail::tmat4x4<T, P> toMat4(
function toQuat (line 164) | detail::tquat<T, P> toQuat(
function toQuat (line 171) | detail::tquat<T, P> toQuat(
FILE: gpu/glm/gtx/raw_data.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/rotate_normalized_axis.hpp
type glm (line 52) | namespace glm
FILE: gpu/glm/gtx/rotate_vector.hpp
type glm (line 50) | namespace glm
FILE: gpu/glm/gtx/scalar_relational.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/simd_mat4.hpp
type ctor (line 64) | enum ctor{_null}
FILE: gpu/glm/gtx/simd_quat.hpp
type ctor (line 75) | enum ctor{null}
FILE: gpu/glm/gtx/simd_vec4.hpp
type glm (line 65) | namespace glm
type comp (line 67) | enum comp
type ctor (line 92) | enum ctor{null}
FILE: gpu/glm/gtx/spline.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/std_based_type.hpp
type glm (line 49) | namespace glm
FILE: gpu/glm/gtx/string_cast.hpp
type glm (line 54) | namespace glm
FILE: gpu/glm/gtx/transform.hpp
type glm (line 52) | namespace glm
FILE: gpu/glm/gtx/transform2.hpp
type glm (line 50) | namespace glm
FILE: gpu/glm/gtx/vec1.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/gtx/vector_angle.hpp
type glm (line 53) | namespace glm
FILE: gpu/glm/gtx/vector_query.hpp
type glm (line 50) | namespace glm
FILE: gpu/glm/gtx/wrap.hpp
type glm (line 48) | namespace glm
FILE: gpu/glm/mat2x2.hpp
type glm (line 34) | namespace glm
FILE: gpu/glm/mat2x3.hpp
type glm (line 34) | namespace glm
FILE: gpu/glm/mat2x4.hpp
type glm (line 34) | namespace glm
FILE: gpu/glm/mat3x2.hpp
type glm (line 34) | namespace glm
FILE: gpu/glm/mat3x3.hpp
type glm (line 34) | namespace glm
FILE: gpu/glm/mat3x4.hpp
type glm (line 34) | namespace glm
FILE: gpu/glm/mat4x2.hpp
type glm (line 34) | namespace glm
FILE: gpu/glm/mat4x3.hpp
type glm (line 34) | namespace glm
FILE: gpu/glm/mat4x4.hpp
type glm (line 34) | namespace glm
FILE: gpu/src/cuda/helper_cuda.h
function __getLastCudaError (line 999) | inline void __getLastCudaError(const char *errorMessage, const char *fil...
function ftoi (line 1017) | inline int ftoi(float value)
function _ConvertSMVer2Cores (line 1023) | inline int _ConvertSMVer2Cores(int major, int minor)
function gpuDeviceInit (line 1065) | inline int gpuDeviceInit(int devID)
function gpuGetMaxGflopsDeviceId (line 1112) | inline int gpuGetMaxGflopsDeviceId()
function findCudaDevice (line 1207) | inline int findCudaDevice()
function checkCudaCapabilities (line 1222) | inline bool checkCudaCapabilities(int major_version, int minor_version)
FILE: gpu/src/cuda/helper_math.h
type uint (line 28) | typedef unsigned int uint;
type ushort (line 29) | typedef unsigned short ushort;
function fminf (line 43) | inline float fminf(float a, float b)
function fmaxf (line 48) | inline float fmaxf(float a, float b)
function max (line 53) | inline int max(int a, int b)
function min (line 58) | inline int min(int a, int b)
function rsqrtf (line 63) | inline float rsqrtf(float x)
function float2 (line 73) | float2 make_float2(float s)
function float2 (line 77) | float2 make_float2(float3 a)
function float2 (line 81) | float2 make_float2(int2 a)
function float2 (line 85) | float2 make_float2(uint2 a)
function int2 (line 90) | int2 make_int2(int s)
function int2 (line 94) | int2 make_int2(int3 a)
function int2 (line 98) | int2 make_int2(uint2 a)
function int2 (line 102) | int2 make_int2(float2 a)
function uint2 (line 107) | uint2 make_uint2(uint s)
function uint2 (line 111) | uint2 make_uint2(uint3 a)
function uint2 (line 115) | uint2 make_uint2(int2 a)
function float3 (line 120) | float3 make_float3(float s)
function float3 (line 124) | float3 make_float3(float2 a)
function float3 (line 128) | float3 make_float3(float2 a, float s)
function float3 (line 132) | float3 make_float3(float4 a)
function float3 (line 136) | float3 make_float3(int3 a)
function float3 (line 140) | float3 make_float3(uint3 a)
function int3 (line 145) | int3 make_int3(int s)
function int3 (line 149) | int3 make_int3(int2 a)
function int3 (line 153) | int3 make_int3(int2 a, int s)
function int3 (line 157) | int3 make_int3(uint3 a)
function int3 (line 161) | int3 make_int3(float3 a)
function uint3 (line 166) | uint3 make_uint3(uint s)
function uint3 (line 170) | uint3 make_uint3(uint2 a)
function uint3 (line 174) | uint3 make_uint3(uint2 a, uint s)
function uint3 (line 178) | uint3 make_uint3(uint4 a)
function uint3 (line 182) | uint3 make_uint3(int3 a)
function float4 (line 187) | float4 make_float4(float s)
function float4 (line 191) | float4 make_float4(float3 a)
function float4 (line 195) | float4 make_float4(float3 a, float w)
function float4 (line 199) | float4 make_float4(int4 a)
function float4 (line 203) | float4 make_float4(uint4 a)
function int4 (line 208) | int4 make_int4(int s)
function int4 (line 212) | int4 make_int4(int3 a)
function int4 (line 216) | int4 make_int4(int3 a, int w)
function int4 (line 220) | int4 make_int4(uint4 a)
function int4 (line 224) | int4 make_int4(float4 a)
function uint4 (line 230) | uint4 make_uint4(uint s)
function uint4 (line 234) | uint4 make_uint4(uint3 a)
function uint4 (line 238) | uint4 make_uint4(uint3 a, uint w)
function uint4 (line 242) | uint4 make_uint4(int4 a)
function float2 (line 736) | float2 operator*(float2 a, float2 b)
function float2 (line 745) | float2 operator*(float2 a, float b)
function float2 (line 749) | float2 operator*(float b, float2 a)
function int2 (line 759) | int2 operator*(int2 a, int2 b)
function int2 (line 768) | int2 operator*(int2 a, int b)
function int2 (line 772) | int2 operator*(int b, int2 a)
function uint2 (line 782) | uint2 operator*(uint2 a, uint2 b)
function uint2 (line 791) | uint2 operator*(uint2 a, uint b)
function uint2 (line 795) | uint2 operator*(uint b, uint2 a)
function float3 (line 805) | float3 operator*(float3 a, float3 b)
function float3 (line 815) | float3 operator*(float3 a, float b)
function float3 (line 819) | float3 operator*(float b, float3 a)
function int3 (line 830) | int3 operator*(int3 a, int3 b)
function int3 (line 840) | int3 operator*(int3 a, int b)
function int3 (line 844) | int3 operator*(int b, int3 a)
function uint3 (line 855) | uint3 operator*(uint3 a, uint3 b)
function uint3 (line 865) | uint3 operator*(uint3 a, uint b)
function uint3 (line 869) | uint3 operator*(uint b, uint3 a)
function float4 (line 880) | float4 operator*(float4 a, float4 b)
function float4 (line 891) | float4 operator*(float4 a, float b)
function float4 (line 895) | float4 operator*(float b, float4 a)
function int4 (line 907) | int4 operator*(int4 a, int4 b)
function int4 (line 918) | int4 operator*(int4 a, int b)
function int4 (line 922) | int4 operator*(int b, int4 a)
function uint4 (line 934) | uint4 operator*(uint4 a, uint4 b)
function uint4 (line 945) | uint4 operator*(uint4 a, uint b)
function uint4 (line 949) | uint4 operator*(uint b, uint4 a)
function float2 (line 1044) | float2 fminf(float2 a, float2 b)
function float3 (line 1048) | float3 fminf(float3 a, float3 b)
function float4 (line 1052) | float4 fminf(float4 a, float4 b)
function int2 (line 1057) | int2 min(int2 a, int2 b)
function int3 (line 1061) | int3 min(int3 a, int3 b)
function int4 (line 1065) | int4 min(int4 a, int4 b)
function uint2 (line 1070) | uint2 min(uint2 a, uint2 b)
function uint3 (line 1074) | uint3 min(uint3 a, uint3 b)
function uint4 (line 1078) | uint4 min(uint4 a, uint4 b)
function float2 (line 1087) | float2 fmaxf(float2 a, float2 b)
function float3 (line 1091) | float3 fmaxf(float3 a, float3 b)
function float4 (line 1095) | float4 fmaxf(float4 a, float4 b)
function int2 (line 1100) | int2 max(int2 a, int2 b)
function int3 (line 1104) | int3 max(int3 a, int3 b)
function int4 (line 1108) | int4 max(int4 a, int4 b)
function uint2 (line 1113) | uint2 max(uint2 a, uint2 b)
function uint3 (line 1117) | uint3 max(uint3 a, uint3 b)
function uint4 (line 1121) | uint4 max(uint4 a, uint4 b)
function lerp (line 1131) | float lerp(float a, float b, float t)
function float2 (line 1135) | float2 lerp(float2 a, float2 b, float t)
function float3 (line 1139) | float3 lerp(float3 a, float3 b, float t)
function float4 (line 1143) | float4 lerp(float4 a, float4 b, float t)
function clamp (line 1153) | float clamp(float f, float a, float b)
function clamp (line 1157) | int clamp(int f, int a, int b)
function uint (line 1161) | uint clamp(uint f, uint a, uint b)
function float2 (line 1166) | float2 clamp(float2 v, float a, float b)
function float2 (line 1170) | float2 clamp(float2 v, float2 a, float2 b)
function float3 (line 1174) | float3 clamp(float3 v, float a, float b)
function float3 (line 1178) | float3 clamp(float3 v, float3 a, float3 b)
function float4 (line 1182) | float4 clamp(float4 v, float a, float b)
function float4 (line 1186) | float4 clamp(float4 v, float4 a, float4 b)
function int2 (line 1191) | int2 clamp(int2 v, int a, int b)
function int2 (line 1195) | int2 clamp(int2 v, int2 a, int2 b)
function int3 (line 1199) | int3 clamp(int3 v, int a, int b)
function int3 (line 1203) | int3 clamp(int3 v, int3 a, int3 b)
function int4 (line 1207) | int4 clamp(int4 v, int a, int b)
function int4 (line 1211) | int4 clamp(int4 v, int4 a, int4 b)
function uint2 (line 1216) | uint2 clamp(uint2 v, uint a, uint b)
function uint2 (line 1220) | uint2 clamp(uint2 v, uint2 a, uint2 b)
function uint3 (line 1224) | uint3 clamp(uint3 v, uint a, uint b)
function uint3 (line 1228) | uint3 clamp(uint3 v, uint3 a, uint3 b)
function uint4 (line 1232) | uint4 clamp(uint4 v, uint a, uint b)
function uint4 (line 1236) | uint4 clamp(uint4 v, uint4 a, uint4 b)
function dot (line 1245) | float dot(float2 a, float2 b)
function dot (line 1249) | float dot(float3 a, float3 b)
function dot (line 1253) | float dot(float4 a, float4 b)
function dot (line 1258) | int dot(int2 a, int2 b)
function dot (line 1262) | int dot(int3 a, int3 b)
function dot (line 1266) | int dot(int4 a, int4 b)
function uint (line 1271) | uint dot(uint2 a, uint2 b)
function uint (line 1275) | uint dot(uint3 a, uint3 b)
function uint (line 1279) | uint dot(uint4 a, uint4 b)
function length (line 1288) | float length(float2 v)
function length (line 1292) | float length(float3 v)
function length (line 1296) | float length(float4 v)
function float2 (line 1305) | float2 normalize(float2 v)
function float3 (line 1310) | float3 normalize(float3 v)
function float4 (line 1315) | float4 normalize(float4 v)
function float2 (line 1325) | float2 floorf(float2 v)
function float3 (line 1329) | float3 floorf(float3 v)
function float4 (line 1333) | float4 floorf(float4 v)
function fracf (line 1342) | float fracf(float v)
function float2 (line 1346) | float2 fracf(float2 v)
function float3 (line 1350) | float3 fracf(float3 v)
function float4 (line 1354) | float4 fracf(float4 v)
function float2 (line 1363) | float2 fmodf(float2 a, float2 b)
function float3 (line 1367) | float3 fmodf(float3 a, float3 b)
function float4 (line 1371) | float4 fmodf(float4 a, float4 b)
function float2 (line 1380) | float2 fabs(float2 v)
function float3 (line 1384) | float3 fabs(float3 v)
function float4 (line 1388) | float4 fabs(float4 v)
function int2 (line 1393) | int2 abs(int2 v)
function int3 (line 1397) | int3 abs(int3 v)
function int4 (line 1401) | int4 abs(int4 v)
function float3 (line 1412) | float3 reflect(float3 i, float3 n)
function float3 (line 1421) | float3 cross(float3 a, float3 b)
function smoothstep (line 1433) | float smoothstep(float a, float b, float x)
function float2 (line 1438) | float2 smoothstep(float2 a, float2 b, float2 x)
function float3 (line 1443) | float3 smoothstep(float3 a, float3 b, float3 x)
function float4 (line 1448) | float4 smoothstep(float4 a, float4 b, float4 x)
FILE: gpu/src/main.cpp
function main (line 5) | int main(int argc, char *argv[])
FILE: gpu/src/particleapp.cpp
function frand (line 61) | inline float frand()
FILE: gpu/src/particleapp.h
function class (line 10) | class ParticleApp
FILE: gpu/src/particlesystem.cpp
function frand (line 78) | inline float frand()
function GLuint (line 716) | GLuint ParticleSystem::createVBO(uint size)
FILE: gpu/src/particlesystem.h
type GLuint (line 9) | typedef unsigned int GLuint;
type uint (line 10) | typedef unsigned int uint;
function class (line 22) | class ParticleSystem
FILE: gpu/src/rendering/actioncamera.h
function class (line 6) | class ActionCamera : public Camera
FILE: gpu/src/rendering/camera.h
function class (line 6) | class Camera
FILE: gpu/src/rendering/orbitingcamera.h
function class (line 18) | class OrbitingCamera
FILE: gpu/src/rendering/renderer.cpp
function GLuint (line 150) | GLuint Renderer::_compileProgram(const char *vertex_file_path, const cha...
function float4 (line 229) | float4 Renderer::raycast2XYPlane(float x, float y)
function float3 (line 246) | float3 Renderer::getDir(float x, float y)
function float3 (line 257) | float3 Renderer::getEye()
FILE: gpu/src/rendering/renderer.h
type GLuint (line 8) | typedef unsigned int GLuint;
type uint (line 9) | typedef unsigned int uint;
function class (line 14) | class Renderer
FILE: gpu/src/ui/mainwindow.h
function namespace (line 8) | namespace Ui {
function class (line 12) | class MainWindow : public QMainWindow
FILE: gpu/src/ui/view.h
function class (line 11) | class View : public QGLWidget
Condensed preview — 620 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (4,809K chars).
[
{
"path": ".gitignore",
"chars": 256,
"preview": "# QT #\n######\n*.pro.user*\n*.qmake.stash\n\n# Compiled Source #\n###################\n*.o\nbuild/\n\n# Executables #\n###########"
},
{
"path": "LICENSE",
"chars": 1078,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2015 ebirenbaum\n\nPermission is hereby granted, free of charge, to any person obtain"
},
{
"path": "README.md",
"chars": 3333,
"preview": "# Unified Particle Solver\n\n#### An implementation of Macklin et. al's [Unified Particle Physics for Real-Time Applicatio"
},
{
"path": "cpu/README",
"chars": 0,
"preview": ""
},
{
"path": "cpu/glm/CMakeLists.txt",
"chars": 1409,
"preview": "set(NAME glm_dummy)\r\n\r\nfile(GLOB ROOT_SOURCE *.cpp)\r\nfile(GLOB ROOT_INLINE *.inl)\r\nfile(GLOB ROOT_HEADER *.hpp)\r\nfile(GL"
},
{
"path": "cpu/glm/common.hpp",
"chars": 1628,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/_features.hpp",
"chars": 13436,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/_fixes.hpp",
"chars": 1914,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/_literals.hpp",
"chars": 1950,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/_noise.hpp",
"chars": 4447,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/_swizzle.hpp",
"chars": 52091,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/_swizzle_func.hpp",
"chars": 65331,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/_vectorize.hpp",
"chars": 6325,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/dummy.cpp",
"chars": 2191,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_common.hpp",
"chars": 22920,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_common.inl",
"chars": 26818,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_exponential.hpp",
"chars": 6696,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_exponential.inl",
"chars": 6972,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_geometric.hpp",
"chars": 6700,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_geometric.inl",
"chars": 9192,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_integer.hpp",
"chars": 9871,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_integer.inl",
"chars": 16243,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_matrix.hpp",
"chars": 7044,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_matrix.inl",
"chars": 15238,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_noise.hpp",
"chars": 4247,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_noise.inl",
"chars": 14800,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_packing.hpp",
"chars": 12448,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_packing.inl",
"chars": 3792,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_trigonometric.hpp",
"chars": 10161,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_trigonometric.inl",
"chars": 6197,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_vector_relational.hpp",
"chars": 7765,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/func_vector_relational.inl",
"chars": 5805,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/glm.cpp",
"chars": 9952,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/hint.hpp",
"chars": 1743,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_common.hpp",
"chars": 2730,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_common.inl",
"chars": 13833,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_exponential.hpp",
"chars": 3094,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_exponential.inl",
"chars": 1520,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_geometric.hpp",
"chars": 2432,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_geometric.inl",
"chars": 4770,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_integer.hpp",
"chars": 1996,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_integer.inl",
"chars": 5295,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_matrix.hpp",
"chars": 2523,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_matrix.inl",
"chars": 42655,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_trigonometric.hpp",
"chars": 1919,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_trigonometric.inl",
"chars": 1522,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_vector_relational.hpp",
"chars": 1939,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/intrinsic_vector_relational.inl",
"chars": 10836,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/precision.hpp",
"chars": 1736,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/precision.inl",
"chars": 0,
"preview": ""
},
{
"path": "cpu/glm/detail/setup.hpp",
"chars": 29098,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_float.hpp",
"chars": 4266,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_gentype.hpp",
"chars": 6466,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_gentype.inl",
"chars": 10638,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_half.hpp",
"chars": 1937,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_half.inl",
"chars": 6381,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_int.hpp",
"chars": 8663,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat.hpp",
"chars": 43402,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat.inl",
"chars": 1507,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat2x2.hpp",
"chars": 8172,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat2x2.inl",
"chars": 15233,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat2x3.hpp",
"chars": 6878,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat2x3.inl",
"chars": 14152,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat2x4.hpp",
"chars": 6979,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat2x4.inl",
"chars": 15129,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat3x2.hpp",
"chars": 6939,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat3x2.inl",
"chars": 15130,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat3x3.hpp",
"chars": 8346,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat3x3.inl",
"chars": 20500,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat3x4.hpp",
"chars": 7198,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat3x4.inl",
"chars": 17676,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat4x2.hpp",
"chars": 7102,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat4x2.inl",
"chars": 17148,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat4x3.hpp",
"chars": 7299,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat4x3.inl",
"chars": 19288,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat4x4.hpp",
"chars": 8756,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_mat4x4.inl",
"chars": 28772,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec.hpp",
"chars": 27853,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec.inl",
"chars": 1507,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec1.hpp",
"chars": 10225,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec1.inl",
"chars": 15826,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec2.hpp",
"chars": 11171,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec2.inl",
"chars": 16895,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec3.hpp",
"chars": 11907,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec3.inl",
"chars": 18266,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec4.hpp",
"chars": 13897,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/detail/type_vec4.inl",
"chars": 21116,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/exponential.hpp",
"chars": 1653,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/ext.hpp",
"chars": 5380,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/fwd.hpp",
"chars": 86565,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/geometric.hpp",
"chars": 1643,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/glm.hpp",
"chars": 4586,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/constants.hpp",
"chars": 5242,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/constants.inl",
"chars": 4854,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/epsilon.hpp",
"chars": 3499,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/epsilon.inl",
"chars": 4269,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/matrix_access.hpp",
"chars": 2993,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/matrix_access.inl",
"chars": 2722,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/matrix_integer.hpp",
"chars": 16963,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/matrix_inverse.hpp",
"chars": 2995,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/matrix_inverse.inl",
"chars": 6815,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/matrix_transform.hpp",
"chars": 11931,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/matrix_transform.inl",
"chars": 14183,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/noise.hpp",
"chars": 2941,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/noise.inl",
"chars": 39563,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/packing.hpp",
"chars": 26927,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/packing.inl",
"chars": 14778,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/quaternion.hpp",
"chars": 13289,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/quaternion.inl",
"chars": 23220,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/random.hpp",
"chars": 3966,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/random.inl",
"chars": 4746,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/reciprocal.hpp",
"chars": 4118,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/reciprocal.inl",
"chars": 5107,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/type_precision.hpp",
"chars": 27005,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/type_precision.inl",
"chars": 1537,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/type_ptr.hpp",
"chars": 6087,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/type_ptr.inl",
"chars": 12353,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/ulp.hpp",
"chars": 3412,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtc/ulp.inl",
"chars": 9248,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/associated_min_max.hpp",
"chars": 3979,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/associated_min_max.inl",
"chars": 26888,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/bit.hpp",
"chars": 9085,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/bit.inl",
"chars": 17708,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/closest_point.hpp",
"chars": 2478,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/closest_point.inl",
"chars": 1249,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/color_space.hpp",
"chars": 3350,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/color_space.inl",
"chars": 4018,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/color_space_YCoCg.hpp",
"chars": 3242,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/color_space_YCoCg.inl",
"chars": 2122,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/compatibility.hpp",
"chars": 17041,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/compatibility.inl",
"chars": 1642,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/component_wise.hpp",
"chars": 2924,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/component_wise.inl",
"chars": 1573,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/constants.hpp",
"chars": 1673,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/dual_quaternion.hpp",
"chars": 10077,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/dual_quaternion.inl",
"chars": 11640,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/epsilon.hpp",
"chars": 1590,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/euler_angles.hpp",
"chars": 5405,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/euler_angles.inl",
"chars": 6237,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/extend.hpp",
"chars": 2404,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/extend.inl",
"chars": 1524,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/extented_min_max.hpp",
"chars": 5055,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/extented_min_max.inl",
"chars": 3183,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/fast_exponential.hpp",
"chars": 3421,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/fast_exponential.inl",
"chars": 4639,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/fast_square_root.hpp",
"chars": 3707,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/fast_square_root.inl",
"chars": 3465,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/fast_trigonometry.hpp",
"chars": 3702,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/fast_trigonometry.inl",
"chars": 2392,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/gradient_paint.hpp",
"chars": 2834,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/gradient_paint.inl",
"chars": 1468,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/handed_coordinate_space.hpp",
"chars": 2907,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/handed_coordinate_space.inl",
"chars": 1103,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/inertia.hpp",
"chars": 3789,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/inertia.inl",
"chars": 3054,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/int_10_10_10_2.hpp",
"chars": 1914,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/int_10_10_10_2.inl",
"chars": 1632,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/integer.hpp",
"chars": 3580,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/integer.inl",
"chars": 4858,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/intersect.hpp",
"chars": 4426,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/intersect.inl",
"chars": 7223,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/io.hpp",
"chars": 5927,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/io.inl",
"chars": 10048,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/log_base.hpp",
"chars": 2300,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/log_base.inl",
"chars": 798,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/matrix_cross_product.hpp",
"chars": 2691,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/matrix_cross_product.inl",
"chars": 1251,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/matrix_interpolation.hpp",
"chars": 3376,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/matrix_interpolation.inl",
"chars": 4441,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/matrix_major_storage.hpp",
"chars": 5322,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/matrix_major_storage.inl",
"chars": 4659,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/matrix_operation.hpp",
"chars": 3913,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/matrix_operation.inl",
"chars": 3036,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/matrix_query.hpp",
"chars": 3969,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/matrix_query.inl",
"chars": 4146,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/mixed_product.hpp",
"chars": 2416,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/mixed_product.inl",
"chars": 787,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/multiple.hpp",
"chars": 2868,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/multiple.inl",
"chars": 3398,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/noise.hpp",
"chars": 1588,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/norm.hpp",
"chars": 3981,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/norm.inl",
"chars": 2977,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/normal.hpp",
"chars": 2422,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/normal.inl",
"chars": 815,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/normalize_dot.hpp",
"chars": 2891,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/normalize_dot.inl",
"chars": 2487,
"preview": "//////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathematics Copyright (c) "
},
{
"path": "cpu/glm/gtx/number_precision.hpp",
"chars": 3693,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/number_precision.inl",
"chars": 550,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/optimum_pow.hpp",
"chars": 3412,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/optimum_pow.inl",
"chars": 1619,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/orthonormalize.hpp",
"chars": 2662,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/orthonormalize.inl",
"chars": 1201,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/perpendicular.hpp",
"chars": 2447,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/perpendicular.inl",
"chars": 721,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/polar_coordinates.hpp",
"chars": 2695,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/polar_coordinates.inl",
"chars": 1968,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/projection.hpp",
"chars": 2313,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/projection.inl",
"chars": 754,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
},
{
"path": "cpu/glm/gtx/quaternion.hpp",
"chars": 6543,
"preview": "///////////////////////////////////////////////////////////////////////////////////\r\n/// OpenGL Mathematics (glm.g-truc."
},
{
"path": "cpu/glm/gtx/quaternion.inl",
"chars": 6580,
"preview": "///////////////////////////////////////////////////////////////////////////////////////////////////\r\n// OpenGL Mathemati"
}
]
// ... and 420 more files (download for full content)
About this extraction
This page contains the full source code of the ebirenbaum/ParticleSolver GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 620 files (4.2 MB), approximately 1.1M tokens, and a symbol index with 1154 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.