Repository: alnitak/flutter_opengl Branch: master Commit: 19a0f50af319 Files: 580 Total size: 2.5 MB Directory structure: gitextract__ltgg91e/ ├── .gitignore ├── .metadata ├── .vscode/ │ ├── c_cpp_properties.json │ ├── extensions.json │ ├── launch.json │ ├── settings.json │ └── tasks.json ├── CHANGELOG.md ├── LICENSE ├── README.md ├── SCRIPTS/ │ └── setupOpenCV-android.sh ├── analysis_options.yaml ├── android/ │ ├── .gitignore │ ├── CMakeLists.txt │ ├── build.gradle │ ├── gradle/ │ │ └── wrapper/ │ │ ├── gradle-wrapper.jar │ │ └── gradle-wrapper.properties │ ├── gradlew │ ├── gradlew.bat │ ├── proguard-rules.pro │ ├── settings.gradle │ └── src/ │ ├── glm/ │ │ ├── CMakeLists.txt │ │ ├── common.hpp │ │ ├── detail/ │ │ │ ├── _features.hpp │ │ │ ├── _fixes.hpp │ │ │ ├── _noise.hpp │ │ │ ├── _swizzle.hpp │ │ │ ├── _swizzle_func.hpp │ │ │ ├── _vectorize.hpp │ │ │ ├── compute_common.hpp │ │ │ ├── compute_vector_relational.hpp │ │ │ ├── func_common.inl │ │ │ ├── func_common_simd.inl │ │ │ ├── func_exponential.inl │ │ │ ├── func_exponential_simd.inl │ │ │ ├── func_geometric.inl │ │ │ ├── func_geometric_simd.inl │ │ │ ├── func_integer.inl │ │ │ ├── func_integer_simd.inl │ │ │ ├── func_matrix.inl │ │ │ ├── func_matrix_simd.inl │ │ │ ├── func_packing.inl │ │ │ ├── func_packing_simd.inl │ │ │ ├── func_trigonometric.inl │ │ │ ├── func_trigonometric_simd.inl │ │ │ ├── func_vector_relational.inl │ │ │ ├── func_vector_relational_simd.inl │ │ │ ├── glm.cpp │ │ │ ├── qualifier.hpp │ │ │ ├── setup.hpp │ │ │ ├── type_float.hpp │ │ │ ├── type_half.hpp │ │ │ ├── type_half.inl │ │ │ ├── type_mat2x2.hpp │ │ │ ├── type_mat2x2.inl │ │ │ ├── type_mat2x3.hpp │ │ │ ├── type_mat2x3.inl │ │ │ ├── type_mat2x4.hpp │ │ │ ├── type_mat2x4.inl │ │ │ ├── type_mat3x2.hpp │ │ │ ├── type_mat3x2.inl │ │ │ ├── type_mat3x3.hpp │ │ │ ├── type_mat3x3.inl │ │ │ ├── type_mat3x4.hpp │ │ │ ├── type_mat3x4.inl │ │ │ ├── type_mat4x2.hpp │ │ │ ├── type_mat4x2.inl │ │ │ ├── type_mat4x3.hpp │ │ │ ├── type_mat4x3.inl │ │ │ ├── type_mat4x4.hpp │ │ │ ├── type_mat4x4.inl │ │ │ ├── type_mat4x4_simd.inl │ │ │ ├── type_quat.hpp │ │ │ ├── type_quat.inl │ │ │ ├── type_quat_simd.inl │ │ │ ├── type_vec1.hpp │ │ │ ├── type_vec1.inl │ │ │ ├── type_vec2.hpp │ │ │ ├── type_vec2.inl │ │ │ ├── type_vec3.hpp │ │ │ ├── type_vec3.inl │ │ │ ├── type_vec4.hpp │ │ │ ├── type_vec4.inl │ │ │ └── type_vec4_simd.inl │ │ ├── exponential.hpp │ │ ├── ext/ │ │ │ ├── matrix_clip_space.hpp │ │ │ ├── matrix_clip_space.inl │ │ │ ├── matrix_common.hpp │ │ │ ├── matrix_common.inl │ │ │ ├── matrix_double2x2.hpp │ │ │ ├── matrix_double2x2_precision.hpp │ │ │ ├── matrix_double2x3.hpp │ │ │ ├── matrix_double2x3_precision.hpp │ │ │ ├── matrix_double2x4.hpp │ │ │ ├── matrix_double2x4_precision.hpp │ │ │ ├── matrix_double3x2.hpp │ │ │ ├── matrix_double3x2_precision.hpp │ │ │ ├── matrix_double3x3.hpp │ │ │ ├── matrix_double3x3_precision.hpp │ │ │ ├── matrix_double3x4.hpp │ │ │ ├── matrix_double3x4_precision.hpp │ │ │ ├── matrix_double4x2.hpp │ │ │ ├── matrix_double4x2_precision.hpp │ │ │ ├── matrix_double4x3.hpp │ │ │ ├── matrix_double4x3_precision.hpp │ │ │ ├── matrix_double4x4.hpp │ │ │ ├── matrix_double4x4_precision.hpp │ │ │ ├── matrix_float2x2.hpp │ │ │ ├── matrix_float2x2_precision.hpp │ │ │ ├── matrix_float2x3.hpp │ │ │ ├── matrix_float2x3_precision.hpp │ │ │ ├── matrix_float2x4.hpp │ │ │ ├── matrix_float2x4_precision.hpp │ │ │ ├── matrix_float3x2.hpp │ │ │ ├── matrix_float3x2_precision.hpp │ │ │ ├── matrix_float3x3.hpp │ │ │ ├── matrix_float3x3_precision.hpp │ │ │ ├── matrix_float3x4.hpp │ │ │ ├── matrix_float3x4_precision.hpp │ │ │ ├── matrix_float4x2.hpp │ │ │ ├── matrix_float4x2_precision.hpp │ │ │ ├── matrix_float4x3.hpp │ │ │ ├── matrix_float4x3_precision.hpp │ │ │ ├── matrix_float4x4.hpp │ │ │ ├── matrix_float4x4_precision.hpp │ │ │ ├── matrix_int2x2.hpp │ │ │ ├── matrix_int2x2_sized.hpp │ │ │ ├── matrix_int2x3.hpp │ │ │ ├── matrix_int2x3_sized.hpp │ │ │ ├── matrix_int2x4.hpp │ │ │ ├── matrix_int2x4_sized.hpp │ │ │ ├── matrix_int3x2.hpp │ │ │ ├── matrix_int3x2_sized.hpp │ │ │ ├── matrix_int3x3.hpp │ │ │ ├── matrix_int3x3_sized.hpp │ │ │ ├── matrix_int3x4.hpp │ │ │ ├── matrix_int3x4_sized.hpp │ │ │ ├── matrix_int4x2.hpp │ │ │ ├── matrix_int4x2_sized.hpp │ │ │ ├── matrix_int4x3.hpp │ │ │ ├── matrix_int4x3_sized.hpp │ │ │ ├── matrix_int4x4.hpp │ │ │ ├── matrix_int4x4_sized.hpp │ │ │ ├── matrix_projection.hpp │ │ │ ├── matrix_projection.inl │ │ │ ├── matrix_relational.hpp │ │ │ ├── matrix_relational.inl │ │ │ ├── matrix_transform.hpp │ │ │ ├── matrix_transform.inl │ │ │ ├── matrix_uint2x2.hpp │ │ │ ├── matrix_uint2x2_sized.hpp │ │ │ ├── matrix_uint2x3.hpp │ │ │ ├── matrix_uint2x3_sized.hpp │ │ │ ├── matrix_uint2x4.hpp │ │ │ ├── matrix_uint2x4_sized.hpp │ │ │ ├── matrix_uint3x2.hpp │ │ │ ├── matrix_uint3x2_sized.hpp │ │ │ ├── matrix_uint3x3.hpp │ │ │ ├── matrix_uint3x3_sized.hpp │ │ │ ├── matrix_uint3x4.hpp │ │ │ ├── matrix_uint3x4_sized.hpp │ │ │ ├── matrix_uint4x2.hpp │ │ │ ├── matrix_uint4x2_sized.hpp │ │ │ ├── matrix_uint4x3.hpp │ │ │ ├── matrix_uint4x3_sized.hpp │ │ │ ├── matrix_uint4x4.hpp │ │ │ ├── matrix_uint4x4_sized.hpp │ │ │ ├── quaternion_common.hpp │ │ │ ├── quaternion_common.inl │ │ │ ├── quaternion_common_simd.inl │ │ │ ├── quaternion_double.hpp │ │ │ ├── quaternion_double_precision.hpp │ │ │ ├── quaternion_exponential.hpp │ │ │ ├── quaternion_exponential.inl │ │ │ ├── quaternion_float.hpp │ │ │ ├── quaternion_float_precision.hpp │ │ │ ├── quaternion_geometric.hpp │ │ │ ├── quaternion_geometric.inl │ │ │ ├── quaternion_relational.hpp │ │ │ ├── quaternion_relational.inl │ │ │ ├── quaternion_transform.hpp │ │ │ ├── quaternion_transform.inl │ │ │ ├── quaternion_trigonometric.hpp │ │ │ ├── quaternion_trigonometric.inl │ │ │ ├── scalar_common.hpp │ │ │ ├── scalar_common.inl │ │ │ ├── scalar_constants.hpp │ │ │ ├── scalar_constants.inl │ │ │ ├── scalar_int_sized.hpp │ │ │ ├── scalar_integer.hpp │ │ │ ├── scalar_integer.inl │ │ │ ├── scalar_packing.hpp │ │ │ ├── scalar_packing.inl │ │ │ ├── scalar_relational.hpp │ │ │ ├── scalar_relational.inl │ │ │ ├── scalar_uint_sized.hpp │ │ │ ├── scalar_ulp.hpp │ │ │ ├── scalar_ulp.inl │ │ │ ├── vector_bool1.hpp │ │ │ ├── vector_bool1_precision.hpp │ │ │ ├── vector_bool2.hpp │ │ │ ├── vector_bool2_precision.hpp │ │ │ ├── vector_bool3.hpp │ │ │ ├── vector_bool3_precision.hpp │ │ │ ├── vector_bool4.hpp │ │ │ ├── vector_bool4_precision.hpp │ │ │ ├── vector_common.hpp │ │ │ ├── vector_common.inl │ │ │ ├── vector_double1.hpp │ │ │ ├── vector_double1_precision.hpp │ │ │ ├── vector_double2.hpp │ │ │ ├── vector_double2_precision.hpp │ │ │ ├── vector_double3.hpp │ │ │ ├── vector_double3_precision.hpp │ │ │ ├── vector_double4.hpp │ │ │ ├── vector_double4_precision.hpp │ │ │ ├── vector_float1.hpp │ │ │ ├── vector_float1_precision.hpp │ │ │ ├── vector_float2.hpp │ │ │ ├── vector_float2_precision.hpp │ │ │ ├── vector_float3.hpp │ │ │ ├── vector_float3_precision.hpp │ │ │ ├── vector_float4.hpp │ │ │ ├── vector_float4_precision.hpp │ │ │ ├── vector_int1.hpp │ │ │ ├── vector_int1_sized.hpp │ │ │ ├── vector_int2.hpp │ │ │ ├── vector_int2_sized.hpp │ │ │ ├── vector_int3.hpp │ │ │ ├── vector_int3_sized.hpp │ │ │ ├── vector_int4.hpp │ │ │ ├── vector_int4_sized.hpp │ │ │ ├── vector_integer.hpp │ │ │ ├── vector_integer.inl │ │ │ ├── vector_packing.hpp │ │ │ ├── vector_packing.inl │ │ │ ├── vector_relational.hpp │ │ │ ├── vector_relational.inl │ │ │ ├── vector_uint1.hpp │ │ │ ├── vector_uint1_sized.hpp │ │ │ ├── vector_uint2.hpp │ │ │ ├── vector_uint2_sized.hpp │ │ │ ├── vector_uint3.hpp │ │ │ ├── vector_uint3_sized.hpp │ │ │ ├── vector_uint4.hpp │ │ │ ├── vector_uint4_sized.hpp │ │ │ ├── vector_ulp.hpp │ │ │ └── vector_ulp.inl │ │ ├── ext.hpp │ │ ├── fwd.hpp │ │ ├── geometric.hpp │ │ ├── glm.hpp │ │ ├── gtc/ │ │ │ ├── bitfield.hpp │ │ │ ├── bitfield.inl │ │ │ ├── color_space.hpp │ │ │ ├── color_space.inl │ │ │ ├── constants.hpp │ │ │ ├── constants.inl │ │ │ ├── epsilon.hpp │ │ │ ├── epsilon.inl │ │ │ ├── integer.hpp │ │ │ ├── integer.inl │ │ │ ├── matrix_access.hpp │ │ │ ├── matrix_access.inl │ │ │ ├── matrix_integer.hpp │ │ │ ├── matrix_inverse.hpp │ │ │ ├── matrix_inverse.inl │ │ │ ├── matrix_transform.hpp │ │ │ ├── matrix_transform.inl │ │ │ ├── noise.hpp │ │ │ ├── noise.inl │ │ │ ├── packing.hpp │ │ │ ├── packing.inl │ │ │ ├── quaternion.hpp │ │ │ ├── quaternion.inl │ │ │ ├── quaternion_simd.inl │ │ │ ├── random.hpp │ │ │ ├── random.inl │ │ │ ├── reciprocal.hpp │ │ │ ├── reciprocal.inl │ │ │ ├── round.hpp │ │ │ ├── round.inl │ │ │ ├── type_aligned.hpp │ │ │ ├── type_precision.hpp │ │ │ ├── type_precision.inl │ │ │ ├── type_ptr.hpp │ │ │ ├── type_ptr.inl │ │ │ ├── ulp.hpp │ │ │ ├── ulp.inl │ │ │ └── vec1.hpp │ │ ├── gtx/ │ │ │ ├── associated_min_max.hpp │ │ │ ├── associated_min_max.inl │ │ │ ├── bit.hpp │ │ │ ├── bit.inl │ │ │ ├── closest_point.hpp │ │ │ ├── closest_point.inl │ │ │ ├── color_encoding.hpp │ │ │ ├── color_encoding.inl │ │ │ ├── color_space.hpp │ │ │ ├── color_space.inl │ │ │ ├── color_space_YCoCg.hpp │ │ │ ├── color_space_YCoCg.inl │ │ │ ├── common.hpp │ │ │ ├── common.inl │ │ │ ├── compatibility.hpp │ │ │ ├── compatibility.inl │ │ │ ├── component_wise.hpp │ │ │ ├── component_wise.inl │ │ │ ├── dual_quaternion.hpp │ │ │ ├── dual_quaternion.inl │ │ │ ├── easing.hpp │ │ │ ├── easing.inl │ │ │ ├── euler_angles.hpp │ │ │ ├── euler_angles.inl │ │ │ ├── extend.hpp │ │ │ ├── extend.inl │ │ │ ├── extended_min_max.hpp │ │ │ ├── extended_min_max.inl │ │ │ ├── exterior_product.hpp │ │ │ ├── exterior_product.inl │ │ │ ├── fast_exponential.hpp │ │ │ ├── fast_exponential.inl │ │ │ ├── fast_square_root.hpp │ │ │ ├── fast_square_root.inl │ │ │ ├── fast_trigonometry.hpp │ │ │ ├── fast_trigonometry.inl │ │ │ ├── float_notmalize.inl │ │ │ ├── functions.hpp │ │ │ ├── functions.inl │ │ │ ├── gradient_paint.hpp │ │ │ ├── gradient_paint.inl │ │ │ ├── handed_coordinate_space.hpp │ │ │ ├── handed_coordinate_space.inl │ │ │ ├── hash.hpp │ │ │ ├── hash.inl │ │ │ ├── integer.hpp │ │ │ ├── integer.inl │ │ │ ├── intersect.hpp │ │ │ ├── intersect.inl │ │ │ ├── io.hpp │ │ │ ├── io.inl │ │ │ ├── log_base.hpp │ │ │ ├── log_base.inl │ │ │ ├── matrix_cross_product.hpp │ │ │ ├── matrix_cross_product.inl │ │ │ ├── matrix_decompose.hpp │ │ │ ├── matrix_decompose.inl │ │ │ ├── matrix_factorisation.hpp │ │ │ ├── matrix_factorisation.inl │ │ │ ├── matrix_interpolation.hpp │ │ │ ├── matrix_interpolation.inl │ │ │ ├── matrix_major_storage.hpp │ │ │ ├── matrix_major_storage.inl │ │ │ ├── matrix_operation.hpp │ │ │ ├── matrix_operation.inl │ │ │ ├── matrix_query.hpp │ │ │ ├── matrix_query.inl │ │ │ ├── matrix_transform_2d.hpp │ │ │ ├── matrix_transform_2d.inl │ │ │ ├── mixed_product.hpp │ │ │ ├── mixed_product.inl │ │ │ ├── norm.hpp │ │ │ ├── norm.inl │ │ │ ├── normal.hpp │ │ │ ├── normal.inl │ │ │ ├── normalize_dot.hpp │ │ │ ├── normalize_dot.inl │ │ │ ├── number_precision.hpp │ │ │ ├── number_precision.inl │ │ │ ├── optimum_pow.hpp │ │ │ ├── optimum_pow.inl │ │ │ ├── orthonormalize.hpp │ │ │ ├── orthonormalize.inl │ │ │ ├── perpendicular.hpp │ │ │ ├── perpendicular.inl │ │ │ ├── polar_coordinates.hpp │ │ │ ├── polar_coordinates.inl │ │ │ ├── projection.hpp │ │ │ ├── projection.inl │ │ │ ├── quaternion.hpp │ │ │ ├── quaternion.inl │ │ │ ├── range.hpp │ │ │ ├── raw_data.hpp │ │ │ ├── raw_data.inl │ │ │ ├── rotate_normalized_axis.hpp │ │ │ ├── rotate_normalized_axis.inl │ │ │ ├── rotate_vector.hpp │ │ │ ├── rotate_vector.inl │ │ │ ├── scalar_multiplication.hpp │ │ │ ├── scalar_relational.hpp │ │ │ ├── scalar_relational.inl │ │ │ ├── spline.hpp │ │ │ ├── spline.inl │ │ │ ├── std_based_type.hpp │ │ │ ├── std_based_type.inl │ │ │ ├── string_cast.hpp │ │ │ ├── string_cast.inl │ │ │ ├── texture.hpp │ │ │ ├── texture.inl │ │ │ ├── transform.hpp │ │ │ ├── transform.inl │ │ │ ├── transform2.hpp │ │ │ ├── transform2.inl │ │ │ ├── type_aligned.hpp │ │ │ ├── type_aligned.inl │ │ │ ├── type_trait.hpp │ │ │ ├── type_trait.inl │ │ │ ├── vec_swizzle.hpp │ │ │ ├── vector_angle.hpp │ │ │ ├── vector_angle.inl │ │ │ ├── vector_query.hpp │ │ │ ├── vector_query.inl │ │ │ ├── wrap.hpp │ │ │ └── wrap.inl │ │ ├── integer.hpp │ │ ├── mat2x2.hpp │ │ ├── mat2x3.hpp │ │ ├── mat2x4.hpp │ │ ├── mat3x2.hpp │ │ ├── mat3x3.hpp │ │ ├── mat3x4.hpp │ │ ├── mat4x2.hpp │ │ ├── mat4x3.hpp │ │ ├── mat4x4.hpp │ │ ├── matrix.hpp │ │ ├── packing.hpp │ │ ├── simd/ │ │ │ ├── common.h │ │ │ ├── exponential.h │ │ │ ├── geometric.h │ │ │ ├── integer.h │ │ │ ├── matrix.h │ │ │ ├── neon.h │ │ │ ├── packing.h │ │ │ ├── platform.h │ │ │ ├── trigonometric.h │ │ │ └── vector_relational.h │ │ ├── trigonometric.hpp │ │ ├── vec2.hpp │ │ ├── vec3.hpp │ │ ├── vec4.hpp │ │ └── vector_relational.hpp │ └── main/ │ ├── AndroidManifest.xml │ └── java/ │ └── com/ │ └── example/ │ └── flutter_opengl/ │ └── FlutterOpenglPlugin.java ├── example/ │ ├── .gitignore │ ├── README.md │ ├── analysis_options.yaml │ ├── android/ │ │ ├── .gitignore │ │ ├── app/ │ │ │ ├── build.gradle │ │ │ └── src/ │ │ │ ├── debug/ │ │ │ │ └── AndroidManifest.xml │ │ │ ├── main/ │ │ │ │ ├── AndroidManifest.xml │ │ │ │ ├── java/ │ │ │ │ │ └── com/ │ │ │ │ │ └── example/ │ │ │ │ │ └── flutter_opengl_example/ │ │ │ │ │ └── MainActivity.java │ │ │ │ ├── kotlin/ │ │ │ │ │ └── com/ │ │ │ │ │ └── example/ │ │ │ │ │ └── flutter_opengl_example/ │ │ │ │ │ └── MainActivity.kt │ │ │ │ └── res/ │ │ │ │ ├── drawable/ │ │ │ │ │ └── launch_background.xml │ │ │ │ ├── drawable-v21/ │ │ │ │ │ └── launch_background.xml │ │ │ │ ├── values/ │ │ │ │ │ └── styles.xml │ │ │ │ └── values-night/ │ │ │ │ └── styles.xml │ │ │ └── profile/ │ │ │ └── AndroidManifest.xml │ │ ├── build.gradle │ │ ├── gradle/ │ │ │ └── wrapper/ │ │ │ └── gradle-wrapper.properties │ │ ├── gradle.properties │ │ └── settings.gradle │ ├── ios/ │ │ ├── .gitignore │ │ ├── Flutter/ │ │ │ ├── AppFrameworkInfo.plist │ │ │ ├── Debug.xcconfig │ │ │ └── Release.xcconfig │ │ ├── Runner/ │ │ │ ├── AppDelegate.swift │ │ │ ├── Assets.xcassets/ │ │ │ │ ├── AppIcon.appiconset/ │ │ │ │ │ └── Contents.json │ │ │ │ └── LaunchImage.imageset/ │ │ │ │ ├── Contents.json │ │ │ │ └── README.md │ │ │ ├── Base.lproj/ │ │ │ │ ├── LaunchScreen.storyboard │ │ │ │ └── Main.storyboard │ │ │ ├── Info.plist │ │ │ └── Runner-Bridging-Header.h │ │ ├── Runner.xcodeproj/ │ │ │ ├── project.pbxproj │ │ │ ├── project.xcworkspace/ │ │ │ │ ├── contents.xcworkspacedata │ │ │ │ └── xcshareddata/ │ │ │ │ ├── IDEWorkspaceChecks.plist │ │ │ │ └── WorkspaceSettings.xcsettings │ │ │ └── xcshareddata/ │ │ │ └── xcschemes/ │ │ │ └── Runner.xcscheme │ │ └── Runner.xcworkspace/ │ │ ├── contents.xcworkspacedata │ │ └── xcshareddata/ │ │ ├── IDEWorkspaceChecks.plist │ │ └── WorkspaceSettings.xcsettings │ ├── lib/ │ │ ├── controls/ │ │ │ ├── ShaderButtons.dart │ │ │ ├── controls.dart │ │ │ ├── texture_chooser.dart │ │ │ └── texture_sizes.dart │ │ ├── edit_shader.dart │ │ ├── main.dart │ │ ├── main_in_deep.dart │ │ ├── shader_widget.dart │ │ ├── shadertoy.dart │ │ ├── states.dart │ │ └── test_widget.dart │ ├── linux/ │ │ ├── .gitignore │ │ ├── CMakeLists.txt │ │ ├── flutter/ │ │ │ ├── CMakeLists.txt │ │ │ ├── generated_plugin_registrant.cc │ │ │ ├── generated_plugin_registrant.h │ │ │ └── generated_plugins.cmake │ │ ├── main.cc │ │ ├── my_application.cc │ │ └── my_application.h │ ├── macos/ │ │ ├── .gitignore │ │ ├── Flutter/ │ │ │ ├── Flutter-Debug.xcconfig │ │ │ ├── Flutter-Release.xcconfig │ │ │ └── GeneratedPluginRegistrant.swift │ │ ├── Runner/ │ │ │ ├── AppDelegate.swift │ │ │ ├── Assets.xcassets/ │ │ │ │ └── AppIcon.appiconset/ │ │ │ │ └── Contents.json │ │ │ ├── Base.lproj/ │ │ │ │ └── MainMenu.xib │ │ │ ├── Configs/ │ │ │ │ ├── AppInfo.xcconfig │ │ │ │ ├── Debug.xcconfig │ │ │ │ ├── Release.xcconfig │ │ │ │ └── Warnings.xcconfig │ │ │ ├── DebugProfile.entitlements │ │ │ ├── Info.plist │ │ │ ├── MainFlutterWindow.swift │ │ │ └── Release.entitlements │ │ ├── Runner.xcodeproj/ │ │ │ ├── project.pbxproj │ │ │ ├── project.xcworkspace/ │ │ │ │ └── xcshareddata/ │ │ │ │ └── IDEWorkspaceChecks.plist │ │ │ └── xcshareddata/ │ │ │ └── xcschemes/ │ │ │ └── Runner.xcscheme │ │ └── Runner.xcworkspace/ │ │ ├── contents.xcworkspacedata │ │ └── xcshareddata/ │ │ └── IDEWorkspaceChecks.plist │ ├── pubspec.yaml │ ├── test/ │ │ └── widget_test.dart │ └── windows/ │ ├── .gitignore │ ├── CMakeLists.txt │ ├── flutter/ │ │ ├── CMakeLists.txt │ │ ├── generated_plugin_registrant.cc │ │ ├── generated_plugin_registrant.h │ │ └── generated_plugins.cmake │ └── runner/ │ ├── CMakeLists.txt │ ├── Runner.rc │ ├── flutter_window.cpp │ ├── flutter_window.h │ ├── main.cpp │ ├── resource.h │ ├── runner.exe.manifest │ ├── utils.cpp │ ├── utils.h │ ├── win32_window.cpp │ └── win32_window.h ├── lib/ │ ├── flutter_opengl.dart │ └── src/ │ ├── flutter_opengl.dart │ ├── flutter_opengl_ffi.dart │ ├── flutter_opengl_method_channel.dart │ ├── flutter_opengl_platform_interface.dart │ ├── ogl_utils.dart │ ├── opengl_controller.dart │ └── opengl_texture.dart ├── linux/ │ ├── CMakeLists.txt │ ├── fl_my_texture_gl.cc │ ├── flutter_opengl_plugin.cc │ ├── include/ │ │ ├── fl_my_texture_gl.h │ │ ├── flutter_opengl/ │ │ │ └── flutter_opengl_plugin.h │ │ └── test.h │ └── test.cpp ├── pubspec.yaml ├── src/ │ ├── Renderer.cpp │ ├── Renderer.h │ ├── Sampler2D.cpp │ ├── Sampler2D.h │ ├── Shader.cpp │ ├── Shader.h │ ├── common.h │ ├── ffi.cpp │ ├── ffi.h │ ├── ndk/ │ │ └── ndk.cpp │ ├── opencv_capture.cpp │ ├── opencv_capture.h │ ├── uniformQueue.cpp │ └── uniformQueue.h ├── test/ │ ├── flutter_opengl_method_channel_test.dart │ └── flutter_opengl_test.dart └── windows/ ├── .gitignore ├── CMakeLists.txt ├── fl_my_texture_gl.cc ├── fl_my_texture_gl.h ├── flutter_opengl_plugin.cpp ├── flutter_opengl_plugin.h ├── flutter_opengl_plugin_c_api.cpp └── include/ └── flutter_opengl/ └── flutter_opengl_plugin_c_api.h ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ # Miscellaneous *.class *.log *.pyc *.swp .DS_Store .atom/ .buildlog/ .history .svn/ migrate_working_dir/ # IntelliJ related *.iml *.ipr *.iws .idea/ # The .vscode folder contains launch configuration and tasks you configure in # VS Code which you may wish to be included in version control, so this line # is commented out by default. #.vscode/ # Flutter/Dart/Pub related # Libraries should not include pubspec.lock, per https://dart.dev/guides/libraries/private-files#pubspeclock. /pubspec.lock **/doc/api/ .dart_tool/ .packages build/ android/src/opencv WORK/ BUILD_LIBS/ SCRIPTS/ !SCRIPTS/setupOpenCV-android.sh #libraries to download windows/glm/ windows/Native_SDK/ windows/glew ================================================ FILE: .metadata ================================================ # This file tracks properties of this Flutter project. # Used by Flutter tool to assess capabilities and perform upgrades etc. # # This file should be version controlled. version: revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 channel: stable project_type: plugin # Tracks metadata for the flutter migrate command migration: platforms: - platform: root create_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 base_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 - platform: android create_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 base_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 - platform: ios create_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 base_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 - platform: linux create_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 base_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 - platform: macos create_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 base_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 - platform: windows create_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 base_revision: 52b3dc25f6471c27b2144594abb11c741cb88f57 # User provided section # List of Local paths (relative to this file) that should be # ignored by the migrate tool. # # Files that are not part of the templates will be ignored by default. unmanaged_files: - 'lib/main.dart' - 'ios/Runner.xcodeproj/project.pbxproj' ================================================ FILE: .vscode/c_cpp_properties.json ================================================ { "configurations": [ { "name": "Linux", "includePath": [ "${workspaceFolder}/**", "${workspaceFolder}/linux/include", "${workspaceFolder}/linux/include/flutter_opengl", "${workspaceFolder}/src" ], "defines": [], "compilerPath": "/usr/bin/clang", "cStandard": "c17", "cppStandard": "c++17", "intelliSenseMode": "linux-clang-x64", "compileCommands": "${workspaceFolder}/build/compile_commands.json", "configurationProvider": "ms-vscode.cmake-tools" }, { "name": "Win32", "includePath": [ "${workspaceFolder}/**" ], "defines": [ "_DEBUG", "UNICODE", "_UNICODE" ], "windowsSdkVersion": "10.0.19041.0", "compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.32.31326/bin/Hostx64/x64/cl.exe", "cStandard": "c17", "cppStandard": "c++17", "intelliSenseMode": "windows-msvc-x64", "configurationProvider": "ms-vscode.cmake-tools" } ], "version": 4 } ================================================ FILE: .vscode/extensions.json ================================================ { "recommendations": [ "ms-vscode.cpptools", "ms-vscode.cpptools-extension-pack", "Dart-Code.flutter" ] } ================================================ FILE: .vscode/launch.json ================================================ { // Use IntelliSense to learn about possible attributes. // Hover to view descriptions of existing attributes. // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 "version": "0.2.0", "configurations": [ { "name": "example (debug mode)", "cwd": "example", "request": "launch", "type": "dart" }, { "name": "example (profile mode)", "cwd": "example", "request": "launch", "type": "dart", "flutterMode": "profile" }, { "name": "example (release mode)", "cwd": "example", "request": "launch", "type": "dart", "flutterMode": "release" }, { "name": "Debug native Windows", "preLaunchTask": "compile windows debug", "type": "cppvsdbg", "request": "launch", "args": [], // "environment": [{"name": "MESA_EGL_VERSION_OVERRIDE", "value": "3.3FC"}], "program": "${workspaceFolder}/example/build/windows/runner/Debug/flutter_opengl_example.exe", "cwd": "${workspaceFolder}" }, { "name": "Debug native Windows VERBOSE", "preLaunchTask": "compile windows debug verbose", "type": "cppvsdbg", "request": "launch", "args": [], // "environment": [{"name": "MESA_EGL_VERSION_OVERRIDE", "value": "3.3FC"}], "program": "${workspaceFolder}/example/build/windows/runner/Debug/flutter_opengl_example.exe", "cwd": "${workspaceFolder}" }, { "name": "Debug native Linux", "preLaunchTask": "compile linux debug", "type": "cppdbg", "request": "launch", "args": [], // "environment": [{"name": "MESA_EGL_VERSION_OVERRIDE", "value": "3.3FC"}], "program": "${workspaceFolder}/example/build/linux/x64/debug/bundle/flutter_opengl_example", "cwd": "${workspaceFolder}" }, { "name": "Debug native Linux VERBOSE", "preLaunchTask": "compile linux debug verbose", "type": "cppdbg", "request": "launch", "program": "${workspaceFolder}/example/build/linux/x64/debug/bundle/flutter_opengl_example", "cwd": "${workspaceFolder}" } ] } ================================================ FILE: .vscode/settings.json ================================================ { "cmake.sourceDirectory": "${workspaceFolder}/linux", "cmake.configureOnOpen": true, "files.associations": { "compare": "cpp", "functional": "cpp", "condition_variable": "cpp", "iostream": "cpp", "cstring": "cpp", "cstdint": "cpp", "sstream": "cpp", "array": "cpp", "atomic": "cpp", "bit": "cpp", "*.tcc": "cpp", "cctype": "cpp", "chrono": "cpp", "clocale": "cpp", "cmath": "cpp", "concepts": "cpp", "cstdio": "cpp", "cstdlib": "cpp", "ctime": "cpp", "cwchar": "cpp", "cwctype": "cpp", "unordered_map": "cpp", "vector": "cpp", "exception": "cpp", "future": "cpp", "initializer_list": "cpp", "iosfwd": "cpp", "istream": "cpp", "limits": "cpp", "memory": "cpp", "mutex": "cpp", "new": "cpp", "numbers": "cpp", "ostream": "cpp", "ratio": "cpp", "semaphore": "cpp", "stdexcept": "cpp", "stop_token": "cpp", "streambuf": "cpp", "string": "cpp", "string_view": "cpp", "system_error": "cpp", "thread": "cpp", "tuple": "cpp", "type_traits": "cpp", "typeinfo": "cpp", "utility": "cpp", "any": "cpp", "hash_map": "cpp", "hash_set": "cpp", "bitset": "cpp", "cinttypes": "cpp", "codecvt": "cpp", "complex": "cpp", "csignal": "cpp", "cstdarg": "cpp", "cstddef": "cpp", "deque": "cpp", "forward_list": "cpp", "list": "cpp", "map": "cpp", "set": "cpp", "unordered_set": "cpp", "algorithm": "cpp", "iterator": "cpp", "memory_resource": "cpp", "numeric": "cpp", "optional": "cpp", "random": "cpp", "fstream": "cpp", "iomanip": "cpp", "cfenv": "cpp", "typeindex": "cpp", "valarray": "cpp", "variant": "cpp", "charconv": "cpp", "coroutine": "cpp", "resumable": "cpp", "format": "cpp", "ios": "cpp", "locale": "cpp", "xfacet": "cpp", "xhash": "cpp", "xiosbase": "cpp", "xlocale": "cpp", "xlocbuf": "cpp", "xlocinfo": "cpp", "xlocmes": "cpp", "xlocmon": "cpp", "xlocnum": "cpp", "xloctime": "cpp", "xmemory": "cpp", "xstddef": "cpp", "xstring": "cpp", "xtr1common": "cpp", "xtree": "cpp", "xutility": "cpp", "regex": "cpp", "shared_mutex": "cpp", "queue": "cpp", "ranges": "cpp", "span": "cpp" } } ================================================ FILE: .vscode/tasks.json ================================================ { "version": "2.0.0", "tasks": [ { "label": "compile linux debug verbose", "command": "cd ${workspaceFolder}/example && flutter build linux -t lib/main_in_deep.dart --debug --verbose", // "args": ["build", "linux", "--verbose"], "type": "shell" }, { "label": "compile linux debug", "command": "cd ${workspaceFolder}/example; flutter build linux -t lib/main_in_deep.dart --debug", // "args": ["build", "linux"], "type": "shell" }, { "label": "compile windows debug verbose", "command": "cd ${workspaceFolder}/example; flutter build windows -t lib/main_in_deep.dart --debug --verbose", // "args": ["build", "linux"], "type": "shell" }, { "label": "compile windows debug", "command": "cd ${workspaceFolder}/example; flutter build windows -t lib/main_in_deep.dart --debug", // "args": ["build", "linux"], "type": "shell" }, ] } ================================================ FILE: CHANGELOG.md ================================================ ## 0.9.0 Code rewritten. Support for Android, Linux and Windows ================================================ FILE: LICENSE ================================================ Copyright 2019 Marco Bavagnoli Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ================================================ FILE: README.md ================================================ # flutter_opengl A Flutter OpenGL ES plugin using a Texture() widget. Supports Android, Linux and Windows. Many shaders from ShaderToy.com can be copy/pasted ## Getting Started | Android | Windows | Linux | iOS | MacOS | Web| | ---- | ---- | ---- | ---- | ---- | ---- | | ✅ | ✅ | ✅ | x | x | x| ![gif](https://github.com/alnitak/flutter_opengl/blob/master/images/flutter_opengl.gif?raw=true "Flutter OpenGL Demo") ![gif](https://github.com/alnitak/flutter_opengl/blob/master/images/flutter_OpenGL-video.gif?raw=true "Flutter OpenGL Demo") ![gif](https://github.com/alnitak/flutter_opengl/blob/master/images/flutter_OpenGL-textures.gif?raw=true "Flutter OpenGL Demo") The main workflow of the plugin is: - ask to native code with a MethodChannel for a texture ID - use the texture ID in a Texture() widget - set a vertex and a fragment sources - start the renderer - change shader sources on the fly All functionalities, but the first call to the first method channel, use FFI calls. The starting idea developing this plugin, was not just to use GLSL, but also take advantage of the wonderful [ShaderToy](https://www.shadertoy.com/) web site. For now it's possible to copy/paste shaders from ShaderToy, but only those which have only one layer. Be aware that on a real device, many shaders could be very slow because they are hungry of power and some others needs ES 3 and for now is not supported on Android (ie latest 3 shaders in the *lib/main_in_deep.dart* example). ***iResolution***, ***iTime***, ***iMouse***, ***iChannel[0-3]*** are supported, other uniforms can be added at run-time. - ***iResolution*** is a vec3 uniform which represents the texture size - ***iTime*** is a float which represents the time since the shader was created - ***iMouse*** is a vec4 which the x and y values represent the coordinates where the mouse or the touch is grabbed hover the *Texture()* widget - ***iChannel[0-3]*** Sampler2D uniform textures ### Simple example ```dart SizedBox( width: 400, height: 300, child: FutureBuilder( /// The surface size identifies the real texture size and /// it is not related to the above SizedBox size future: OpenGLController().openglPlugin.createSurface(300, 200), builder: (_, snapshot) { if (snapshot.hasError || !snapshot.hasData) { return const SizedBox.shrink(); } /// When the texture id is retrieved, it will be possible /// to start the renderer, set a shader and display it. /// Start renderer thread OpenGLController().openglFFI.startThread(); /// Set the fragment shader OpenGLController().openglFFI.setShaderToy(fShader); /// build the texture widget return OpenGLTexture(id: snapshot.data!); }, ), ) ``` Look at ***example/lib/main_in_deep.dart*** for a full fledged example. Once the renderer is started all the below methods can be used via *OpenGLController().openglFFI*: | method | description | | ---- | ---- | | bool **rendererStatus**() | Returns true if the texture has been created successfully via *OpenGLController().openglPlugin.createSurface()* | | Size **getTextureSize**() | Get the size of the current texture. If not set it returns Size(-1, -1)| | **startThread**() | Starts the drawing thread loop. | | **stopThread**() | Delete shader, delete texture and stops the drawing thread loop. | |String **setShader**(bool isContinuous, String vertexShader, String fragmentShader)|**isContinuous** not used yet.
**vertexShader** String of the vertex shader source.
**fragmentShader** String of the fragment shader source

returns the compiling shader error string or an empty string if no errors.| | String **setShaderToy**(String fragmentShader) |Set the shader to be used in the current texture.
These are only fragment shaders taken from ShaderToy.com
Many of the shaders can be copy/pasted, but they must have only the "image" layer (ie no buffer).
Also many of them could be heavy for mobile devices (few FPS).

The uniforms actually available and automatically registered are:
float **iTime**
vec4 **iMouse**
vec3 **iResolution**
Sampler2D **iChannel[0-3]**| | String **getVertexShader**() |Get current vertex shader text.| | String **getFragmentShader**() |Get current fragment shader text.| | **addShaderToyUniforms**() |add these uniforms:
vec4 **iMouse**
vec3 **iResolution**
float **iTime**
Sampler2D **iChannel[0-3]**
These uniforms are automatically set when using **setShaderToy()**| |**setMousePosition**(Offset startingPos, Offset pos, PointerEventType eventType, Size twSize)|Set the **iMouse** uniform.
How to use the mouse input (only left button supported):
mouse.xy = mouse position during last button down
abs(mouse.zw) = mouse position during last button click
sign(mouze.z) = button is down
sign(mouze.w) = button is clicked

This is automatically processed by **OpenGLTexture** widget

For reference:
https://www.shadertoy.com/view/llySRh
https://www.shadertoy.com/view/Mss3zH| | double **getFps**() |Get current FPS (capped to 100).| |bool **addBoolUniform**(String name, bool val)
bool **addIntUniform**(String name, int val)
bool **addFloatUniform**(String name, double val)
bool **addVec2Uniform**(String name, List`` val)
bool **addVec3Uniform**(String name, List`` val)
bool **addVec4Uniform**(String name, List`` val)
bool **addMat2Uniform**(String name, List`` val)
bool **addMat3Uniform**(String name, List`` val)
bool **addMat4Uniform**(String name, List`` val)| Add an uniforms.
Return true if succes or false if already added.| |bool **addSampler2DUniform**(String name, int width, int height, Uint8List val)| Add a Sampler2D uniform. The raw image stored in *val* must be in RGBA32 format.| |bool **replaceSampler2DUniform**(String name, int width, int height, Uint8List val)|Replace a Sampler2D uniform texture with another one with different size.| |bool **setBoolUniform**(String name, bool val)
bool **setIntUniform**(String name, int val)
bool **setFloatUniform**(String name, double val)
bool **setVec2Uniform**(String name, List`` val)
bool **setVec3Uniform**(String name, List`` val)
bool **setVec4Uniform**(String name, List`` val)
bool **setMat2Uniform**(String name, List`` val)
bool **setMat3Uniform**(String name, List`` val)
bool **setMat4Uniform**(String name, List`` val)| Set value of an existing uniform. Return false if the uniform doesn't exist.| |bool **setSampler2DUniform**(String name, Uint8List val)|Replace a texture with another image with the same size.
Be sure the *val* length is the same as the previously stored image with the uniform named *name*.| |bool **startCaptureOnSampler2D**(String name, String completeFilePath)|Set Sampler2D uniform *name* with frames captured by OpenCV VideoCapture

*completeFilePath* can be:
- 'cam0' for webCam0
- 'cam1' for webCam1
- a complete local video file path

**Note**: this video capture is just for reference on how textures work in real time. Videos FPS are not precise and the camera on Android doesn't work.| | bool **stopCapture**() | Stop capturing thread.| # Setup ## Linux Be sure you have **glew**, **glm** and **OpenCV** packages installed. ## Windows Go into the windows folder from the project root. - clone **Native_SDK**: ```git clone https://github.com/powervr-graphics/Native_SDK.git``` you can safely delete all but the *lib* and *include* directories from the cloned repo - clone **glm** ```git clone https://github.com/g-truc/glm.git``` - download **glew** *Binaries for Windows 32-bit and 64-bit* from here: [https://glew.sourceforge.net](https://glew.sourceforge.net/) (sources at https://github.com/nigels-com/glew) extract the zip and rename its main directory to "glew" - run "SCRIPTS\setupOpenCV-windows.bat" or manually download OpenCV and extract it into SCRIPT dir: https://github.com/opencv/opencv/releases/download/4.7.0/opencv-4.7.0-windows.exe ## Android Run the script *SCRIPT/setupOpenCV-android.sh* or manually download OpenCV from here https://github.com/opencv/opencv/releases/download/4.7.0/opencv-4.7.0-android-sdk.zip locate libs and include folders and copy them into android/src/opencv. # TODO - better docomentation - the c/c++ code is not "state of the art" written! PRs are welcomed - iOS, Mac and Web support - ES 3 on Android (now supports 2) - displayed FPS seems not to be correct - leave OpenCV into the plugin for further use? ================================================ FILE: SCRIPTS/setupOpenCV-android.sh ================================================ #!/bin/bash wget https://github.com/opencv/opencv/releases/download/4.7.0/opencv-4.7.0-android-sdk.zip unzip opencv-4.7.0-android-sdk.zip rm -frd ../android/src/opencv cp -r ./OpenCV-android-sdk/sdk/native/libs ../android/src/opencv cp -r ./OpenCV-android-sdk/sdk/native/jni/include ../android/src/opencv ================================================ FILE: analysis_options.yaml ================================================ include: package:flutter_lints/flutter.yaml # Additional information about this file can be found at # https://dart.dev/guides/language/analysis-options ================================================ FILE: android/.gitignore ================================================ *.iml .gradle /local.properties /.idea/workspace.xml /.idea/libraries .DS_Store /build /captures .cxx ================================================ FILE: android/CMakeLists.txt ================================================ # For more information about using CMake with Android Studio, read the # documentation: https://d.android.com/studio/projects/add-native-code.html # Sets the minimum version of CMake required to build the native library. cmake_minimum_required(VERSION 3.4.1) #cmake_minimum_required(VERSION 3.22.1) # Project-level configuration. set(PROJECT_NAME "flutter_opengl") project(${PROJECT_NAME} LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) # This value is used when generating builds using this plugin, so it must # not be changed. set(PLUGIN_NAME "flutter_opengl_plugin") message(${ANDROID_ABI}) # Creates and names a library, sets it as either STATIC # or SHARED, and provides the relative paths to its source code. # You can define multiple libraries, and CMake builds them for you. # Gradle automatically packages shared libraries with your APK. add_library( # Sets the name of the library. ${PLUGIN_NAME} # Sets the library as a shared library. SHARED # Provides a relative path to your source file(s). ../src/ndk/ndk.cpp ../src/common.h ../src/ffi.cpp ../src/Renderer.cpp ../src/Shader.cpp ../src/uniformQueue.cpp ../src/Sampler2D.cpp ../src/Sampler2D.cpp ../src/opencv_capture.cpp ) #set (CMAKE_SHARED_LINKER_FLAGS "-Wl,--gc-sections,--strip-debug -fvisibility=hidden -fuse-ld=lld") # Searches for a specified prebuilt library and stores the path as a # variable. Because CMake includes system libraries in the search path by # default, you only need to specify the name of the public NDK library # you want to add. CMake verifies that the library exists before # completing its build. find_library( # Sets the name of the path variable. log-lib # Specifies the name of the NDK library that # you want CMake to locate. log) add_subdirectory(src/glm) add_library(glm::glm ALIAS glm) set (OPENCV_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/opencv) set (OPENCV_LIBS_LOC ${OPENCV_DIR}/${ANDROID_ABI}) # trying to use OpenCV camera with ffmpeg. No success for now #set (FFMPEG_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/ffmpeg) #set (FFMPEG_LIBS_LOC ${FFMPEG_DIR}/${ANDROID_ABI}) #set (FFMPEG_DIR ${OPENCV_DIR}) #set (FFMPEG_LIBS_LOC ${OPENCV_DIR}/${ANDROID_ABI}) target_link_libraries( # Specifies the target library. ${PLUGIN_NAME} # Links the target library to the log library # included in the NDK. ${log-lib} android EGL # GLESv1_CM # GLESv2 GLESv3 glm dl m mediandk jnigraphics # ${OPENCV_LIBS_LOC}/libopencv_core.so # ${OPENCV_LIBS_LOC}/libopencv_highgui.so # ${OPENCV_LIBS_LOC}/libopencv_imgcodecs.so # ${OPENCV_LIBS_LOC}/libopencv_img_hash.so # ${OPENCV_LIBS_LOC}/libopencv_imgproc.so # ${OPENCV_LIBS_LOC}/libopencv_videoio.so # ${OPENCV_LIBS_LOC}/libopencv_video.so # ${OPENCV_LIBS_LOC}/libopencv_videostab.so # ${OPENCV_LIBS_LOC}/libopencv_dnn.so # ${OPENCV_LIBS_LOC}/libopencv_calib3d.so # ${OPENCV_LIBS_LOC}/libopencv_photo.so # ${OPENCV_LIBS_LOC}/libopencv_features2d.so # ${OPENCV_LIBS_LOC}/libopencv_flann.so ${OPENCV_DIR}/${ANDROID_ABI}/libopencv_java4.so # ${FFMPEG_LIBS_LOC}/libavcodec.so # ${FFMPEG_LIBS_LOC}/libavdevice.so # ${FFMPEG_LIBS_LOC}/libavfilter.so # ${FFMPEG_LIBS_LOC}/libavformat.so # ${FFMPEG_LIBS_LOC}/libavutil.so # ${FFMPEG_LIBS_LOC}/libswresample.so # ${FFMPEG_LIBS_LOC}/libswscale.so ) include_directories( ../src ) include_directories( src/glm/ ) include_directories( ${OPENCV_DIR}/include ) include_directories( ${FFMPEG_DIR}/include ) ================================================ FILE: android/build.gradle ================================================ group 'com.example.flutter_opengl' version '1.0' buildscript { repositories { google() mavenCentral() } dependencies { // classpath 'com.android.tools.build:gradle:7.1.3' classpath 'com.android.tools.build:gradle:7.3.1' } } rootProject.allprojects { repositories { google() mavenCentral() } } apply plugin: 'com.android.library' android { compileSdkVersion 33 compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } defaultConfig { minSdkVersion 24 targetSdkVersion 33 packagingOptions { doNotStrip '**.so' } sourceSets { main { jniLibs.srcDirs = ['src/opencv/libs'] } } externalNativeBuild { cmake { arguments '-DBUILD_TESTING=OFF', '-DANDROID_TOOLCHAIN=clang', '-DCMAKE_VERBOSE_MAKEFILE=ON', '-DANDROID_STL=c++_shared' cppFlags "-std=c++17 -fexceptions -frtti -stdlib=libc++ -v" } } } externalNativeBuild { cmake { path "CMakeLists.txt" // version "3.22.1" } } buildTypes { release { minifyEnabled false shrinkResources false proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' } debug { debuggable true } } buildToolsVersion '32.0.0' compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } } ================================================ FILE: android/gradle/wrapper/gradle-wrapper.properties ================================================ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists ================================================ FILE: android/gradlew ================================================ #!/bin/sh # # Copyright © 2015-2021 the original authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ############################################################################## # # Gradle start up script for POSIX generated by Gradle. # # Important for running: # # (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is # noncompliant, but you have some other compliant shell such as ksh or # bash, then to run this script, type that shell name before the whole # command line, like: # # ksh Gradle # # Busybox and similar reduced shells will NOT work, because this script # requires all of these POSIX shell features: # * functions; # * expansions «$var», «${var}», «${var:-default}», «${var+SET}», # «${var#prefix}», «${var%suffix}», and «$( cmd )»; # * compound commands having a testable exit status, especially «case»; # * various built-in commands including «command», «set», and «ulimit». # # Important for patching: # # (2) This script targets any POSIX shell, so it avoids extensions provided # by Bash, Ksh, etc; in particular arrays are avoided. # # The "traditional" practice of packing multiple parameters into a # space-separated string is a well documented source of bugs and security # problems, so this is (mostly) avoided, by progressively accumulating # options in "$@", and eventually passing that to Java. # # Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, # and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; # see the in-line comments for details. # # There are tweaks for specific operating systems such as AIX, CygWin, # Darwin, MinGW, and NonStop. # # (3) This script is generated from the Groovy template # https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt # within the Gradle project. # # You can find Gradle at https://github.com/gradle/gradle/. # ############################################################################## # Attempt to set APP_HOME # Resolve links: $0 may be a link app_path=$0 # Need this for daisy-chained symlinks. while APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path [ -h "$app_path" ] do ls=$( ls -ld "$app_path" ) link=${ls#*' -> '} case $link in #( /*) app_path=$link ;; #( *) app_path=$APP_HOME$link ;; esac done APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit APP_NAME="Gradle" APP_BASE_NAME=${0##*/} # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD=maximum warn () { echo "$*" } >&2 die () { echo echo "$*" echo exit 1 } >&2 # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false nonstop=false case "$( uname )" in #( CYGWIN* ) cygwin=true ;; #( Darwin* ) darwin=true ;; #( MSYS* | MINGW* ) msys=true ;; #( NONSTOP* ) nonstop=true ;; esac CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD=$JAVA_HOME/jre/sh/java else JAVACMD=$JAVA_HOME/bin/java fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD=java which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi # Increase the maximum file descriptors if we can. if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then case $MAX_FD in #( max*) MAX_FD=$( ulimit -H -n ) || warn "Could not query maximum file descriptor limit" esac case $MAX_FD in #( '' | soft) :;; #( *) ulimit -n "$MAX_FD" || warn "Could not set maximum file descriptor limit to $MAX_FD" esac fi # Collect all arguments for the java command, stacking in reverse order: # * args from the command line # * the main class name # * -classpath # * -D...appname settings # * --module-path (only if needed) # * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. # For Cygwin or MSYS, switch paths to Windows format before running java if "$cygwin" || "$msys" ; then APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) JAVACMD=$( cygpath --unix "$JAVACMD" ) # Now convert the arguments - kludge to limit ourselves to /bin/sh for arg do if case $arg in #( -*) false ;; # don't mess with options #( /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath [ -e "$t" ] ;; #( *) false ;; esac then arg=$( cygpath --path --ignore --mixed "$arg" ) fi # Roll the args list around exactly as many times as the number of # args, so each arg winds up back in the position where it started, but # possibly modified. # # NB: a `for` loop captures its iteration list before it begins, so # changing the positional parameters here affects neither the number of # iterations, nor the values presented in `arg`. shift # remove old arg set -- "$@" "$arg" # push replacement arg done fi # Collect all arguments for the java command; # * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of # shell script including quotes and variable substitutions, so put them in # double quotes to make sure that they get re-expanded; and # * put everything else in single quotes, so that it's not re-expanded. set -- \ "-Dorg.gradle.appname=$APP_BASE_NAME" \ -classpath "$CLASSPATH" \ org.gradle.wrapper.GradleWrapperMain \ "$@" # Use "xargs" to parse quoted args. # # With -n1 it outputs one arg per line, with the quotes and backslashes removed. # # In Bash we could simply go: # # readarray ARGS < <( xargs -n1 <<<"$var" ) && # set -- "${ARGS[@]}" "$@" # # but POSIX shell has neither arrays nor command substitution, so instead we # post-process each arg (as a line of input to sed) to backslash-escape any # character that might be a shell metacharacter, then use eval to reverse # that process (while maintaining the separation between arguments), and wrap # the whole thing up as a single "set" statement. # # This will of course break if any of these variables contains a newline or # an unmatched quote. # eval "set -- $( printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | xargs -n1 | sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | tr '\n' ' ' )" '"$@"' exec "$JAVACMD" "$@" ================================================ FILE: android/gradlew.bat ================================================ @rem @rem Copyright 2015 the original author or authors. @rem @rem Licensed under the Apache License, Version 2.0 (the "License"); @rem you may not use this file except in compliance with the License. @rem You may obtain a copy of the License at @rem @rem https://www.apache.org/licenses/LICENSE-2.0 @rem @rem Unless required by applicable law or agreed to in writing, software @rem distributed under the License is distributed on an "AS IS" BASIS, @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @rem See the License for the specific language governing permissions and @rem limitations under the License. @rem @if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Resolve any "." and ".." in APP_HOME to make it shorter. for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if "%ERRORLEVEL%" == "0" goto execute echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto execute echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* :end @rem End local scope for the variables with windows NT shell if "%ERRORLEVEL%"=="0" goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 exit /b 1 :mainEnd if "%OS%"=="Windows_NT" endlocal :omega ================================================ FILE: android/proguard-rules.pro ================================================ #Flutter Wrapper -keep class io.flutter.app.** { *; } -keep class io.flutter.plugin.** { *; } -keep class io.flutter.util.** { *; } -keep class io.flutter.view.** { *; } -keep class io.flutter.** { *; } -keep class io.flutter.plugins.** { *; } -dontwarn android.** -keep class androidx.lifecycle.** { *; } #https://github.com/flutter/flutter/issues/58479 ================================================ FILE: android/settings.gradle ================================================ rootProject.name = 'flutter_opengl' ================================================ FILE: android/src/glm/CMakeLists.txt ================================================ file(GLOB ROOT_SOURCE *.cpp) file(GLOB ROOT_INLINE *.inl) file(GLOB ROOT_HEADER *.hpp) file(GLOB ROOT_TEXT ../*.txt) file(GLOB ROOT_MD ../*.md) file(GLOB ROOT_NAT ../util/glm.natvis) file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp) file(GLOB_RECURSE CORE_INLINE ./detail/*.inl) file(GLOB_RECURSE CORE_HEADER ./detail/*.hpp) file(GLOB_RECURSE EXT_SOURCE ./ext/*.cpp) file(GLOB_RECURSE EXT_INLINE ./ext/*.inl) file(GLOB_RECURSE EXT_HEADER ./ext/*.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) file(GLOB_RECURSE SIMD_SOURCE ./simd/*.cpp) file(GLOB_RECURSE SIMD_INLINE ./simd/*.inl) file(GLOB_RECURSE SIMD_HEADER ./simd/*.h) source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD}) source_group("Core Files" FILES ${CORE_SOURCE}) source_group("Core Files" FILES ${CORE_INLINE}) source_group("Core Files" FILES ${CORE_HEADER}) source_group("EXT Files" FILES ${EXT_SOURCE}) source_group("EXT Files" FILES ${EXT_INLINE}) source_group("EXT Files" FILES ${EXT_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}) source_group("SIMD Files" FILES ${SIMD_SOURCE}) source_group("SIMD Files" FILES ${SIMD_INLINE}) source_group("SIMD Files" FILES ${SIMD_HEADER}) add_library(glm INTERFACE) target_include_directories(glm INTERFACE ../) if(BUILD_STATIC_LIBS) add_library(glm_static STATIC ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT} ${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER} ${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER} ${EXT_SOURCE} ${EXT_INLINE} ${EXT_HEADER} ${GTC_SOURCE} ${GTC_INLINE} ${GTC_HEADER} ${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER} ${SIMD_SOURCE} ${SIMD_INLINE} ${SIMD_HEADER}) target_link_libraries(glm_static PUBLIC glm) add_library(glm::glm_static ALIAS glm_static) endif() if(BUILD_SHARED_LIBS) add_library(glm_shared SHARED ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT} ${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER} ${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER} ${EXT_SOURCE} ${EXT_INLINE} ${EXT_HEADER} ${GTC_SOURCE} ${GTC_INLINE} ${GTC_HEADER} ${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER} ${SIMD_SOURCE} ${SIMD_INLINE} ${SIMD_HEADER}) target_link_libraries(glm_shared PUBLIC glm) add_library(glm::glm_shared ALIAS glm_shared) endif() ================================================ FILE: android/src/glm/common.hpp ================================================ /// @ref core /// @file glm/common.hpp /// /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// /// @defgroup core_func_common Common functions /// @ingroup core /// /// Provides GLSL common functions /// /// These all operate component-wise. The description is per component. /// /// Include to use these core features. #pragma once #include "detail/qualifier.hpp" #include "detail/_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 GLSL abs man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR genType abs(genType x); /// Returns x if x >= 0; otherwise, it returns -x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL abs man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec abs(vec const& x); /// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL sign man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec sign(vec const& x); /// Returns a value equal to the nearest integer that is less then or equal to x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL floor man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec floor(vec 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 L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL trunc man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec trunc(vec 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 L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL round man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec round(vec 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 L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL roundEven man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// @see New round to even technique template GLM_FUNC_DECL vec roundEven(vec const& x); /// Returns a value equal to the nearest integer /// that is greater than or equal to x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL ceil man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec ceil(vec const& x); /// Return x - floor(x). /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL fract man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType fract(genType x); /// Return x - floor(x). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL fract man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec fract(vec const& x); template GLM_FUNC_DECL genType mod(genType x, genType y); template GLM_FUNC_DECL vec mod(vec const& x, T y); /// Modulus. Returns x - y * floor(x / y) /// for each component in x using the floating point value y. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types, include glm/gtc/integer for integer scalar types support /// @tparam Q Value from qualifier enum /// /// @see GLSL mod man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec mod(vec const& x, vec 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 GLSL modf man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType modf(genType x, genType& i); /// Returns y if y < x; otherwise, it returns x. /// /// @tparam genType Floating-point or integer; scalar or vector types. /// /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR genType min(genType x, genType y); /// Returns y if y < x; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec min(vec const& x, T y); /// Returns y if y < x; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec min(vec const& x, vec const& y); /// Returns y if x < y; otherwise, it returns x. /// /// @tparam genType Floating-point or integer; scalar or vector types. /// /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR genType max(genType x, genType y); /// Returns y if x < y; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec max(vec const& x, T y); /// Returns y if x < y; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec max(vec const& x, vec 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 GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal); /// Returns min(max(x, minVal), maxVal) for each component in x /// using the floating-point values minVal and maxVal. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec clamp(vec const& x, T minVal, T maxVal); /// Returns min(max(x, minVal), maxVal) for each component in x /// using the floating-point values minVal and maxVal. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec clamp(vec const& x, vec const& minVal, vec 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 GLSL mix man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// /// @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 /// ... /// 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); // Returns 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 GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a); template GLM_FUNC_DECL vec mix(vec const& x, vec const& y, vec const& a); template GLM_FUNC_DECL vec mix(vec const& x, vec const& y, U a); /// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType. /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType step(genType edge, genType x); /// Returns 0.0 if x < edge, otherwise it returns 1.0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec step(T edge, vec const& x); /// Returns 0.0 if x < edge, otherwise it returns 1.0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec step(vec const& edge, vec 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 GLSL smoothstep man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x); template GLM_FUNC_DECL vec smoothstep(T edge0, T edge1, vec const& x); template GLM_FUNC_DECL vec smoothstep(vec const& edge0, vec const& edge1, vec 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 L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL isnan man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec isnan(vec 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 L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL isinf man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec isinf(vec 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 GLSL floatBitsToInt man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions 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. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see GLSL floatBitsToInt man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec floatBitsToInt(vec 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 GLSL floatBitsToUint man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions 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. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see GLSL floatBitsToUint man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec floatBitsToUint(vec 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 GLSL intBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions 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. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see GLSL intBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec intBitsToFloat(vec 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 GLSL uintBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions 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. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see GLSL uintBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec uintBitsToFloat(vec const& v); /// Computes and returns a * b + c. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL fma man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template 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 GLSL frexp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType frexp(genType x, int& exp); template GLM_FUNC_DECL vec frexp(vec const& v, vec& 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 GLSL ldexp man page; /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType ldexp(genType const& x, int const& exp); template GLM_FUNC_DECL vec ldexp(vec const& v, vec const& exp); /// @} }//namespace glm #include "detail/func_common.inl" ================================================ FILE: android/src/glm/detail/_features.hpp ================================================ #pragma once // #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) # define GLM_CXX11_STATIC_ASSERT #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) ================================================ FILE: android/src/glm/detail/_fixes.hpp ================================================ #include //! 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: android/src/glm/detail/_noise.hpp ================================================ #pragma once #include "../common.hpp" namespace glm{ namespace detail { template GLM_FUNC_QUALIFIER T mod289(T const& x) { return x - floor(x * (static_cast(1.0) / static_cast(289.0))) * static_cast(289.0); } template GLM_FUNC_QUALIFIER T permute(T const& x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r) { return static_cast(1.79284291400159) - static_cast(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r) { return static_cast(1.79284291400159) - static_cast(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r) { return static_cast(1.79284291400159) - static_cast(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r) { return static_cast(1.79284291400159) - static_cast(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t) { return (t * t * t) * (t * (t * static_cast(6) - static_cast(15)) + static_cast(10)); } template GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t) { return (t * t * t) * (t * (t * static_cast(6) - static_cast(15)) + static_cast(10)); } template GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t) { return (t * t * t) * (t * (t * static_cast(6) - static_cast(15)) + static_cast(10)); } }//namespace detail }//namespace glm ================================================ FILE: android/src/glm/detail/_swizzle.hpp ================================================ #pragma once namespace glm{ namespace detail { // Internal class for implementing swizzle operators template struct _swizzle_base0 { protected: GLM_FUNC_QUALIFIER T& elem(size_t i){ return (reinterpret_cast(_buffer))[i]; } GLM_FUNC_QUALIFIER T const& elem(size_t i) const{ return (reinterpret_cast(_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 struct _swizzle_base1 : public _swizzle_base0 { }; template struct _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<2, T, Q> operator ()() const { return vec<2, T, Q>(this->elem(E0), this->elem(E1)); } }; template struct _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<3, T, Q> operator ()() const { return vec<3, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2)); } }; template struct _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, T, Q> operator ()() const { return vec<4, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); } }; // Internal class for implementing swizzle operators /* Template parameters: T = type of scalar values (e.g. float, double) 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 struct _swizzle_base2 : public _swizzle_base1::value> { struct op_equal { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e = t; } }; struct op_minus { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e -= t; } }; struct op_plus { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e += t; } }; struct op_mul { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e *= t; } }; struct op_div { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e /= t; } }; public: GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t) { for (int i = 0; i < N; ++i) (*this)[i] = t; return *this; } GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec const& that) { _apply_op(that, op_equal()); return *this; } GLM_FUNC_QUALIFIER void operator -= (vec const& that) { _apply_op(that, op_minus()); } GLM_FUNC_QUALIFIER void operator += (vec const& that) { _apply_op(that, op_plus()); } GLM_FUNC_QUALIFIER void operator *= (vec const& that) { _apply_op(that, op_mul()); } GLM_FUNC_QUALIFIER void operator /= (vec const& that) { _apply_op(that, op_div()); } GLM_FUNC_QUALIFIER T& operator[](size_t i) { const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } GLM_FUNC_QUALIFIER T operator[](size_t i) const { const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } protected: template GLM_FUNC_QUALIFIER void _apply_op(vec const& that, const U& 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. T 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 struct _swizzle_base2 : public _swizzle_base1::value> { struct Stub {}; GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const&) { return *this; } GLM_FUNC_QUALIFIER T operator[] (size_t i) const { const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } }; template struct _swizzle : public _swizzle_base2 { typedef _swizzle_base2 base_type; using base_type::operator=; GLM_FUNC_QUALIFIER operator vec () const { return (*this)(); } }; // // To prevent the C++ syntax from getting entirely overwhelming, define some alias macros // #define GLM_SWIZZLE_TEMPLATE1 template #define GLM_SWIZZLE_TEMPLATE2 template #define GLM_SWIZZLE_TYPE1 _swizzle #define GLM_SWIZZLE_TYPE2 _swizzle // // 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 vec operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \ { \ return a() OPERAND b(); \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER vec operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const vec& b) \ { \ return a() OPERAND b; \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER vec operator OPERAND ( const vec& 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 vec operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const T& b) \ { \ return a() OPERAND b; \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER vec 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, Q, E0,E1) \ struct { detail::_swizzle<2, T, Q, 0,0,-1,-2> E0 ## E0; }; \ struct { detail::_swizzle<2, T, Q, 0,1,-1,-2> E0 ## E1; }; \ struct { detail::_swizzle<2, T, Q, 1,0,-1,-2> E1 ## E0; }; \ struct { detail::_swizzle<2, T, Q, 1,1,-1,-2> E1 ## E1; }; #define GLM_SWIZZLE2_3_MEMBERS(T, Q, E0,E1) \ struct { detail::_swizzle<3,T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; #define GLM_SWIZZLE2_4_MEMBERS(T, Q, E0,E1) \ struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; #define GLM_SWIZZLE3_2_MEMBERS(T, Q, E0,E1,E2) \ struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; }; #define GLM_SWIZZLE3_3_MEMBERS(T, Q ,E0,E1,E2) \ struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; }; #define GLM_SWIZZLE3_4_MEMBERS(T, Q, E0,E1,E2) \ struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; #define GLM_SWIZZLE4_2_MEMBERS(T, Q, E0,E1,E2,E3) \ struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 0,3,-1,-2> E0 ## E3; }; \ struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 1,3,-1,-2> E1 ## E3; }; \ struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 2,3,-1,-2> E2 ## E3; }; \ struct { detail::_swizzle<2,T, Q, 3,0,-1,-2> E3 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 3,1,-1,-2> E3 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 3,2,-1,-2> E3 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 3,3,-1,-2> E3 ## E3; }; #define GLM_SWIZZLE4_3_MEMBERS(T, Q, E0,E1,E2,E3) \ struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,0,3,-1> E0 ## E0 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,1,3,-1> E0 ## E1 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,2,3,-1> E0 ## E2 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 0,3,0,-1> E0 ## E3 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,3,1,-1> E0 ## E3 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,3,2,-1> E0 ## E3 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,3,3,-1> E0 ## E3 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,0,3,-1> E1 ## E0 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,1,3,-1> E1 ## E1 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,2,3,-1> E1 ## E2 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 1,3,0,-1> E1 ## E3 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,3,1,-1> E1 ## E3 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,3,2,-1> E1 ## E3 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,3,3,-1> E1 ## E3 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,0,3,-1> E2 ## E0 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,1,3,-1> E2 ## E1 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,2,3,-1> E2 ## E2 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 2,3,0,-1> E2 ## E3 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,3,1,-1> E2 ## E3 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,3,2,-1> E2 ## E3 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,3,3,-1> E2 ## E3 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 3,0,0,-1> E3 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 3,0,1,-1> E3 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 3,0,2,-1> E3 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 3,0,3,-1> E3 ## E0 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 3,1,0,-1> E3 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 3,1,1,-1> E3 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 3,1,2,-1> E3 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 3,1,3,-1> E3 ## E1 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 3,2,0,-1> E3 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 3,2,1,-1> E3 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 3,2,2,-1> E3 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 3,2,3,-1> E3 ## E2 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 3,3,0,-1> E3 ## E3 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 3,3,1,-1> E3 ## E3 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 3,3,2,-1> E3 ## E3 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 3,3,3,-1> E3 ## E3 ## E3; }; #define GLM_SWIZZLE4_4_MEMBERS(T, Q, E0,E1,E2,E3) \ struct { detail::_swizzle<4, T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,3,3,3> E3 ## E3 ## E3 ## E3; }; ================================================ FILE: android/src/glm/detail/_swizzle_func.hpp ================================================ #pragma once #define GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, CONST, A, B) \ vec<2, T, Q> A ## B() CONST \ { \ return vec<2, T, Q>(this->A, this->B); \ } #define GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, CONST, A, B, C) \ vec<3, T, Q> A ## B ## C() CONST \ { \ return vec<3, T, Q>(this->A, this->B, this->C); \ } #define GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, CONST, A, B, C, D) \ vec<4, T, Q> A ## B ## C ## D() CONST \ { \ return vec<4, T, Q>(this->A, this->B, this->C, this->D); \ } #define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(T, P, L, CONST, A, B) \ template \ vec vec::A ## B() CONST \ { \ return vec<2, T, Q>(this->A, this->B); \ } #define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(T, P, L, CONST, A, B, C) \ template \ vec<3, T, Q> vec::A ## B ## C() CONST \ { \ return vec<3, T, Q>(this->A, this->B, this->C); \ } #define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(T, P, L, CONST, A, B, C, D) \ template \ vec<4, T, Q> vec::A ## B ## C ## D() CONST \ { \ return vec<4, T, Q>(this->A, this->B, this->C, this->D); \ } #define GLM_MUTABLE #define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, B, A) #define GLM_SWIZZLE_GEN_REF_FROM_VEC2(T, P) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, x, y) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, r, g) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, s, t) #define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B) #define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, B, A) #define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, A, B, C) \ GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C) #define GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P) \ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, x, y, z) \ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, r, g, b) \ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, s, t, p) #define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, C) #define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, B) #define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, C, A) #define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) #define GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P) \ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, x, y, z, w) \ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, r, g, b, a) \ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, s, t, p, q) #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, x, y) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, r, g) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, s, t) #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C) #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C) #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, x, y, z) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, r, g, b) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, s, t, p) #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, D) #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, D) #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, D) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, x, y, z, w) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, r, g, b, a) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, s, t, p, q) ================================================ FILE: android/src/glm/detail/_vectorize.hpp ================================================ #pragma once namespace glm{ namespace detail { template class vec, length_t L, typename R, typename T, qualifier Q> struct functor1{}; template class vec, typename R, typename T, qualifier Q> struct functor1 { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<1, R, Q> call(R (*Func) (T x), vec<1, T, Q> const& v) { return vec<1, R, Q>(Func(v.x)); } }; template class vec, typename R, typename T, qualifier Q> struct functor1 { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<2, R, Q> call(R (*Func) (T x), vec<2, T, Q> const& v) { return vec<2, R, Q>(Func(v.x), Func(v.y)); } }; template class vec, typename R, typename T, qualifier Q> struct functor1 { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<3, R, Q> call(R (*Func) (T x), vec<3, T, Q> const& v) { return vec<3, R, Q>(Func(v.x), Func(v.y), Func(v.z)); } }; template class vec, typename R, typename T, qualifier Q> struct functor1 { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, R, Q> call(R (*Func) (T x), vec<4, T, Q> const& v) { return vec<4, R, Q>(Func(v.x), Func(v.y), Func(v.z), Func(v.w)); } }; template class vec, length_t L, typename T, qualifier Q> struct functor2{}; template class vec, typename T, qualifier Q> struct functor2 { GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, vec<1, T, Q> const& b) { return vec<1, T, Q>(Func(a.x, b.x)); } }; template class vec, typename T, qualifier Q> struct functor2 { GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, vec<2, T, Q> const& b) { return vec<2, T, Q>(Func(a.x, b.x), Func(a.y, b.y)); } }; template class vec, typename T, qualifier Q> struct functor2 { GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, vec<3, T, Q> const& b) { return vec<3, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z)); } }; template class vec, typename T, qualifier Q> struct functor2 { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w)); } }; template class vec, length_t L, typename T, qualifier Q> struct functor2_vec_sca{}; template class vec, typename T, qualifier Q> struct functor2_vec_sca { GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, T b) { return vec<1, T, Q>(Func(a.x, b)); } }; template class vec, typename T, qualifier Q> struct functor2_vec_sca { GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, T b) { return vec<2, T, Q>(Func(a.x, b), Func(a.y, b)); } }; template class vec, typename T, qualifier Q> struct functor2_vec_sca { GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, T b) { return vec<3, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b)); } }; template class vec, typename T, qualifier Q> struct functor2_vec_sca { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, T b) { return vec<4, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b)); } }; template struct functor2_vec_int {}; template struct functor2_vec_int<1, T, Q> { GLM_FUNC_QUALIFIER static vec<1, int, Q> call(int (*Func) (T x, int y), vec<1, T, Q> const& a, vec<1, int, Q> const& b) { return vec<1, int, Q>(Func(a.x, b.x)); } }; template struct functor2_vec_int<2, T, Q> { GLM_FUNC_QUALIFIER static vec<2, int, Q> call(int (*Func) (T x, int y), vec<2, T, Q> const& a, vec<2, int, Q> const& b) { return vec<2, int, Q>(Func(a.x, b.x), Func(a.y, b.y)); } }; template struct functor2_vec_int<3, T, Q> { GLM_FUNC_QUALIFIER static vec<3, int, Q> call(int (*Func) (T x, int y), vec<3, T, Q> const& a, vec<3, int, Q> const& b) { return vec<3, int, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z)); } }; template struct functor2_vec_int<4, T, Q> { GLM_FUNC_QUALIFIER static vec<4, int, Q> call(int (*Func) (T x, int y), vec<4, T, Q> const& a, vec<4, int, Q> const& b) { return vec<4, int, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w)); } }; }//namespace detail }//namespace glm ================================================ FILE: android/src/glm/detail/compute_common.hpp ================================================ #pragma once #include "setup.hpp" #include namespace glm{ namespace detail { template struct compute_abs {}; template struct compute_abs { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x) { GLM_STATIC_ASSERT( std::numeric_limits::is_iec559 || std::numeric_limits::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; } }; #if GLM_COMPILER & GLM_COMPILER_CUDA template<> struct compute_abs { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static float call(float x) { return fabsf(x); } }; #endif template struct compute_abs { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x) { GLM_STATIC_ASSERT( (!std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'abs' only accept floating-point and integer scalar or vector inputs"); return x; } }; }//namespace detail }//namespace glm ================================================ FILE: android/src/glm/detail/compute_vector_relational.hpp ================================================ #pragma once //#include "compute_common.hpp" #include "setup.hpp" #include namespace glm{ namespace detail { template struct compute_equal { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) { return a == b; } }; /* template struct compute_equal { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) { return detail::compute_abs::is_signed>::call(b - a) <= static_cast(0); //return std::memcmp(&a, &b, sizeof(T)) == 0; } }; */ }//namespace detail }//namespace glm ================================================ FILE: android/src/glm/detail/func_common.inl ================================================ /// @ref core /// @file glm/detail/func_common.inl #include "../vector_relational.hpp" #include "compute_common.hpp" #include "type_vec1.hpp" #include "type_vec2.hpp" #include "type_vec3.hpp" #include "type_vec4.hpp" #include "_vectorize.hpp" #include namespace glm { // min template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType min(genType x, genType y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); return (y < x) ? y : x; } // max template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType max(genType x, genType y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); return (x < y) ? y : x; } // abs template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR int abs(int x) { int const y = x >> (sizeof(int) * 8 - 1); return (x ^ y) - y; } // round # if GLM_HAS_CXX11_STL using ::std::round; # else template GLM_FUNC_QUALIFIER genType round(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'round' only accept floating-point inputs"); return x < static_cast(0) ? static_cast(int(x - static_cast(0.5))) : static_cast(int(x + static_cast(0.5))); } # endif // trunc # if GLM_HAS_CXX11_STL using ::std::trunc; # else template GLM_FUNC_QUALIFIER genType trunc(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'trunc' only accept floating-point inputs"); return x < static_cast(0) ? -std::floor(-x) : std::floor(x); } # endif }//namespace glm namespace glm{ namespace detail { template struct compute_abs_vector { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec call(vec const& x) { return detail::functor1::call(abs, x); } }; template struct compute_mix_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, vec const& a) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); return vec(vec(x) * (static_cast(1) - a) + vec(y) * a); } }; template struct compute_mix_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, vec const& a) { vec Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = a[i] ? y[i] : x[i]; return Result; } }; template struct compute_mix_scalar { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, U const& a) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); return vec(vec(x) * (static_cast(1) - a) + vec(y) * a); } }; template struct compute_mix_scalar { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, bool const& a) { return a ? y : x; } }; template struct compute_mix { GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, U const& a) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); return static_cast(static_cast(x) * (static_cast(1) - a) + static_cast(y) * a); } }; template struct compute_mix { GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, bool const& a) { return a ? y : x; } }; template struct compute_sign { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return vec(glm::lessThan(vec(0), x)) - vec(glm::lessThan(x, vec(0))); } }; # if GLM_ARCH == GLM_ARCH_X86 template struct compute_sign { GLM_FUNC_QUALIFIER static vec call(vec const& x) { T const Shift(static_cast(sizeof(T) * 8 - 1)); vec const y(vec::type, Q>(-x) >> typename detail::make_unsigned::type(Shift)); return (x >> Shift) | y; } }; # endif template struct compute_floor { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(std::floor, x); } }; template struct compute_ceil { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(std::ceil, x); } }; template struct compute_fract { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return x - floor(x); } }; template struct compute_trunc { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(trunc, x); } }; template struct compute_round { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(round, x); } }; template struct compute_mod { GLM_FUNC_QUALIFIER static vec call(vec const& a, vec const& b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'mod' only accept floating-point inputs. Include for integer inputs."); return a - b * floor(a / b); } }; template struct compute_min_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y) { return detail::functor2::call(min, x, y); } }; template struct compute_max_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y) { return detail::functor2::call(max, x, y); } }; template struct compute_clamp_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& minVal, vec const& maxVal) { return min(max(x, minVal), maxVal); } }; template struct compute_step_vector { GLM_FUNC_QUALIFIER static vec call(vec const& edge, vec const& x) { return mix(vec(1), vec(0), glm::lessThan(x, edge)); } }; template struct compute_smoothstep_vector { GLM_FUNC_QUALIFIER static vec call(vec const& edge0, vec const& edge1, vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs"); vec const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast(0), static_cast(1))); return tmp * tmp * (static_cast(3) - static_cast(2) * tmp); } }; }//namespace detail template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genFIType abs(genFIType x) { return detail::compute_abs::is_signed>::call(x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec abs(vec const& x) { return detail::compute_abs_vector::value>::call(x); } // sign // fast and works for any type template GLM_FUNC_QUALIFIER genFIType sign(genFIType x) { GLM_STATIC_ASSERT( std::numeric_limits::is_iec559 || (std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'sign' only accept signed inputs"); return detail::compute_sign<1, genFIType, defaultp, std::numeric_limits::is_iec559, detail::is_aligned::value>::call(vec<1, genFIType>(x)).x; } template GLM_FUNC_QUALIFIER vec sign(vec const& x) { GLM_STATIC_ASSERT( std::numeric_limits::is_iec559 || (std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'sign' only accept signed inputs"); return detail::compute_sign::is_iec559, detail::is_aligned::value>::call(x); } // floor using ::std::floor; template GLM_FUNC_QUALIFIER vec floor(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'floor' only accept floating-point inputs."); return detail::compute_floor::value>::call(x); } template GLM_FUNC_QUALIFIER vec trunc(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'trunc' only accept floating-point inputs"); return detail::compute_trunc::value>::call(x); } template GLM_FUNC_QUALIFIER vec round(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'round' only accept floating-point inputs"); return detail::compute_round::value>::call(x); } /* // roundEven template GLM_FUNC_QUALIFIER genType roundEven(genType const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'roundEven' only accept floating-point inputs"); return genType(int(x + genType(int(x) % 2))); } */ // roundEven template GLM_FUNC_QUALIFIER genType roundEven(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'roundEven' only accept floating-point inputs"); int Integer = static_cast(x); genType IntegerPart = static_cast(Integer); genType FractionalPart = fract(x); if(FractionalPart > static_cast(0.5) || FractionalPart < static_cast(0.5)) { return round(x); } else if((Integer % 2) == 0) { return IntegerPart; } else if(x <= static_cast(0)) // Work around... { return IntegerPart - static_cast(1); } else { return IntegerPart + static_cast(1); } //else // Bug on MinGW 4.5.2 //{ // return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0)); //} } template GLM_FUNC_QUALIFIER vec roundEven(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'roundEven' only accept floating-point inputs"); return detail::functor1::call(roundEven, x); } // ceil using ::std::ceil; template GLM_FUNC_QUALIFIER vec ceil(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'ceil' only accept floating-point inputs"); return detail::compute_ceil::value>::call(x); } // fract template GLM_FUNC_QUALIFIER genType fract(genType x) { return fract(vec<1, genType>(x)).x; } template GLM_FUNC_QUALIFIER vec fract(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fract' only accept floating-point inputs"); return detail::compute_fract::value>::call(x); } // mod template GLM_FUNC_QUALIFIER genType mod(genType x, genType y) { # if GLM_COMPILER & GLM_COMPILER_CUDA // Another Cuda compiler bug https://github.com/g-truc/glm/issues/530 vec<1, genType, defaultp> Result(mod(vec<1, genType, defaultp>(x), y)); return Result.x; # else return mod(vec<1, genType, defaultp>(x), y).x; # endif } template GLM_FUNC_QUALIFIER vec mod(vec const& x, T y) { return detail::compute_mod::value>::call(x, vec(y)); } template GLM_FUNC_QUALIFIER vec mod(vec const& x, vec const& y) { return detail::compute_mod::value>::call(x, y); } // modf template GLM_FUNC_QUALIFIER genType modf(genType x, genType & i) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'modf' only accept floating-point inputs"); return std::modf(x, &i); } template GLM_FUNC_QUALIFIER vec<1, T, Q> modf(vec<1, T, Q> const& x, vec<1, T, Q> & i) { return vec<1, T, Q>( modf(x.x, i.x)); } template GLM_FUNC_QUALIFIER vec<2, T, Q> modf(vec<2, T, Q> const& x, vec<2, T, Q> & i) { return vec<2, T, Q>( modf(x.x, i.x), modf(x.y, i.y)); } template GLM_FUNC_QUALIFIER vec<3, T, Q> modf(vec<3, T, Q> const& x, vec<3, T, Q> & i) { return vec<3, T, Q>( modf(x.x, i.x), modf(x.y, i.y), modf(x.z, i.z)); } template GLM_FUNC_QUALIFIER vec<4, T, Q> modf(vec<4, T, Q> const& x, vec<4, T, Q> & i) { return vec<4, T, Q>( 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 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec min(vec const& a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); return detail::compute_min_vector::value>::call(a, vec(b)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec min(vec const& a, vec const& b) { return detail::compute_min_vector::value>::call(a, b); } // max template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec max(vec const& a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); return detail::compute_max_vector::value>::call(a, vec(b)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec max(vec const& a, vec const& b) { return detail::compute_max_vector::value>::call(a, b); } // clamp template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'clamp' only accept floating-point or integer inputs"); return min(max(x, minVal), maxVal); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec clamp(vec const& x, T minVal, T maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'clamp' only accept floating-point or integer inputs"); return detail::compute_clamp_vector::value>::call(x, vec(minVal), vec(maxVal)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec clamp(vec const& x, vec const& minVal, vec const& maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'clamp' only accept floating-point or integer inputs"); return detail::compute_clamp_vector::value>::call(x, minVal, maxVal); } template GLM_FUNC_QUALIFIER genTypeT mix(genTypeT x, genTypeT y, genTypeU a) { return detail::compute_mix::call(x, y, a); } template GLM_FUNC_QUALIFIER vec mix(vec const& x, vec const& y, U a) { return detail::compute_mix_scalar::value>::call(x, y, a); } template GLM_FUNC_QUALIFIER vec mix(vec const& x, vec const& y, vec const& a) { return detail::compute_mix_vector::value>::call(x, y, a); } // step template GLM_FUNC_QUALIFIER genType step(genType edge, genType x) { return mix(static_cast(1), static_cast(0), x < edge); } template GLM_FUNC_QUALIFIER vec step(T edge, vec const& x) { return detail::compute_step_vector::value>::call(vec(edge), x); } template GLM_FUNC_QUALIFIER vec step(vec const& edge, vec const& x) { return detail::compute_step_vector::value>::call(edge, x); } // smoothstep template GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs"); genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1))); return tmp * tmp * (genType(3) - genType(2) * tmp); } template GLM_FUNC_QUALIFIER vec smoothstep(T edge0, T edge1, vec const& x) { return detail::compute_smoothstep_vector::value>::call(vec(edge0), vec(edge1), x); } template GLM_FUNC_QUALIFIER vec smoothstep(vec const& edge0, vec const& edge1, vec const& x) { return detail::compute_smoothstep_vector::value>::call(edge0, edge1, x); } # if GLM_HAS_CXX11_STL using std::isnan; # else template GLM_FUNC_QUALIFIER bool isnan(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isnan' only accept floating-point inputs"); # if GLM_HAS_CXX11_STL return std::isnan(x); # elif GLM_COMPILER & GLM_COMPILER_VC return _isnan(x) != 0; # elif GLM_COMPILER & GLM_COMPILER_INTEL # if GLM_PLATFORM & GLM_PLATFORM_WINDOWS return _isnan(x) != 0; # else return ::isnan(x) != 0; # endif # elif (GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) && (GLM_PLATFORM & GLM_PLATFORM_ANDROID) && __cplusplus < 201103L return _isnan(x) != 0; # elif GLM_COMPILER & GLM_COMPILER_CUDA return ::isnan(x) != 0; # else return std::isnan(x); # endif } # endif template GLM_FUNC_QUALIFIER vec isnan(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isnan' only accept floating-point inputs"); vec Result; for (length_t l = 0; l < v.length(); ++l) Result[l] = glm::isnan(v[l]); return Result; } # if GLM_HAS_CXX11_STL using std::isinf; # else template GLM_FUNC_QUALIFIER bool isinf(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isinf' only accept floating-point inputs"); # if GLM_HAS_CXX11_STL return std::isinf(x); # elif GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC) # if(GLM_PLATFORM & GLM_PLATFORM_WINDOWS) return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF; # else return ::isinf(x); # endif # elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG) # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L) return _isinf(x) != 0; # else return std::isinf(x); # endif # elif GLM_COMPILER & GLM_COMPILER_CUDA // http://developer.download.nvidia.com/compute/cuda/4_2/rel/toolkit/docs/online/group__CUDA__MATH__DOUBLE_g13431dd2b40b51f9139cbb7f50c18fab.html#g13431dd2b40b51f9139cbb7f50c18fab return ::isinf(double(x)) != 0; # else return std::isinf(x); # endif } # endif template GLM_FUNC_QUALIFIER vec isinf(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isinf' only accept floating-point inputs"); vec Result; for (length_t l = 0; l < v.length(); ++l) Result[l] = glm::isinf(v[l]); return Result; } GLM_FUNC_QUALIFIER int floatBitsToInt(float const& v) { union { float in; int out; } u; u.in = v; return u.out; } template GLM_FUNC_QUALIFIER vec floatBitsToInt(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); } GLM_FUNC_QUALIFIER uint floatBitsToUint(float const& v) { union { float in; uint out; } u; u.in = v; return u.out; } template GLM_FUNC_QUALIFIER vec floatBitsToUint(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); } GLM_FUNC_QUALIFIER float intBitsToFloat(int const& v) { union { int in; float out; } u; u.in = v; return u.out; } template GLM_FUNC_QUALIFIER vec intBitsToFloat(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); } GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const& v) { union { uint in; float out; } u; u.in = v; return u.out; } template GLM_FUNC_QUALIFIER vec uintBitsToFloat(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); } # if GLM_HAS_CXX11_STL using std::fma; # else template GLM_FUNC_QUALIFIER genType fma(genType const& a, genType const& b, genType const& c) { return a * b + c; } # endif template GLM_FUNC_QUALIFIER genType frexp(genType x, int& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'frexp' only accept floating-point inputs"); return std::frexp(x, &exp); } template GLM_FUNC_QUALIFIER vec frexp(vec const& v, vec& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'frexp' only accept floating-point inputs"); vec Result; for (length_t l = 0; l < v.length(); ++l) Result[l] = std::frexp(v[l], &exp[l]); return Result; } template GLM_FUNC_QUALIFIER genType ldexp(genType const& x, int const& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'ldexp' only accept floating-point inputs"); return std::ldexp(x, exp); } template GLM_FUNC_QUALIFIER vec ldexp(vec const& v, vec const& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'ldexp' only accept floating-point inputs"); vec Result; for (length_t l = 0; l < v.length(); ++l) Result[l] = std::ldexp(v[l], exp[l]); return Result; } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "func_common_simd.inl" #endif ================================================ FILE: android/src/glm/detail/func_common_simd.inl ================================================ /// @ref core /// @file glm/detail/func_common_simd.inl #if GLM_ARCH & GLM_ARCH_SSE2_BIT #include "../simd/common.h" #include namespace glm{ namespace detail { template struct compute_abs_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_abs(v.data); return result; } }; template struct compute_abs_vector<4, int, Q, true> { GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v) { vec<4, int, Q> result; result.data = glm_ivec4_abs(v.data); return result; } }; template struct compute_floor<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_floor(v.data); return result; } }; template struct compute_ceil<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_ceil(v.data); return result; } }; template struct compute_fract<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_fract(v.data); return result; } }; template struct compute_round<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_round(v.data); return result; } }; template struct compute_mod<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y) { vec<4, float, Q> result; result.data = glm_vec4_mod(x.data, y.data); return result; } }; template struct compute_min_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { vec<4, float, Q> result; result.data = _mm_min_ps(v1.data, v2.data); return result; } }; template struct compute_min_vector<4, int, Q, true> { GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2) { vec<4, int, Q> result; result.data = _mm_min_epi32(v1.data, v2.data); return result; } }; template struct compute_min_vector<4, uint, Q, true> { GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2) { vec<4, uint, Q> result; result.data = _mm_min_epu32(v1.data, v2.data); return result; } }; template struct compute_max_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { vec<4, float, Q> result; result.data = _mm_max_ps(v1.data, v2.data); return result; } }; template struct compute_max_vector<4, int, Q, true> { GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2) { vec<4, int, Q> result; result.data = _mm_max_epi32(v1.data, v2.data); return result; } }; template struct compute_max_vector<4, uint, Q, true> { GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2) { vec<4, uint, Q> result; result.data = _mm_max_epu32(v1.data, v2.data); return result; } }; template struct compute_clamp_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& minVal, vec<4, float, Q> const& maxVal) { vec<4, float, Q> result; result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data); return result; } }; template struct compute_clamp_vector<4, int, Q, true> { GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& x, vec<4, int, Q> const& minVal, vec<4, int, Q> const& maxVal) { vec<4, int, Q> result; result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data); return result; } }; template struct compute_clamp_vector<4, uint, Q, true> { GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& x, vec<4, uint, Q> const& minVal, vec<4, uint, Q> const& maxVal) { vec<4, uint, Q> result; result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data); return result; } }; template struct compute_mix_vector<4, float, bool, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y, vec<4, bool, Q> const& a) { __m128i const Load = _mm_set_epi32(-static_cast(a.w), -static_cast(a.z), -static_cast(a.y), -static_cast(a.x)); __m128 const Mask = _mm_castsi128_ps(Load); vec<4, float, Q> Result; # if 0 && GLM_ARCH & GLM_ARCH_AVX Result.data = _mm_blendv_ps(x.data, y.data, Mask); # else Result.data = _mm_or_ps(_mm_and_ps(Mask, y.data), _mm_andnot_ps(Mask, x.data)); # endif return Result; } }; /* FIXME template struct compute_step_vector { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge, vec<4, float, Q> const& x) { vec<4, float, Q> Result; result.data = glm_vec4_step(edge.data, x.data); return result; } }; */ template struct compute_smoothstep_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge0, vec<4, float, Q> const& edge1, vec<4, float, Q> const& x) { vec<4, float, Q> Result; Result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data); return Result; } }; }//namespace detail }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/detail/func_exponential.inl ================================================ /// @ref core /// @file glm/detail/func_exponential.inl #include "../vector_relational.hpp" #include "_vectorize.hpp" #include #include #include namespace glm{ namespace detail { # if GLM_HAS_CXX11_STL using std::log2; # else template genType log2(genType Value) { return std::log(Value) * static_cast(1.4426950408889634073599246810019); } # endif template struct compute_log2 { GLM_FUNC_QUALIFIER static vec call(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'log2' only accept floating-point inputs. Include for integer inputs."); return detail::functor1::call(log2, v); } }; template struct compute_sqrt { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(std::sqrt, x); } }; template struct compute_inversesqrt { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return static_cast(1) / sqrt(x); } }; template struct compute_inversesqrt { GLM_FUNC_QUALIFIER static vec call(vec const& x) { vec tmp(x); vec xhalf(tmp * 0.5f); vec* p = reinterpret_cast*>(const_cast*>(&x)); vec i = vec(0x5f375a86) - (*p >> vec(1)); vec* ptmp = reinterpret_cast*>(&i); tmp = *ptmp; tmp = tmp * (1.5f - xhalf * tmp * tmp); return tmp; } }; }//namespace detail // pow using std::pow; template GLM_FUNC_QUALIFIER vec pow(vec const& base, vec const& exponent) { return detail::functor2::call(pow, base, exponent); } // exp using std::exp; template GLM_FUNC_QUALIFIER vec exp(vec const& x) { return detail::functor1::call(exp, x); } // log using std::log; template GLM_FUNC_QUALIFIER vec log(vec const& x) { return detail::functor1::call(log, x); } # if GLM_HAS_CXX11_STL using std::exp2; # else //exp2, ln2 = 0.69314718055994530941723212145818f template GLM_FUNC_QUALIFIER genType exp2(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'exp2' only accept floating-point inputs"); return std::exp(static_cast(0.69314718055994530941723212145818) * x); } # endif template GLM_FUNC_QUALIFIER vec exp2(vec const& x) { return detail::functor1::call(exp2, x); } // log2, ln2 = 0.69314718055994530941723212145818f template GLM_FUNC_QUALIFIER genType log2(genType x) { return log2(vec<1, genType>(x)).x; } template GLM_FUNC_QUALIFIER vec log2(vec const& x) { return detail::compute_log2::is_iec559, detail::is_aligned::value>::call(x); } // sqrt using std::sqrt; template GLM_FUNC_QUALIFIER vec sqrt(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sqrt' only accept floating-point inputs"); return detail::compute_sqrt::value>::call(x); } // inversesqrt template GLM_FUNC_QUALIFIER genType inversesqrt(genType x) { return static_cast(1) / sqrt(x); } template GLM_FUNC_QUALIFIER vec inversesqrt(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'inversesqrt' only accept floating-point inputs"); return detail::compute_inversesqrt::value>::call(x); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "func_exponential_simd.inl" #endif ================================================ FILE: android/src/glm/detail/func_exponential_simd.inl ================================================ /// @ref core /// @file glm/detail/func_exponential_simd.inl #include "../simd/exponential.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { template struct compute_sqrt<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> Result; Result.data = _mm_sqrt_ps(v.data); return Result; } }; # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE template<> struct compute_sqrt<4, float, aligned_lowp, true> { GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v) { vec<4, float, aligned_lowp> Result; Result.data = glm_vec4_sqrt_lowp(v.data); return Result; } }; # endif }//namespace detail }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/detail/func_geometric.inl ================================================ #include "../exponential.hpp" #include "../common.hpp" namespace glm{ namespace detail { template struct compute_length { GLM_FUNC_QUALIFIER static T call(vec const& v) { return sqrt(dot(v, v)); } }; template struct compute_distance { GLM_FUNC_QUALIFIER static T call(vec const& p0, vec const& p1) { return length(p1 - p0); } }; template struct compute_dot{}; template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<1, T, Q> const& a, vec<1, T, Q> const& b) { return a.x * b.x; } }; template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& a, vec<2, T, Q> const& b) { vec<2, T, Q> tmp(a * b); return tmp.x + tmp.y; } }; template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<3, T, Q> const& a, vec<3, T, Q> const& b) { vec<3, T, Q> tmp(a * b); return tmp.x + tmp.y + tmp.z; } }; template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> tmp(a * b); return (tmp.x + tmp.y) + (tmp.z + tmp.w); } }; template struct compute_cross { GLM_FUNC_QUALIFIER static vec<3, T, Q> call(vec<3, T, Q> const& x, vec<3, T, Q> const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); return vec<3, T, Q>( x.y * y.z - y.y * x.z, x.z * y.x - y.z * x.x, x.x * y.y - y.x * x.y); } }; template struct compute_normalize { GLM_FUNC_QUALIFIER static vec call(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return v * inversesqrt(dot(v, v)); } }; template struct compute_faceforward { GLM_FUNC_QUALIFIER static vec call(vec const& N, vec const& I, vec const& Nref) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return dot(Nref, I) < static_cast(0) ? N : -N; } }; template struct compute_reflect { GLM_FUNC_QUALIFIER static vec call(vec const& I, vec const& N) { return I - N * dot(N, I) * static_cast(2); } }; template struct compute_refract { GLM_FUNC_QUALIFIER static vec call(vec const& I, vec const& N, T eta) { T const dotValue(dot(N, I)); T const k(static_cast(1) - eta * eta * (static_cast(1) - dotValue * dotValue)); vec const Result = (k >= static_cast(0)) ? (eta * I - (eta * dotValue + std::sqrt(k)) * N) : vec(0); return Result; } }; }//namespace detail // length template GLM_FUNC_QUALIFIER genType length(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length' accepts only floating-point inputs"); return abs(x); } template GLM_FUNC_QUALIFIER T length(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length' accepts only floating-point inputs"); return detail::compute_length::value>::call(v); } // distance template GLM_FUNC_QUALIFIER genType distance(genType const& p0, genType const& p1) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance' accepts only floating-point inputs"); return length(p1 - p0); } template GLM_FUNC_QUALIFIER T distance(vec const& p0, vec const& p1) { return detail::compute_distance::value>::call(p0, p1); } // dot template GLM_FUNC_QUALIFIER T dot(T x, T y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); return x * y; } template GLM_FUNC_QUALIFIER T dot(vec const& x, vec const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); } // cross template GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y) { return detail::compute_cross::value>::call(x, y); } /* // normalize template GLM_FUNC_QUALIFIER genType normalize(genType const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return x < genType(0) ? genType(-1) : genType(1); } */ template GLM_FUNC_QUALIFIER vec normalize(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return detail::compute_normalize::value>::call(x); } // faceforward template GLM_FUNC_QUALIFIER genType faceforward(genType const& N, genType const& I, genType const& Nref) { return dot(Nref, I) < static_cast(0) ? N : -N; } template GLM_FUNC_QUALIFIER vec faceforward(vec const& N, vec const& I, vec const& Nref) { return detail::compute_faceforward::value>::call(N, I, Nref); } // reflect template GLM_FUNC_QUALIFIER genType reflect(genType const& I, genType const& N) { return I - N * dot(N, I) * genType(2); } template GLM_FUNC_QUALIFIER vec reflect(vec const& I, vec const& N) { return detail::compute_reflect::value>::call(I, N); } // refract template GLM_FUNC_QUALIFIER genType refract(genType const& I, genType const& N, genType eta) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'refract' accepts only floating-point inputs"); genType const dotValue(dot(N, I)); genType const k(static_cast(1) - eta * eta * (static_cast(1) - dotValue * dotValue)); return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast(k >= static_cast(0)); } template GLM_FUNC_QUALIFIER vec refract(vec const& I, vec const& N, T eta) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'refract' accepts only floating-point inputs"); return detail::compute_refract::value>::call(I, N, eta); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "func_geometric_simd.inl" #endif ================================================ FILE: android/src/glm/detail/func_geometric_simd.inl ================================================ /// @ref core /// @file glm/detail/func_geometric_simd.inl #include "../simd/geometric.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { template struct compute_length<4, float, Q, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v) { return _mm_cvtss_f32(glm_vec4_length(v.data)); } }; template struct compute_distance<4, float, Q, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1) { return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data)); } }; template struct compute_dot, float, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y) { return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); } }; template struct compute_cross { GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<3, float, Q> const& a, vec<3, float, Q> const& b) { __m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x); __m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x); __m128 const xpd0 = glm_vec4_cross(set0, set1); vec<4, float, Q> Result; Result.data = xpd0; return vec<3, float, Q>(Result); } }; template struct compute_normalize<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> Result; Result.data = glm_vec4_normalize(v.data); return Result; } }; template struct compute_faceforward<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& N, vec<4, float, Q> const& I, vec<4, float, Q> const& Nref) { vec<4, float, Q> Result; Result.data = glm_vec4_faceforward(N.data, I.data, Nref.data); return Result; } }; template struct compute_reflect<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N) { vec<4, float, Q> Result; Result.data = glm_vec4_reflect(I.data, N.data); return Result; } }; template struct compute_refract<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N, float eta) { vec<4, float, Q> Result; Result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta)); return Result; } }; }//namespace detail }//namespace glm #elif GLM_ARCH & GLM_ARCH_NEON_BIT namespace glm{ namespace detail { template struct compute_length<4, float, Q, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v) { return sqrt(compute_dot, float, true>::call(v, v)); } }; template struct compute_distance<4, float, Q, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1) { return compute_length<4, float, Q, true>::call(p1 - p0); } }; template struct compute_dot, float, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y) { #if GLM_ARCH & GLM_ARCH_ARMV8_BIT float32x4_t v = vmulq_f32(x.data, y.data); return vaddvq_f32(v); #else // Armv7a with Neon float32x4_t p = vmulq_f32(x.data, y.data); float32x2_t v = vpadd_f32(vget_low_f32(p), vget_high_f32(p)); v = vpadd_f32(v, v); return vget_lane_f32(v, 0); #endif } }; template struct compute_normalize<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { float32x4_t p = vmulq_f32(v.data, v.data); #if GLM_ARCH & GLM_ARCH_ARMV8_BIT p = vpaddq_f32(p, p); p = vpaddq_f32(p, p); #else float32x2_t t = vpadd_f32(vget_low_f32(p), vget_high_f32(p)); t = vpadd_f32(t, t); p = vcombine_f32(t, t); #endif float32x4_t vd = vrsqrteq_f32(p); vec<4, float, Q> Result; Result.data = vmulq_f32(v.data, vd); return Result; } }; }//namespace detail }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/detail/func_integer.inl ================================================ /// @ref core #include "_vectorize.hpp" #if(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC) # include # pragma intrinsic(_BitScanReverse) #endif//(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC) #include #if !GLM_HAS_EXTENDED_INTEGER_TYPE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic ignored "-Wlong-long" # endif # if (GLM_COMPILER & GLM_COMPILER_CLANG) # pragma clang diagnostic ignored "-Wc++11-long-long" # endif #endif namespace glm{ namespace detail { template GLM_FUNC_QUALIFIER T mask(T Bits) { return Bits >= static_cast(sizeof(T) * 8) ? ~static_cast(0) : (static_cast(1) << Bits) - static_cast(1); } template struct compute_bitfieldReverseStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T, T) { return v; } }; template struct compute_bitfieldReverseStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T Mask, T Shift) { return (v & Mask) << Shift | (v & (~Mask)) >> Shift; } }; template struct compute_bitfieldBitCountStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T, T) { return v; } }; template struct compute_bitfieldBitCountStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T Mask, T Shift) { return (v & Mask) + ((v >> Shift) & Mask); } }; template struct compute_findLSB { GLM_FUNC_QUALIFIER static int call(genIUType Value) { if(Value == 0) return -1; return glm::bitCount(~Value & (Value - static_cast(1))); } }; # if GLM_HAS_BITSCAN_WINDOWS template struct compute_findLSB { GLM_FUNC_QUALIFIER static int call(genIUType Value) { unsigned long Result(0); unsigned char IsNotNull = _BitScanForward(&Result, *reinterpret_cast(&Value)); return IsNotNull ? int(Result) : -1; } }; # if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32)) template struct compute_findLSB { GLM_FUNC_QUALIFIER static int call(genIUType Value) { unsigned long Result(0); unsigned char IsNotNull = _BitScanForward64(&Result, *reinterpret_cast(&Value)); return IsNotNull ? int(Result) : -1; } }; # endif # endif//GLM_HAS_BITSCAN_WINDOWS template struct compute_findMSB_step_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x, T Shift) { return x | (x >> Shift); } }; template struct compute_findMSB_step_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x, T) { return x; } }; template struct compute_findMSB_vec { GLM_FUNC_QUALIFIER static vec call(vec const& v) { vec x(v); x = compute_findMSB_step_vec= 8>::call(x, static_cast( 1)); x = compute_findMSB_step_vec= 8>::call(x, static_cast( 2)); x = compute_findMSB_step_vec= 8>::call(x, static_cast( 4)); x = compute_findMSB_step_vec= 16>::call(x, static_cast( 8)); x = compute_findMSB_step_vec= 32>::call(x, static_cast(16)); x = compute_findMSB_step_vec= 64>::call(x, static_cast(32)); return vec(sizeof(T) * 8 - 1) - glm::bitCount(~x); } }; # if GLM_HAS_BITSCAN_WINDOWS template GLM_FUNC_QUALIFIER int compute_findMSB_32(genIUType Value) { unsigned long Result(0); unsigned char IsNotNull = _BitScanReverse(&Result, *reinterpret_cast(&Value)); return IsNotNull ? int(Result) : -1; } template struct compute_findMSB_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(compute_findMSB_32, x); } }; # if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32)) template GLM_FUNC_QUALIFIER int compute_findMSB_64(genIUType Value) { unsigned long Result(0); unsigned char IsNotNull = _BitScanReverse64(&Result, *reinterpret_cast(&Value)); return IsNotNull ? int(Result) : -1; } template struct compute_findMSB_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(compute_findMSB_64, x); } }; # endif # endif//GLM_HAS_BITSCAN_WINDOWS }//namespace detail // uaddCarry GLM_FUNC_QUALIFIER uint uaddCarry(uint const& x, uint const& y, uint & Carry) { detail::uint64 const Value64(static_cast(x) + static_cast(y)); detail::uint64 const Max32((static_cast(1) << static_cast(32)) - static_cast(1)); Carry = Value64 > Max32 ? 1u : 0u; return static_cast(Value64 % (Max32 + static_cast(1))); } template GLM_FUNC_QUALIFIER vec uaddCarry(vec const& x, vec const& y, vec& Carry) { vec Value64(vec(x) + vec(y)); vec Max32((static_cast(1) << static_cast(32)) - static_cast(1)); Carry = mix(vec(0), vec(1), greaterThan(Value64, Max32)); return vec(Value64 % (Max32 + static_cast(1))); } // usubBorrow GLM_FUNC_QUALIFIER uint usubBorrow(uint const& x, uint const& y, uint & Borrow) { Borrow = x >= y ? static_cast(0) : static_cast(1); if(y >= x) return y - x; else return static_cast((static_cast(1) << static_cast(32)) + (static_cast(y) - static_cast(x))); } template GLM_FUNC_QUALIFIER vec usubBorrow(vec const& x, vec const& y, vec& Borrow) { Borrow = mix(vec(1), vec(0), greaterThanEqual(x, y)); vec const YgeX(y - x); vec const XgeY(vec((static_cast(1) << static_cast(32)) + (vec(y) - vec(x)))); return mix(XgeY, YgeX, greaterThanEqual(y, x)); } // umulExtended GLM_FUNC_QUALIFIER void umulExtended(uint const& x, uint const& y, uint & msb, uint & lsb) { detail::uint64 Value64 = static_cast(x) * static_cast(y); msb = static_cast(Value64 >> static_cast(32)); lsb = static_cast(Value64); } template GLM_FUNC_QUALIFIER void umulExtended(vec const& x, vec const& y, vec& msb, vec& lsb) { vec Value64(vec(x) * vec(y)); msb = vec(Value64 >> static_cast(32)); lsb = vec(Value64); } // imulExtended GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int& msb, int& lsb) { detail::int64 Value64 = static_cast(x) * static_cast(y); msb = static_cast(Value64 >> static_cast(32)); lsb = static_cast(Value64); } template GLM_FUNC_QUALIFIER void imulExtended(vec const& x, vec const& y, vec& msb, vec& lsb) { vec Value64(vec(x) * vec(y)); lsb = vec(Value64 & static_cast(0xFFFFFFFF)); msb = vec((Value64 >> static_cast(32)) & static_cast(0xFFFFFFFF)); } // bitfieldExtract template GLM_FUNC_QUALIFIER genIUType bitfieldExtract(genIUType Value, int Offset, int Bits) { return bitfieldExtract(vec<1, genIUType>(Value), Offset, Bits).x; } template GLM_FUNC_QUALIFIER vec bitfieldExtract(vec const& Value, int Offset, int Bits) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldExtract' only accept integer inputs"); return (Value >> static_cast(Offset)) & static_cast(detail::mask(Bits)); } // bitfieldInsert template GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const& Base, genIUType const& Insert, int Offset, int Bits) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldInsert' only accept integer values"); return bitfieldInsert(vec<1, genIUType>(Base), vec<1, genIUType>(Insert), Offset, Bits).x; } template GLM_FUNC_QUALIFIER vec bitfieldInsert(vec const& Base, vec const& Insert, int Offset, int Bits) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldInsert' only accept integer values"); T const Mask = static_cast(detail::mask(Bits) << Offset); return (Base & ~Mask) | ((Insert << static_cast(Offset)) & Mask); } // bitfieldReverse template GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); return bitfieldReverse(glm::vec<1, genIUType, glm::defaultp>(x)).x; } template GLM_FUNC_QUALIFIER vec bitfieldReverse(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); vec x(v); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 2>::call(x, static_cast(0x5555555555555555ull), static_cast( 1)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 4>::call(x, static_cast(0x3333333333333333ull), static_cast( 2)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 8>::call(x, static_cast(0x0F0F0F0F0F0F0F0Full), static_cast( 4)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 16>::call(x, static_cast(0x00FF00FF00FF00FFull), static_cast( 8)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 32>::call(x, static_cast(0x0000FFFF0000FFFFull), static_cast(16)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 64>::call(x, static_cast(0x00000000FFFFFFFFull), static_cast(32)); return x; } // bitCount template GLM_FUNC_QUALIFIER int bitCount(genIUType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); return bitCount(glm::vec<1, genIUType, glm::defaultp>(x)).x; } template GLM_FUNC_QUALIFIER vec bitCount(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable : 4310) //cast truncates constant value # endif vec::type, Q> x(*reinterpret_cast::type, Q> const *>(&v)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 2>::call(x, typename detail::make_unsigned::type(0x5555555555555555ull), typename detail::make_unsigned::type( 1)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 4>::call(x, typename detail::make_unsigned::type(0x3333333333333333ull), typename detail::make_unsigned::type( 2)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 8>::call(x, typename detail::make_unsigned::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned::type( 4)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 16>::call(x, typename detail::make_unsigned::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned::type( 8)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 32>::call(x, typename detail::make_unsigned::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned::type(16)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 64>::call(x, typename detail::make_unsigned::type(0x00000000FFFFFFFFull), typename detail::make_unsigned::type(32)); return vec(x); # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif } // findLSB template GLM_FUNC_QUALIFIER int findLSB(genIUType Value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); return detail::compute_findLSB::call(Value); } template GLM_FUNC_QUALIFIER vec findLSB(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); return detail::functor1::call(findLSB, x); } // findMSB template GLM_FUNC_QUALIFIER int findMSB(genIUType v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); return findMSB(vec<1, genIUType>(v)).x; } template GLM_FUNC_QUALIFIER vec findMSB(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); return detail::compute_findMSB_vec::call(v); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "func_integer_simd.inl" #endif ================================================ FILE: android/src/glm/detail/func_integer_simd.inl ================================================ #include "../simd/integer.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { template struct compute_bitfieldReverseStep<4, uint, Q, true, true> { GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v, uint Mask, uint Shift) { __m128i const set0 = v.data; __m128i const set1 = _mm_set1_epi32(static_cast(Mask)); __m128i const and1 = _mm_and_si128(set0, set1); __m128i const sft1 = _mm_slli_epi32(and1, Shift); __m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1)); __m128i const and2 = _mm_and_si128(set0, set2); __m128i const sft2 = _mm_srai_epi32(and2, Shift); __m128i const or0 = _mm_or_si128(sft1, sft2); return or0; } }; template struct compute_bitfieldBitCountStep<4, uint, Q, true, true> { GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v, uint Mask, uint Shift) { __m128i const set0 = v.data; __m128i const set1 = _mm_set1_epi32(static_cast(Mask)); __m128i const and0 = _mm_and_si128(set0, set1); __m128i const sft0 = _mm_slli_epi32(set0, Shift); __m128i const and1 = _mm_and_si128(sft0, set1); __m128i const add0 = _mm_add_epi32(and0, and1); return add0; } }; }//namespace detail # if GLM_ARCH & GLM_ARCH_AVX_BIT template<> GLM_FUNC_QUALIFIER int bitCount(uint x) { return _mm_popcnt_u32(x); } # if(GLM_MODEL == GLM_MODEL_64) template<> GLM_FUNC_QUALIFIER int bitCount(detail::uint64 x) { return static_cast(_mm_popcnt_u64(x)); } # endif//GLM_MODEL # endif//GLM_ARCH }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/detail/func_matrix.inl ================================================ #include "../geometric.hpp" #include namespace glm{ namespace detail { template struct compute_matrixCompMult { GLM_FUNC_QUALIFIER static mat call(mat const& x, mat const& y) { mat Result; for(length_t i = 0; i < Result.length(); ++i) Result[i] = x[i] * y[i]; return Result; } }; template struct compute_transpose{}; template struct compute_transpose<2, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m) { mat<2, 2, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; return Result; } }; template struct compute_transpose<2, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<3, 2, T, Q> call(mat<2, 3, T, Q> const& m) { mat<3,2, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; return Result; } }; template struct compute_transpose<2, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<4, 2, T, Q> call(mat<2, 4, T, Q> const& m) { mat<4, 2, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[3][0] = m[0][3]; Result[3][1] = m[1][3]; return Result; } }; template struct compute_transpose<3, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<2, 3, T, Q> call(mat<3, 2, T, Q> const& m) { mat<2, 3, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; return Result; } }; template struct compute_transpose<3, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m) { mat<3, 3, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; return Result; } }; template struct compute_transpose<3, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<4, 3, T, Q> call(mat<3, 4, T, Q> const& m) { mat<4, 3, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; Result[3][0] = m[0][3]; Result[3][1] = m[1][3]; Result[3][2] = m[2][3]; return Result; } }; template struct compute_transpose<4, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<2, 4, T, Q> call(mat<4, 2, T, Q> const& m) { mat<2, 4, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[0][3] = m[3][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[1][3] = m[3][1]; return Result; } }; template struct compute_transpose<4, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<3, 4, T, Q> call(mat<4, 3, T, Q> const& m) { mat<3, 4, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[0][3] = m[3][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[1][3] = m[3][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; Result[2][3] = m[3][2]; return Result; } }; template struct compute_transpose<4, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m) { mat<4, 4, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[0][3] = m[3][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[1][3] = m[3][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; Result[2][3] = m[3][2]; Result[3][0] = m[0][3]; Result[3][1] = m[1][3]; Result[3][2] = m[2][3]; Result[3][3] = m[3][3]; return Result; } }; template struct compute_determinant{}; template struct compute_determinant<2, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static T call(mat<2, 2, T, Q> const& m) { return m[0][0] * m[1][1] - m[1][0] * m[0][1]; } }; template struct compute_determinant<3, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static T call(mat<3, 3, T, Q> const& m) { return + m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2]) - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2]) + m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]); } }; template struct compute_determinant<4, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static T call(mat<4, 4, T, Q> const& m) { T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; vec<4, T, Q> DetCof( + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02), - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04), + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05), - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05)); return m[0][0] * DetCof[0] + m[0][1] * DetCof[1] + m[0][2] * DetCof[2] + m[0][3] * DetCof[3]; } }; template struct compute_inverse{}; template struct compute_inverse<2, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m) { T OneOverDeterminant = static_cast(1) / ( + m[0][0] * m[1][1] - m[1][0] * m[0][1]); mat<2, 2, T, Q> Inverse( + m[1][1] * OneOverDeterminant, - m[0][1] * OneOverDeterminant, - m[1][0] * OneOverDeterminant, + m[0][0] * OneOverDeterminant); return Inverse; } }; template struct compute_inverse<3, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m) { T OneOverDeterminant = static_cast(1) / ( + m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2]) - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2]) + m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2])); mat<3, 3, T, Q> Inverse; Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant; Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant; Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant; Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant; Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant; Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant; Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant; Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant; Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant; return Inverse; } }; template struct compute_inverse<4, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m) { T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; vec<4, T, Q> Fac0(Coef00, Coef00, Coef02, Coef03); vec<4, T, Q> Fac1(Coef04, Coef04, Coef06, Coef07); vec<4, T, Q> Fac2(Coef08, Coef08, Coef10, Coef11); vec<4, T, Q> Fac3(Coef12, Coef12, Coef14, Coef15); vec<4, T, Q> Fac4(Coef16, Coef16, Coef18, Coef19); vec<4, T, Q> Fac5(Coef20, Coef20, Coef22, Coef23); vec<4, T, Q> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]); vec<4, T, Q> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]); vec<4, T, Q> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]); vec<4, T, Q> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]); vec<4, T, Q> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2); vec<4, T, Q> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4); vec<4, T, Q> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5); vec<4, T, Q> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5); vec<4, T, Q> SignA(+1, -1, +1, -1); vec<4, T, Q> SignB(-1, +1, -1, +1); mat<4, 4, T, Q> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB); vec<4, T, Q> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]); vec<4, T, Q> Dot0(m[0] * Row0); T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w); T OneOverDeterminant = static_cast(1) / Dot1; return Inverse * OneOverDeterminant; } }; }//namespace detail template GLM_FUNC_QUALIFIER mat matrixCompMult(mat const& x, mat const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs"); return detail::compute_matrixCompMult::value>::call(x, y); } template GLM_FUNC_QUALIFIER typename detail::outerProduct_trait::type outerProduct(vec const& c, vec const& r) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs"); typename detail::outerProduct_trait::type m; for(length_t i = 0; i < m.length(); ++i) m[i] = c * r[i]; return m; } template GLM_FUNC_QUALIFIER typename mat::transpose_type transpose(mat const& m) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs"); return detail::compute_transpose::value>::call(m); } template GLM_FUNC_QUALIFIER T determinant(mat const& m) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs"); return detail::compute_determinant::value>::call(m); } template GLM_FUNC_QUALIFIER mat inverse(mat const& m) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs"); return detail::compute_inverse::value>::call(m); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "func_matrix_simd.inl" #endif ================================================ FILE: android/src/glm/detail/func_matrix_simd.inl ================================================ #if GLM_ARCH & GLM_ARCH_SSE2_BIT #include "type_mat4x4.hpp" #include "../geometric.hpp" #include "../simd/matrix.h" #include namespace glm{ namespace detail { # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE template struct compute_matrixCompMult<4, 4, float, Q, true> { GLM_STATIC_ASSERT(detail::is_aligned::value, "Specialization requires aligned"); GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& x, mat<4, 4, float, Q> const& y) { mat<4, 4, float, Q> Result; glm_mat4_matrixCompMult( *static_cast(&x[0].data), *static_cast(&y[0].data), *static_cast(&Result[0].data)); return Result; } }; # endif template struct compute_transpose<4, 4, float, Q, true> { GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m) { mat<4, 4, float, Q> Result; glm_mat4_transpose(&m[0].data, &Result[0].data); return Result; } }; template struct compute_determinant<4, 4, float, Q, true> { GLM_FUNC_QUALIFIER static float call(mat<4, 4, float, Q> const& m) { return _mm_cvtss_f32(glm_mat4_determinant(&m[0].data)); } }; template struct compute_inverse<4, 4, float, Q, true> { GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m) { mat<4, 4, float, Q> Result; glm_mat4_inverse(&m[0].data, &Result[0].data); return Result; } }; }//namespace detail # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE template<> GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_lowp> outerProduct<4, 4, float, aligned_lowp>(vec<4, float, aligned_lowp> const& c, vec<4, float, aligned_lowp> const& r) { __m128 NativeResult[4]; glm_mat4_outerProduct(c.data, r.data, NativeResult); mat<4, 4, float, aligned_lowp> Result; std::memcpy(&Result[0], &NativeResult[0], sizeof(Result)); return Result; } template<> GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_mediump> outerProduct<4, 4, float, aligned_mediump>(vec<4, float, aligned_mediump> const& c, vec<4, float, aligned_mediump> const& r) { __m128 NativeResult[4]; glm_mat4_outerProduct(c.data, r.data, NativeResult); mat<4, 4, float, aligned_mediump> Result; std::memcpy(&Result[0], &NativeResult[0], sizeof(Result)); return Result; } template<> GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_highp> outerProduct<4, 4, float, aligned_highp>(vec<4, float, aligned_highp> const& c, vec<4, float, aligned_highp> const& r) { __m128 NativeResult[4]; glm_mat4_outerProduct(c.data, r.data, NativeResult); mat<4, 4, float, aligned_highp> Result; std::memcpy(&Result[0], &NativeResult[0], sizeof(Result)); return Result; } # endif }//namespace glm #elif GLM_ARCH & GLM_ARCH_NEON_BIT namespace glm { #if GLM_LANG & GLM_LANG_CXX11_FLAG template GLM_FUNC_QUALIFIER typename std::enable_if::value, mat<4, 4, float, Q>>::type operator*(mat<4, 4, float, Q> const & m1, mat<4, 4, float, Q> const & m2) { auto MulRow = [&](int l) { float32x4_t const SrcA = m2[l].data; float32x4_t r = neon::mul_lane(m1[0].data, SrcA, 0); r = neon::madd_lane(r, m1[1].data, SrcA, 1); r = neon::madd_lane(r, m1[2].data, SrcA, 2); r = neon::madd_lane(r, m1[3].data, SrcA, 3); return r; }; mat<4, 4, float, aligned_highp> Result; Result[0].data = MulRow(0); Result[1].data = MulRow(1); Result[2].data = MulRow(2); Result[3].data = MulRow(3); return Result; } #endif // CXX11 template struct detail::compute_inverse<4, 4, float, Q, true> { GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m) { float32x4_t const& m0 = m[0].data; float32x4_t const& m1 = m[1].data; float32x4_t const& m2 = m[2].data; float32x4_t const& m3 = m[3].data; // m[2][2] * m[3][3] - m[3][2] * m[2][3]; // m[2][2] * m[3][3] - m[3][2] * m[2][3]; // m[1][2] * m[3][3] - m[3][2] * m[1][3]; // m[1][2] * m[2][3] - m[2][2] * m[1][3]; float32x4_t Fac0; { float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 2), neon::dup_lane(m1, 2)); float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 3), 3, m2, 3); float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 2), 3, m2, 2); float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 3), neon::dup_lane(m1, 3)); Fac0 = w0 * w1 - w2 * w3; } // m[2][1] * m[3][3] - m[3][1] * m[2][3]; // m[2][1] * m[3][3] - m[3][1] * m[2][3]; // m[1][1] * m[3][3] - m[3][1] * m[1][3]; // m[1][1] * m[2][3] - m[2][1] * m[1][3]; float32x4_t Fac1; { float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 1), neon::dup_lane(m1, 1)); float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 3), 3, m2, 3); float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 1), 3, m2, 1); float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 3), neon::dup_lane(m1, 3)); Fac1 = w0 * w1 - w2 * w3; } // m[2][1] * m[3][2] - m[3][1] * m[2][2]; // m[2][1] * m[3][2] - m[3][1] * m[2][2]; // m[1][1] * m[3][2] - m[3][1] * m[1][2]; // m[1][1] * m[2][2] - m[2][1] * m[1][2]; float32x4_t Fac2; { float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 1), neon::dup_lane(m1, 1)); float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 2), 3, m2, 2); float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 1), 3, m2, 1); float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 2), neon::dup_lane(m1, 2)); Fac2 = w0 * w1 - w2 * w3; } // m[2][0] * m[3][3] - m[3][0] * m[2][3]; // m[2][0] * m[3][3] - m[3][0] * m[2][3]; // m[1][0] * m[3][3] - m[3][0] * m[1][3]; // m[1][0] * m[2][3] - m[2][0] * m[1][3]; float32x4_t Fac3; { float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 0), neon::dup_lane(m1, 0)); float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 3), 3, m2, 3); float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 0), 3, m2, 0); float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 3), neon::dup_lane(m1, 3)); Fac3 = w0 * w1 - w2 * w3; } // m[2][0] * m[3][2] - m[3][0] * m[2][2]; // m[2][0] * m[3][2] - m[3][0] * m[2][2]; // m[1][0] * m[3][2] - m[3][0] * m[1][2]; // m[1][0] * m[2][2] - m[2][0] * m[1][2]; float32x4_t Fac4; { float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 0), neon::dup_lane(m1, 0)); float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 2), 3, m2, 2); float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 0), 3, m2, 0); float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 2), neon::dup_lane(m1, 2)); Fac4 = w0 * w1 - w2 * w3; } // m[2][0] * m[3][1] - m[3][0] * m[2][1]; // m[2][0] * m[3][1] - m[3][0] * m[2][1]; // m[1][0] * m[3][1] - m[3][0] * m[1][1]; // m[1][0] * m[2][1] - m[2][0] * m[1][1]; float32x4_t Fac5; { float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 0), neon::dup_lane(m1, 0)); float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 1), 3, m2, 1); float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 0), 3, m2, 0); float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 1), neon::dup_lane(m1, 1)); Fac5 = w0 * w1 - w2 * w3; } float32x4_t Vec0 = neon::copy_lane(neon::dupq_lane(m0, 0), 0, m1, 0); // (m[1][0], m[0][0], m[0][0], m[0][0]); float32x4_t Vec1 = neon::copy_lane(neon::dupq_lane(m0, 1), 0, m1, 1); // (m[1][1], m[0][1], m[0][1], m[0][1]); float32x4_t Vec2 = neon::copy_lane(neon::dupq_lane(m0, 2), 0, m1, 2); // (m[1][2], m[0][2], m[0][2], m[0][2]); float32x4_t Vec3 = neon::copy_lane(neon::dupq_lane(m0, 3), 0, m1, 3); // (m[1][3], m[0][3], m[0][3], m[0][3]); float32x4_t Inv0 = Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2; float32x4_t Inv1 = Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4; float32x4_t Inv2 = Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5; float32x4_t Inv3 = Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5; float32x4_t r0 = float32x4_t{-1, +1, -1, +1} * Inv0; float32x4_t r1 = float32x4_t{+1, -1, +1, -1} * Inv1; float32x4_t r2 = float32x4_t{-1, +1, -1, +1} * Inv2; float32x4_t r3 = float32x4_t{+1, -1, +1, -1} * Inv3; float32x4_t det = neon::mul_lane(r0, m0, 0); det = neon::madd_lane(det, r1, m0, 1); det = neon::madd_lane(det, r2, m0, 2); det = neon::madd_lane(det, r3, m0, 3); float32x4_t rdet = vdupq_n_f32(1 / vgetq_lane_f32(det, 0)); mat<4, 4, float, Q> r; r[0].data = vmulq_f32(r0, rdet); r[1].data = vmulq_f32(r1, rdet); r[2].data = vmulq_f32(r2, rdet); r[3].data = vmulq_f32(r3, rdet); return r; } }; }//namespace glm #endif ================================================ FILE: android/src/glm/detail/func_packing.inl ================================================ /// @ref core /// @file glm/detail/func_packing.inl #include "../common.hpp" #include "type_half.hpp" namespace glm { GLM_FUNC_QUALIFIER uint packUnorm2x16(vec2 const& v) { union { unsigned short in[2]; uint out; } u; vec<2, unsigned short, defaultp> result(round(clamp(v, 0.0f, 1.0f) * 65535.0f)); u.in[0] = result[0]; u.in[1] = result[1]; return u.out; } GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint p) { union { uint in; unsigned short out[2]; } u; u.in = p; return vec2(u.out[0], u.out[1]) * 1.5259021896696421759365224689097e-5f; } GLM_FUNC_QUALIFIER uint packSnorm2x16(vec2 const& v) { union { signed short in[2]; uint out; } u; vec<2, short, defaultp> result(round(clamp(v, -1.0f, 1.0f) * 32767.0f)); u.in[0] = result[0]; u.in[1] = result[1]; return u.out; } GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint p) { union { uint in; signed short out[2]; } u; u.in = p; return clamp(vec2(u.out[0], u.out[1]) * 3.0518509475997192297128208258309e-5f, -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint packUnorm4x8(vec4 const& v) { union { unsigned char in[4]; uint out; } u; vec<4, unsigned char, defaultp> result(round(clamp(v, 0.0f, 1.0f) * 255.0f)); u.in[0] = result[0]; u.in[1] = result[1]; u.in[2] = result[2]; u.in[3] = result[3]; return u.out; } GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint p) { union { uint in; unsigned char out[4]; } u; u.in = p; return vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0039215686274509803921568627451f; } GLM_FUNC_QUALIFIER uint packSnorm4x8(vec4 const& v) { union { signed char in[4]; uint out; } u; vec<4, signed char, defaultp> result(round(clamp(v, -1.0f, 1.0f) * 127.0f)); u.in[0] = result[0]; u.in[1] = result[1]; u.in[2] = result[2]; u.in[3] = result[3]; return u.out; } GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint p) { union { uint in; signed char out[4]; } u; u.in = p; return clamp(vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0078740157480315f, -1.0f, 1.0f); } GLM_FUNC_QUALIFIER double packDouble2x32(uvec2 const& v) { union { uint in[2]; double out; } u; u.in[0] = v[0]; u.in[1] = v[1]; return u.out; } GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double v) { union { double in; uint out[2]; } u; u.in = v; return uvec2(u.out[0], u.out[1]); } GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const& v) { union { signed short in[2]; uint out; } u; u.in[0] = detail::toFloat16(v.x); u.in[1] = detail::toFloat16(v.y); return u.out; } GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint v) { union { uint in; signed short out[2]; } u; u.in = v; return vec2( detail::toFloat32(u.out[0]), detail::toFloat32(u.out[1])); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "func_packing_simd.inl" #endif ================================================ FILE: android/src/glm/detail/func_packing_simd.inl ================================================ namespace glm{ namespace detail { }//namespace detail }//namespace glm ================================================ FILE: android/src/glm/detail/func_trigonometric.inl ================================================ #include "_vectorize.hpp" #include #include namespace glm { // radians template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'radians' only accept floating-point input"); return degrees * static_cast(0.01745329251994329576923690768489); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec radians(vec const& v) { return detail::functor1::call(radians, v); } // degrees template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'degrees' only accept floating-point input"); return radians * static_cast(57.295779513082320876798154814105); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec degrees(vec const& v) { return detail::functor1::call(degrees, v); } // sin using ::std::sin; template GLM_FUNC_QUALIFIER vec sin(vec const& v) { return detail::functor1::call(sin, v); } // cos using std::cos; template GLM_FUNC_QUALIFIER vec cos(vec const& v) { return detail::functor1::call(cos, v); } // tan using std::tan; template GLM_FUNC_QUALIFIER vec tan(vec const& v) { return detail::functor1::call(tan, v); } // asin using std::asin; template GLM_FUNC_QUALIFIER vec asin(vec const& v) { return detail::functor1::call(asin, v); } // acos using std::acos; template GLM_FUNC_QUALIFIER vec acos(vec const& v) { return detail::functor1::call(acos, v); } // atan template GLM_FUNC_QUALIFIER genType atan(genType y, genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'atan' only accept floating-point input"); return ::std::atan2(y, x); } template GLM_FUNC_QUALIFIER vec atan(vec const& a, vec const& b) { return detail::functor2::call(::std::atan2, a, b); } using std::atan; template GLM_FUNC_QUALIFIER vec atan(vec const& v) { return detail::functor1::call(atan, v); } // sinh using std::sinh; template GLM_FUNC_QUALIFIER vec sinh(vec const& v) { return detail::functor1::call(sinh, v); } // cosh using std::cosh; template GLM_FUNC_QUALIFIER vec cosh(vec const& v) { return detail::functor1::call(cosh, v); } // tanh using std::tanh; template GLM_FUNC_QUALIFIER vec tanh(vec const& v) { return detail::functor1::call(tanh, v); } // asinh # if GLM_HAS_CXX11_STL using std::asinh; # else template GLM_FUNC_QUALIFIER genType asinh(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asinh' only accept floating-point input"); return (x < static_cast(0) ? static_cast(-1) : (x > static_cast(0) ? static_cast(1) : static_cast(0))) * log(std::abs(x) + sqrt(static_cast(1) + x * x)); } # endif template GLM_FUNC_QUALIFIER vec asinh(vec const& v) { return detail::functor1::call(asinh, v); } // acosh # if GLM_HAS_CXX11_STL using std::acosh; # else template GLM_FUNC_QUALIFIER genType acosh(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acosh' only accept floating-point input"); if(x < static_cast(1)) return static_cast(0); return log(x + sqrt(x * x - static_cast(1))); } # endif template GLM_FUNC_QUALIFIER vec acosh(vec const& v) { return detail::functor1::call(acosh, v); } // atanh # if GLM_HAS_CXX11_STL using std::atanh; # else template GLM_FUNC_QUALIFIER genType atanh(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'atanh' only accept floating-point input"); if(std::abs(x) >= static_cast(1)) return 0; return static_cast(0.5) * log((static_cast(1) + x) / (static_cast(1) - x)); } # endif template GLM_FUNC_QUALIFIER vec atanh(vec const& v) { return detail::functor1::call(atanh, v); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "func_trigonometric_simd.inl" #endif ================================================ FILE: android/src/glm/detail/func_trigonometric_simd.inl ================================================ ================================================ FILE: android/src/glm/detail/func_vector_relational.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec lessThan(vec const& x, vec const& y) { vec Result(true); for(length_t i = 0; i < L; ++i) Result[i] = x[i] < y[i]; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec lessThanEqual(vec const& x, vec const& y) { vec Result(true); for(length_t i = 0; i < L; ++i) Result[i] = x[i] <= y[i]; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec greaterThan(vec const& x, vec const& y) { vec Result(true); for(length_t i = 0; i < L; ++i) Result[i] = x[i] > y[i]; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec greaterThanEqual(vec const& x, vec const& y) { vec Result(true); for(length_t i = 0; i < L; ++i) Result[i] = x[i] >= y[i]; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(vec const& x, vec const& y) { vec Result(true); for(length_t i = 0; i < L; ++i) Result[i] = x[i] == y[i]; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y) { vec Result(true); for(length_t i = 0; i < L; ++i) Result[i] = x[i] != y[i]; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool any(vec const& v) { bool Result = false; for(length_t i = 0; i < L; ++i) Result = Result || v[i]; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool all(vec const& v) { bool Result = true; for(length_t i = 0; i < L; ++i) Result = Result && v[i]; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec not_(vec const& v) { vec Result(true); for(length_t i = 0; i < L; ++i) Result[i] = !v[i]; return Result; } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "func_vector_relational_simd.inl" #endif ================================================ FILE: android/src/glm/detail/func_vector_relational_simd.inl ================================================ namespace glm{ namespace detail { }//namespace detail }//namespace glm ================================================ FILE: android/src/glm/detail/glm.cpp ================================================ /// @ref core /// @file glm/glm.cpp #ifndef GLM_ENABLE_EXPERIMENTAL #define GLM_ENABLE_EXPERIMENTAL #endif #include #include #include #include #include #include namespace glm { // tvec1 type explicit instantiation template struct vec<1, uint8, lowp>; template struct vec<1, uint16, lowp>; template struct vec<1, uint32, lowp>; template struct vec<1, uint64, lowp>; template struct vec<1, int8, lowp>; template struct vec<1, int16, lowp>; template struct vec<1, int32, lowp>; template struct vec<1, int64, lowp>; template struct vec<1, float32, lowp>; template struct vec<1, float64, lowp>; template struct vec<1, uint8, mediump>; template struct vec<1, uint16, mediump>; template struct vec<1, uint32, mediump>; template struct vec<1, uint64, mediump>; template struct vec<1, int8, mediump>; template struct vec<1, int16, mediump>; template struct vec<1, int32, mediump>; template struct vec<1, int64, mediump>; template struct vec<1, float32, mediump>; template struct vec<1, float64, mediump>; template struct vec<1, uint8, highp>; template struct vec<1, uint16, highp>; template struct vec<1, uint32, highp>; template struct vec<1, uint64, highp>; template struct vec<1, int8, highp>; template struct vec<1, int16, highp>; template struct vec<1, int32, highp>; template struct vec<1, int64, highp>; template struct vec<1, float32, highp>; template struct vec<1, float64, highp>; // tvec2 type explicit instantiation template struct vec<2, uint8, lowp>; template struct vec<2, uint16, lowp>; template struct vec<2, uint32, lowp>; template struct vec<2, uint64, lowp>; template struct vec<2, int8, lowp>; template struct vec<2, int16, lowp>; template struct vec<2, int32, lowp>; template struct vec<2, int64, lowp>; template struct vec<2, float32, lowp>; template struct vec<2, float64, lowp>; template struct vec<2, uint8, mediump>; template struct vec<2, uint16, mediump>; template struct vec<2, uint32, mediump>; template struct vec<2, uint64, mediump>; template struct vec<2, int8, mediump>; template struct vec<2, int16, mediump>; template struct vec<2, int32, mediump>; template struct vec<2, int64, mediump>; template struct vec<2, float32, mediump>; template struct vec<2, float64, mediump>; template struct vec<2, uint8, highp>; template struct vec<2, uint16, highp>; template struct vec<2, uint32, highp>; template struct vec<2, uint64, highp>; template struct vec<2, int8, highp>; template struct vec<2, int16, highp>; template struct vec<2, int32, highp>; template struct vec<2, int64, highp>; template struct vec<2, float32, highp>; template struct vec<2, float64, highp>; // tvec3 type explicit instantiation template struct vec<3, uint8, lowp>; template struct vec<3, uint16, lowp>; template struct vec<3, uint32, lowp>; template struct vec<3, uint64, lowp>; template struct vec<3, int8, lowp>; template struct vec<3, int16, lowp>; template struct vec<3, int32, lowp>; template struct vec<3, int64, lowp>; template struct vec<3, float32, lowp>; template struct vec<3, float64, lowp>; template struct vec<3, uint8, mediump>; template struct vec<3, uint16, mediump>; template struct vec<3, uint32, mediump>; template struct vec<3, uint64, mediump>; template struct vec<3, int8, mediump>; template struct vec<3, int16, mediump>; template struct vec<3, int32, mediump>; template struct vec<3, int64, mediump>; template struct vec<3, float32, mediump>; template struct vec<3, float64, mediump>; template struct vec<3, uint8, highp>; template struct vec<3, uint16, highp>; template struct vec<3, uint32, highp>; template struct vec<3, uint64, highp>; template struct vec<3, int8, highp>; template struct vec<3, int16, highp>; template struct vec<3, int32, highp>; template struct vec<3, int64, highp>; template struct vec<3, float32, highp>; template struct vec<3, float64, highp>; // tvec4 type explicit instantiation template struct vec<4, uint8, lowp>; template struct vec<4, uint16, lowp>; template struct vec<4, uint32, lowp>; template struct vec<4, uint64, lowp>; template struct vec<4, int8, lowp>; template struct vec<4, int16, lowp>; template struct vec<4, int32, lowp>; template struct vec<4, int64, lowp>; template struct vec<4, float32, lowp>; template struct vec<4, float64, lowp>; template struct vec<4, uint8, mediump>; template struct vec<4, uint16, mediump>; template struct vec<4, uint32, mediump>; template struct vec<4, uint64, mediump>; template struct vec<4, int8, mediump>; template struct vec<4, int16, mediump>; template struct vec<4, int32, mediump>; template struct vec<4, int64, mediump>; template struct vec<4, float32, mediump>; template struct vec<4, float64, mediump>; template struct vec<4, uint8, highp>; template struct vec<4, uint16, highp>; template struct vec<4, uint32, highp>; template struct vec<4, uint64, highp>; template struct vec<4, int8, highp>; template struct vec<4, int16, highp>; template struct vec<4, int32, highp>; template struct vec<4, int64, highp>; template struct vec<4, float32, highp>; template struct vec<4, float64, highp>; // tmat2x2 type explicit instantiation template struct mat<2, 2, float32, lowp>; template struct mat<2, 2, float64, lowp>; template struct mat<2, 2, float32, mediump>; template struct mat<2, 2, float64, mediump>; template struct mat<2, 2, float32, highp>; template struct mat<2, 2, float64, highp>; // tmat2x3 type explicit instantiation template struct mat<2, 3, float32, lowp>; template struct mat<2, 3, float64, lowp>; template struct mat<2, 3, float32, mediump>; template struct mat<2, 3, float64, mediump>; template struct mat<2, 3, float32, highp>; template struct mat<2, 3, float64, highp>; // tmat2x4 type explicit instantiation template struct mat<2, 4, float32, lowp>; template struct mat<2, 4, float64, lowp>; template struct mat<2, 4, float32, mediump>; template struct mat<2, 4, float64, mediump>; template struct mat<2, 4, float32, highp>; template struct mat<2, 4, float64, highp>; // tmat3x2 type explicit instantiation template struct mat<3, 2, float32, lowp>; template struct mat<3, 2, float64, lowp>; template struct mat<3, 2, float32, mediump>; template struct mat<3, 2, float64, mediump>; template struct mat<3, 2, float32, highp>; template struct mat<3, 2, float64, highp>; // tmat3x3 type explicit instantiation template struct mat<3, 3, float32, lowp>; template struct mat<3, 3, float64, lowp>; template struct mat<3, 3, float32, mediump>; template struct mat<3, 3, float64, mediump>; template struct mat<3, 3, float32, highp>; template struct mat<3, 3, float64, highp>; // tmat3x4 type explicit instantiation template struct mat<3, 4, float32, lowp>; template struct mat<3, 4, float64, lowp>; template struct mat<3, 4, float32, mediump>; template struct mat<3, 4, float64, mediump>; template struct mat<3, 4, float32, highp>; template struct mat<3, 4, float64, highp>; // tmat4x2 type explicit instantiation template struct mat<4, 2, float32, lowp>; template struct mat<4, 2, float64, lowp>; template struct mat<4, 2, float32, mediump>; template struct mat<4, 2, float64, mediump>; template struct mat<4, 2, float32, highp>; template struct mat<4, 2, float64, highp>; // tmat4x3 type explicit instantiation template struct mat<4, 3, float32, lowp>; template struct mat<4, 3, float64, lowp>; template struct mat<4, 3, float32, mediump>; template struct mat<4, 3, float64, mediump>; template struct mat<4, 3, float32, highp>; template struct mat<4, 3, float64, highp>; // tmat4x4 type explicit instantiation template struct mat<4, 4, float32, lowp>; template struct mat<4, 4, float64, lowp>; template struct mat<4, 4, float32, mediump>; template struct mat<4, 4, float64, mediump>; template struct mat<4, 4, float32, highp>; template struct mat<4, 4, float64, highp>; // tquat type explicit instantiation template struct qua; template struct qua; template struct qua; template struct qua; template struct qua; template struct qua; //tdualquat type explicit instantiation template struct tdualquat; template struct tdualquat; template struct tdualquat; template struct tdualquat; template struct tdualquat; template struct tdualquat; }//namespace glm ================================================ FILE: android/src/glm/detail/qualifier.hpp ================================================ #pragma once #include "setup.hpp" namespace glm { /// Qualify GLM types in term of alignment (packed, aligned) and precision in term of ULPs (lowp, mediump, highp) enum qualifier { packed_highp, ///< Typed data is tightly packed in memory and operations are executed with high precision in term of ULPs packed_mediump, ///< Typed data is tightly packed in memory and operations are executed with medium precision in term of ULPs for higher performance packed_lowp, ///< Typed data is tightly packed in memory and operations are executed with low precision in term of ULPs to maximize performance # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE aligned_highp, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs aligned_mediump, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs for higher performance aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance aligned = aligned_highp, ///< By default aligned qualifier is also high precision # endif highp = packed_highp, ///< By default highp qualifier is also packed mediump = packed_mediump, ///< By default mediump qualifier is also packed lowp = packed_lowp, ///< By default lowp qualifier is also packed packed = packed_highp, ///< By default packed qualifier is also high precision # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE && defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES) defaultp = aligned_highp # else defaultp = highp # endif }; typedef qualifier precision; template struct vec; template struct mat; template struct qua; # if GLM_HAS_TEMPLATE_ALIASES template using tvec1 = vec<1, T, Q>; template using tvec2 = vec<2, T, Q>; template using tvec3 = vec<3, T, Q>; template using tvec4 = vec<4, T, Q>; template using tmat2x2 = mat<2, 2, T, Q>; template using tmat2x3 = mat<2, 3, T, Q>; template using tmat2x4 = mat<2, 4, T, Q>; template using tmat3x2 = mat<3, 2, T, Q>; template using tmat3x3 = mat<3, 3, T, Q>; template using tmat3x4 = mat<3, 4, T, Q>; template using tmat4x2 = mat<4, 2, T, Q>; template using tmat4x3 = mat<4, 3, T, Q>; template using tmat4x4 = mat<4, 4, T, Q>; template using tquat = qua; # endif namespace detail { template struct is_aligned { static const bool value = false; }; # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE template<> struct is_aligned { static const bool value = true; }; template<> struct is_aligned { static const bool value = true; }; template<> struct is_aligned { static const bool value = true; }; # endif template struct storage { typedef struct type { T data[L]; } type; }; # if GLM_HAS_ALIGNOF template struct storage { typedef struct alignas(L * sizeof(T)) type { T data[L]; } type; }; template struct storage<3, T, true> { typedef struct alignas(4 * sizeof(T)) type { T data[4]; } type; }; # endif # if GLM_ARCH & GLM_ARCH_SSE2_BIT template<> struct storage<4, float, true> { typedef glm_f32vec4 type; }; template<> struct storage<4, int, true> { typedef glm_i32vec4 type; }; template<> struct storage<4, unsigned int, true> { typedef glm_u32vec4 type; }; template<> struct storage<2, double, true> { typedef glm_f64vec2 type; }; template<> struct storage<2, detail::int64, true> { typedef glm_i64vec2 type; }; template<> struct storage<2, detail::uint64, true> { typedef glm_u64vec2 type; }; # endif # if (GLM_ARCH & GLM_ARCH_AVX_BIT) template<> struct storage<4, double, true> { typedef glm_f64vec4 type; }; # endif # if (GLM_ARCH & GLM_ARCH_AVX2_BIT) template<> struct storage<4, detail::int64, true> { typedef glm_i64vec4 type; }; template<> struct storage<4, detail::uint64, true> { typedef glm_u64vec4 type; }; # endif # if GLM_ARCH & GLM_ARCH_NEON_BIT template<> struct storage<4, float, true> { typedef glm_f32vec4 type; }; template<> struct storage<4, int, true> { typedef glm_i32vec4 type; }; template<> struct storage<4, unsigned int, true> { typedef glm_u32vec4 type; }; # endif enum genTypeEnum { GENTYPE_VEC, GENTYPE_MAT, GENTYPE_QUAT }; template struct genTypeTrait {}; template struct genTypeTrait > { static const genTypeEnum GENTYPE = GENTYPE_MAT; }; template struct init_gentype { }; template struct init_gentype { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity() { return genType(1, 0, 0, 0); } }; template struct init_gentype { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity() { return genType(1); } }; }//namespace detail }//namespace glm ================================================ FILE: android/src/glm/detail/setup.hpp ================================================ #ifndef GLM_SETUP_INCLUDED #include #include #define GLM_VERSION_MAJOR 0 #define GLM_VERSION_MINOR 9 #define GLM_VERSION_PATCH 9 #define GLM_VERSION_REVISION 8 #define GLM_VERSION 998 #define GLM_VERSION_MESSAGE "GLM: version 0.9.9.8" #define GLM_SETUP_INCLUDED GLM_VERSION /////////////////////////////////////////////////////////////////////////////////// // Active states #define GLM_DISABLE 0 #define GLM_ENABLE 1 /////////////////////////////////////////////////////////////////////////////////// // Messages #if defined(GLM_FORCE_MESSAGES) # define GLM_MESSAGES GLM_ENABLE #else # define GLM_MESSAGES GLM_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// // Detect the platform #include "../simd/platform.h" /////////////////////////////////////////////////////////////////////////////////// // Build model #if defined(_M_ARM64) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__) # define GLM_MODEL GLM_MODEL_64 #elif defined(__i386__) || defined(__ppc__) || defined(__ILP32__) || defined(_M_ARM) # define GLM_MODEL GLM_MODEL_32 #else # define GLM_MODEL GLM_MODEL_32 #endif// #if !defined(GLM_MODEL) && GLM_COMPILER != 0 # error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message." #endif//GLM_MODEL /////////////////////////////////////////////////////////////////////////////////// // C++ Version // User defines: GLM_FORCE_CXX98, GLM_FORCE_CXX03, GLM_FORCE_CXX11, GLM_FORCE_CXX14, GLM_FORCE_CXX17, GLM_FORCE_CXX2A #define GLM_LANG_CXX98_FLAG (1 << 1) #define GLM_LANG_CXX03_FLAG (1 << 2) #define GLM_LANG_CXX0X_FLAG (1 << 3) #define GLM_LANG_CXX11_FLAG (1 << 4) #define GLM_LANG_CXX14_FLAG (1 << 5) #define GLM_LANG_CXX17_FLAG (1 << 6) #define GLM_LANG_CXX2A_FLAG (1 << 7) #define GLM_LANG_CXXMS_FLAG (1 << 8) #define GLM_LANG_CXXGNU_FLAG (1 << 9) #define GLM_LANG_CXX98 GLM_LANG_CXX98_FLAG #define GLM_LANG_CXX03 (GLM_LANG_CXX98 | GLM_LANG_CXX03_FLAG) #define GLM_LANG_CXX0X (GLM_LANG_CXX03 | GLM_LANG_CXX0X_FLAG) #define GLM_LANG_CXX11 (GLM_LANG_CXX0X | GLM_LANG_CXX11_FLAG) #define GLM_LANG_CXX14 (GLM_LANG_CXX11 | GLM_LANG_CXX14_FLAG) #define GLM_LANG_CXX17 (GLM_LANG_CXX14 | GLM_LANG_CXX17_FLAG) #define GLM_LANG_CXX2A (GLM_LANG_CXX17 | GLM_LANG_CXX2A_FLAG) #define GLM_LANG_CXXMS GLM_LANG_CXXMS_FLAG #define GLM_LANG_CXXGNU GLM_LANG_CXXGNU_FLAG #if (defined(_MSC_EXTENSIONS)) # define GLM_LANG_EXT GLM_LANG_CXXMS_FLAG #elif ((GLM_COMPILER & (GLM_COMPILER_CLANG | GLM_COMPILER_GCC)) && (GLM_ARCH & GLM_ARCH_SIMD_BIT)) # define GLM_LANG_EXT GLM_LANG_CXXMS_FLAG #else # define GLM_LANG_EXT 0 #endif #if (defined(GLM_FORCE_CXX_UNKNOWN)) # define GLM_LANG 0 #elif defined(GLM_FORCE_CXX2A) # define GLM_LANG (GLM_LANG_CXX2A | GLM_LANG_EXT) # define GLM_LANG_STL11_FORCED #elif defined(GLM_FORCE_CXX17) # define GLM_LANG (GLM_LANG_CXX17 | GLM_LANG_EXT) # define GLM_LANG_STL11_FORCED #elif defined(GLM_FORCE_CXX14) # define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_EXT) # define GLM_LANG_STL11_FORCED #elif defined(GLM_FORCE_CXX11) # define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_EXT) # define GLM_LANG_STL11_FORCED #elif defined(GLM_FORCE_CXX03) # define GLM_LANG (GLM_LANG_CXX03 | GLM_LANG_EXT) #elif defined(GLM_FORCE_CXX98) # define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_EXT) #else # if GLM_COMPILER & GLM_COMPILER_VC && defined(_MSVC_LANG) # if GLM_COMPILER >= GLM_COMPILER_VC15_7 # define GLM_LANG_PLATFORM _MSVC_LANG # elif GLM_COMPILER >= GLM_COMPILER_VC15 # if _MSVC_LANG > 201402L # define GLM_LANG_PLATFORM 201402L # else # define GLM_LANG_PLATFORM _MSVC_LANG # endif # else # define GLM_LANG_PLATFORM 0 # endif # else # define GLM_LANG_PLATFORM 0 # endif # if __cplusplus > 201703L || GLM_LANG_PLATFORM > 201703L # define GLM_LANG (GLM_LANG_CXX2A | GLM_LANG_EXT) # elif __cplusplus == 201703L || GLM_LANG_PLATFORM == 201703L # define GLM_LANG (GLM_LANG_CXX17 | GLM_LANG_EXT) # elif __cplusplus == 201402L || __cplusplus == 201500L || GLM_LANG_PLATFORM == 201402L # define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_EXT) # elif __cplusplus == 201103L || GLM_LANG_PLATFORM == 201103L # define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_EXT) # elif defined(__INTEL_CXX11_MODE__) || defined(_MSC_VER) || defined(__GXX_EXPERIMENTAL_CXX0X__) # define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_EXT) # elif __cplusplus == 199711L # define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_EXT) # else # define GLM_LANG (0 | GLM_LANG_EXT) # endif #endif /////////////////////////////////////////////////////////////////////////////////// // Has of C++ features // http://clang.llvm.org/cxx_status.html // http://gcc.gnu.org/projects/cxx0x.html // http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx // Android has multiple STLs but C++11 STL detection doesn't always work #284 #564 #if GLM_PLATFORM == GLM_PLATFORM_ANDROID && !defined(GLM_LANG_STL11_FORCED) # define GLM_HAS_CXX11_STL 0 #elif GLM_COMPILER & GLM_COMPILER_CLANG # if (defined(_LIBCPP_VERSION) || (GLM_LANG & GLM_LANG_CXX11_FLAG) || defined(GLM_LANG_STL11_FORCED)) # define GLM_HAS_CXX11_STL 1 # else # define GLM_HAS_CXX11_STL 0 # endif #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_CXX11_STL 1 #else # define GLM_HAS_CXX11_STL ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_PLATFORM != GLM_PLATFORM_WINDOWS) && (GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15)))) #endif // N1720 #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_STATIC_ASSERT __has_feature(cxx_static_assert) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_STATIC_ASSERT 1 #else # define GLM_HAS_STATIC_ASSERT ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_CUDA)) || \ ((GLM_COMPILER & GLM_COMPILER_VC)))) #endif // N1988 #if GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_EXTENDED_INTEGER_TYPE 1 #else # define GLM_HAS_EXTENDED_INTEGER_TYPE (\ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC)) || \ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CUDA)) || \ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CLANG))) #endif // N2672 Initializer lists http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_INITIALIZER_LISTS __has_feature(cxx_generalized_initializers) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_INITIALIZER_LISTS 1 #else # define GLM_HAS_INITIALIZER_LISTS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2544 Unrestricted unions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_UNRESTRICTED_UNIONS __has_feature(cxx_unrestricted_unions) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_UNRESTRICTED_UNIONS 1 #else # define GLM_HAS_UNRESTRICTED_UNIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ (GLM_COMPILER & GLM_COMPILER_VC) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA))) #endif // N2346 #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_DEFAULTED_FUNCTIONS __has_feature(cxx_defaulted_functions) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_DEFAULTED_FUNCTIONS 1 #else # define GLM_HAS_DEFAULTED_FUNCTIONS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \ (GLM_COMPILER & GLM_COMPILER_CUDA))) #endif // N2118 #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_RVALUE_REFERENCES __has_feature(cxx_rvalue_references) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_RVALUE_REFERENCES 1 #else # define GLM_HAS_RVALUE_REFERENCES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_VC)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2437 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS __has_feature(cxx_explicit_conversions) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS 1 #else # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2258 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_TEMPLATE_ALIASES __has_feature(cxx_alias_templates) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_TEMPLATE_ALIASES 1 #else # define GLM_HAS_TEMPLATE_ALIASES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2930 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_RANGE_FOR __has_feature(cxx_range_for) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_RANGE_FOR 1 #else # define GLM_HAS_RANGE_FOR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \ ((GLM_COMPILER & GLM_COMPILER_VC)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2341 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_ALIGNOF __has_feature(cxx_alignas) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_ALIGNOF 1 #else # define GLM_HAS_ALIGNOF ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2235 Generalized Constant Expressions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf // N3652 Extended Constant Expressions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html #if (GLM_ARCH & GLM_ARCH_SIMD_BIT) // Compiler SIMD intrinsics don't support constexpr... # define GLM_HAS_CONSTEXPR 0 #elif (GLM_COMPILER & GLM_COMPILER_CLANG) # define GLM_HAS_CONSTEXPR __has_feature(cxx_relaxed_constexpr) #elif (GLM_LANG & GLM_LANG_CXX14_FLAG) # define GLM_HAS_CONSTEXPR 1 #else # define GLM_HAS_CONSTEXPR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && GLM_HAS_INITIALIZER_LISTS && (\ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL17)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)))) #endif #if GLM_HAS_CONSTEXPR # define GLM_CONSTEXPR constexpr #else # define GLM_CONSTEXPR #endif // #if GLM_HAS_CONSTEXPR # if (GLM_COMPILER & GLM_COMPILER_CLANG) # if __has_feature(cxx_if_constexpr) # define GLM_HAS_IF_CONSTEXPR 1 # else # define GLM_HAS_IF_CONSTEXPR 0 # endif # elif (GLM_LANG & GLM_LANG_CXX17_FLAG) # define GLM_HAS_IF_CONSTEXPR 1 # else # define GLM_HAS_IF_CONSTEXPR 0 # endif #else # define GLM_HAS_IF_CONSTEXPR 0 #endif #if GLM_HAS_IF_CONSTEXPR # define GLM_IF_CONSTEXPR if constexpr #else # define GLM_IF_CONSTEXPR if #endif // #if GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_ASSIGNABLE 1 #else # define GLM_HAS_ASSIGNABLE ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC49)))) #endif // #define GLM_HAS_TRIVIAL_QUERIES 0 // #if GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_MAKE_SIGNED 1 #else # define GLM_HAS_MAKE_SIGNED ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // #if defined(GLM_FORCE_INTRINSICS) # define GLM_HAS_BITSCAN_WINDOWS ((GLM_PLATFORM & GLM_PLATFORM_WINDOWS) && (\ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14) && (GLM_ARCH & GLM_ARCH_X86_BIT)))) #else # define GLM_HAS_BITSCAN_WINDOWS 0 #endif /////////////////////////////////////////////////////////////////////////////////// // OpenMP #ifdef _OPENMP # if GLM_COMPILER & GLM_COMPILER_GCC # if GLM_COMPILER >= GLM_COMPILER_GCC61 # define GLM_HAS_OPENMP 45 # elif GLM_COMPILER >= GLM_COMPILER_GCC49 # define GLM_HAS_OPENMP 40 # elif GLM_COMPILER >= GLM_COMPILER_GCC47 # define GLM_HAS_OPENMP 31 # else # define GLM_HAS_OPENMP 0 # endif # elif GLM_COMPILER & GLM_COMPILER_CLANG # if GLM_COMPILER >= GLM_COMPILER_CLANG38 # define GLM_HAS_OPENMP 31 # else # define GLM_HAS_OPENMP 0 # endif # elif GLM_COMPILER & GLM_COMPILER_VC # define GLM_HAS_OPENMP 20 # elif GLM_COMPILER & GLM_COMPILER_INTEL # if GLM_COMPILER >= GLM_COMPILER_INTEL16 # define GLM_HAS_OPENMP 40 # else # define GLM_HAS_OPENMP 0 # endif # else # define GLM_HAS_OPENMP 0 # endif #else # define GLM_HAS_OPENMP 0 #endif /////////////////////////////////////////////////////////////////////////////////// // nullptr #if GLM_LANG & GLM_LANG_CXX0X_FLAG # define GLM_CONFIG_NULLPTR GLM_ENABLE #else # define GLM_CONFIG_NULLPTR GLM_DISABLE #endif #if GLM_CONFIG_NULLPTR == GLM_ENABLE # define GLM_NULLPTR nullptr #else # define GLM_NULLPTR 0 #endif /////////////////////////////////////////////////////////////////////////////////// // Static assert #if GLM_HAS_STATIC_ASSERT # define GLM_STATIC_ASSERT(x, message) static_assert(x, message) #elif GLM_COMPILER & GLM_COMPILER_VC # define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1] #else # define GLM_STATIC_ASSERT(x, message) assert(x) #endif//GLM_LANG /////////////////////////////////////////////////////////////////////////////////// // Qualifiers #if GLM_COMPILER & GLM_COMPILER_CUDA # define GLM_CUDA_FUNC_DEF __device__ __host__ # define GLM_CUDA_FUNC_DECL __device__ __host__ #else # define GLM_CUDA_FUNC_DEF # define GLM_CUDA_FUNC_DECL #endif #if defined(GLM_FORCE_INLINE) # if GLM_COMPILER & GLM_COMPILER_VC # define GLM_INLINE __forceinline # define GLM_NEVER_INLINE __declspec((noinline)) # elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG) # define GLM_INLINE inline __attribute__((__always_inline__)) # define GLM_NEVER_INLINE __attribute__((__noinline__)) # elif GLM_COMPILER & GLM_COMPILER_CUDA # define GLM_INLINE __forceinline__ # define GLM_NEVER_INLINE __noinline__ # else # define GLM_INLINE inline # define GLM_NEVER_INLINE # endif//GLM_COMPILER #else # define GLM_INLINE inline # define GLM_NEVER_INLINE #endif//defined(GLM_FORCE_INLINE) #define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL #define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE /////////////////////////////////////////////////////////////////////////////////// // Swizzle operators // User defines: GLM_FORCE_SWIZZLE #define GLM_SWIZZLE_DISABLED 0 #define GLM_SWIZZLE_OPERATOR 1 #define GLM_SWIZZLE_FUNCTION 2 #if defined(GLM_FORCE_XYZW_ONLY) # undef GLM_FORCE_SWIZZLE #endif #if defined(GLM_SWIZZLE) # pragma message("GLM: GLM_SWIZZLE is deprecated, use GLM_FORCE_SWIZZLE instead.") # define GLM_FORCE_SWIZZLE #endif #if defined(GLM_FORCE_SWIZZLE) && (GLM_LANG & GLM_LANG_CXXMS_FLAG) # define GLM_CONFIG_SWIZZLE GLM_SWIZZLE_OPERATOR #elif defined(GLM_FORCE_SWIZZLE) # define GLM_CONFIG_SWIZZLE GLM_SWIZZLE_FUNCTION #else # define GLM_CONFIG_SWIZZLE GLM_SWIZZLE_DISABLED #endif /////////////////////////////////////////////////////////////////////////////////// // Allows using not basic types as genType // #define GLM_FORCE_UNRESTRICTED_GENTYPE #ifdef GLM_FORCE_UNRESTRICTED_GENTYPE # define GLM_CONFIG_UNRESTRICTED_GENTYPE GLM_ENABLE #else # define GLM_CONFIG_UNRESTRICTED_GENTYPE GLM_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// // Clip control, define GLM_FORCE_DEPTH_ZERO_TO_ONE before including GLM // to use a clip space between 0 to 1. // Coordinate system, define GLM_FORCE_LEFT_HANDED before including GLM // to use left handed coordinate system by default. #define GLM_CLIP_CONTROL_ZO_BIT (1 << 0) // ZERO_TO_ONE #define GLM_CLIP_CONTROL_NO_BIT (1 << 1) // NEGATIVE_ONE_TO_ONE #define GLM_CLIP_CONTROL_LH_BIT (1 << 2) // LEFT_HANDED, For DirectX, Metal, Vulkan #define GLM_CLIP_CONTROL_RH_BIT (1 << 3) // RIGHT_HANDED, For OpenGL, default in GLM #define GLM_CLIP_CONTROL_LH_ZO (GLM_CLIP_CONTROL_LH_BIT | GLM_CLIP_CONTROL_ZO_BIT) #define GLM_CLIP_CONTROL_LH_NO (GLM_CLIP_CONTROL_LH_BIT | GLM_CLIP_CONTROL_NO_BIT) #define GLM_CLIP_CONTROL_RH_ZO (GLM_CLIP_CONTROL_RH_BIT | GLM_CLIP_CONTROL_ZO_BIT) #define GLM_CLIP_CONTROL_RH_NO (GLM_CLIP_CONTROL_RH_BIT | GLM_CLIP_CONTROL_NO_BIT) #ifdef GLM_FORCE_DEPTH_ZERO_TO_ONE # ifdef GLM_FORCE_LEFT_HANDED # define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_LH_ZO # else # define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_RH_ZO # endif #else # ifdef GLM_FORCE_LEFT_HANDED # define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_LH_NO # else # define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_RH_NO # endif #endif /////////////////////////////////////////////////////////////////////////////////// // Qualifiers #if (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)) # define GLM_DEPRECATED __declspec(deprecated) # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef __declspec(align(alignment)) type name #elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG | GLM_COMPILER_INTEL) # define GLM_DEPRECATED __attribute__((__deprecated__)) # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __attribute__((aligned(alignment))) #elif GLM_COMPILER & GLM_COMPILER_CUDA # define GLM_DEPRECATED # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __align__(x) #else # define GLM_DEPRECATED # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name #endif /////////////////////////////////////////////////////////////////////////////////// #ifdef GLM_FORCE_EXPLICIT_CTOR # define GLM_EXPLICIT explicit #else # define GLM_EXPLICIT #endif /////////////////////////////////////////////////////////////////////////////////// // SYCL #if GLM_COMPILER==GLM_COMPILER_SYCL #include #include namespace glm { namespace std { // Import SYCL's functions into the namespace glm::std to force their usages. // It's important to use the math built-in function (sin, exp, ...) // of SYCL instead the std ones. using namespace cl::sycl; /////////////////////////////////////////////////////////////////////////////// // Import some "harmless" std's stuffs used by glm into // the new glm::std namespace. template using numeric_limits = ::std::numeric_limits; using ::std::size_t; using ::std::uint8_t; using ::std::uint16_t; using ::std::uint32_t; using ::std::uint64_t; using ::std::int8_t; using ::std::int16_t; using ::std::int32_t; using ::std::int64_t; using ::std::make_unsigned; /////////////////////////////////////////////////////////////////////////////// } //namespace std } //namespace glm #endif /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// // Length type: all length functions returns a length_t type. // When GLM_FORCE_SIZE_T_LENGTH is defined, length_t is a typedef of size_t otherwise // length_t is a typedef of int like GLSL defines it. #define GLM_LENGTH_INT 1 #define GLM_LENGTH_SIZE_T 2 #ifdef GLM_FORCE_SIZE_T_LENGTH # define GLM_CONFIG_LENGTH_TYPE GLM_LENGTH_SIZE_T #else # define GLM_CONFIG_LENGTH_TYPE GLM_LENGTH_INT #endif namespace glm { using std::size_t; # if GLM_CONFIG_LENGTH_TYPE == GLM_LENGTH_SIZE_T typedef size_t length_t; # else typedef int length_t; # endif }//namespace glm /////////////////////////////////////////////////////////////////////////////////// // constexpr #if GLM_HAS_CONSTEXPR # define GLM_CONFIG_CONSTEXP GLM_ENABLE namespace glm { template constexpr std::size_t countof(T const (&)[N]) { return N; } }//namespace glm # define GLM_COUNTOF(arr) glm::countof(arr) #elif defined(_MSC_VER) # define GLM_CONFIG_CONSTEXP GLM_DISABLE # define GLM_COUNTOF(arr) _countof(arr) #else # define GLM_CONFIG_CONSTEXP GLM_DISABLE # define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0]) #endif /////////////////////////////////////////////////////////////////////////////////// // uint namespace glm{ namespace detail { template struct is_int { enum test {value = 0}; }; template<> struct is_int { enum test {value = ~0}; }; template<> struct is_int { enum test {value = ~0}; }; }//namespace detail typedef unsigned int uint; }//namespace glm /////////////////////////////////////////////////////////////////////////////////// // 64-bit int #if GLM_HAS_EXTENDED_INTEGER_TYPE # include #endif namespace glm{ namespace detail { # if GLM_HAS_EXTENDED_INTEGER_TYPE typedef std::uint64_t uint64; typedef std::int64_t int64; # elif (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available typedef uint64_t uint64; typedef int64_t int64; # elif GLM_COMPILER & GLM_COMPILER_VC typedef unsigned __int64 uint64; typedef signed __int64 int64; # elif GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic ignored "-Wlong-long" __extension__ typedef unsigned long long uint64; __extension__ typedef signed long long int64; # elif (GLM_COMPILER & GLM_COMPILER_CLANG) # pragma clang diagnostic ignored "-Wc++11-long-long" typedef unsigned long long uint64; typedef signed long long int64; # else//unknown compiler typedef unsigned long long uint64; typedef signed long long int64; # endif }//namespace detail }//namespace glm /////////////////////////////////////////////////////////////////////////////////// // make_unsigned #if GLM_HAS_MAKE_SIGNED # include namespace glm{ namespace detail { using std::make_unsigned; }//namespace detail }//namespace glm #else namespace glm{ namespace detail { template struct make_unsigned {}; template<> struct make_unsigned { typedef unsigned char type; }; template<> struct make_unsigned { typedef unsigned char type; }; template<> struct make_unsigned { typedef unsigned short type; }; template<> struct make_unsigned { typedef unsigned int type; }; template<> struct make_unsigned { typedef unsigned long type; }; template<> struct make_unsigned { typedef uint64 type; }; template<> struct make_unsigned { typedef unsigned char type; }; template<> struct make_unsigned { typedef unsigned short type; }; template<> struct make_unsigned { typedef unsigned int type; }; template<> struct make_unsigned { typedef unsigned long type; }; template<> struct make_unsigned { typedef uint64 type; }; }//namespace detail }//namespace glm #endif /////////////////////////////////////////////////////////////////////////////////// // Only use x, y, z, w as vector type components #ifdef GLM_FORCE_XYZW_ONLY # define GLM_CONFIG_XYZW_ONLY GLM_ENABLE #else # define GLM_CONFIG_XYZW_ONLY GLM_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// // Configure the use of defaulted initialized types #define GLM_CTOR_INIT_DISABLE 0 #define GLM_CTOR_INITIALIZER_LIST 1 #define GLM_CTOR_INITIALISATION 2 #if defined(GLM_FORCE_CTOR_INIT) && GLM_HAS_INITIALIZER_LISTS # define GLM_CONFIG_CTOR_INIT GLM_CTOR_INITIALIZER_LIST #elif defined(GLM_FORCE_CTOR_INIT) && !GLM_HAS_INITIALIZER_LISTS # define GLM_CONFIG_CTOR_INIT GLM_CTOR_INITIALISATION #else # define GLM_CONFIG_CTOR_INIT GLM_CTOR_INIT_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// // Use SIMD instruction sets #if GLM_HAS_ALIGNOF && (GLM_LANG & GLM_LANG_CXXMS_FLAG) && (GLM_ARCH & GLM_ARCH_SIMD_BIT) # define GLM_CONFIG_SIMD GLM_ENABLE #else # define GLM_CONFIG_SIMD GLM_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// // Configure the use of defaulted function #if GLM_HAS_DEFAULTED_FUNCTIONS && GLM_CONFIG_CTOR_INIT == GLM_CTOR_INIT_DISABLE # define GLM_CONFIG_DEFAULTED_FUNCTIONS GLM_ENABLE # define GLM_DEFAULT = default #else # define GLM_CONFIG_DEFAULTED_FUNCTIONS GLM_DISABLE # define GLM_DEFAULT #endif /////////////////////////////////////////////////////////////////////////////////// // Configure the use of aligned gentypes #ifdef GLM_FORCE_ALIGNED // Legacy define # define GLM_FORCE_DEFAULT_ALIGNED_GENTYPES #endif #ifdef GLM_FORCE_DEFAULT_ALIGNED_GENTYPES # define GLM_FORCE_ALIGNED_GENTYPES #endif #if GLM_HAS_ALIGNOF && (GLM_LANG & GLM_LANG_CXXMS_FLAG) && (defined(GLM_FORCE_ALIGNED_GENTYPES) || (GLM_CONFIG_SIMD == GLM_ENABLE)) # define GLM_CONFIG_ALIGNED_GENTYPES GLM_ENABLE #else # define GLM_CONFIG_ALIGNED_GENTYPES GLM_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// // Configure the use of anonymous structure as implementation detail #if ((GLM_CONFIG_SIMD == GLM_ENABLE) || (GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR) || (GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE)) # define GLM_CONFIG_ANONYMOUS_STRUCT GLM_ENABLE #else # define GLM_CONFIG_ANONYMOUS_STRUCT GLM_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// // Silent warnings #ifdef GLM_FORCE_SILENT_WARNINGS # define GLM_SILENT_WARNINGS GLM_ENABLE #else # define GLM_SILENT_WARNINGS GLM_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// // Precision #define GLM_HIGHP 1 #define GLM_MEDIUMP 2 #define GLM_LOWP 3 #if defined(GLM_FORCE_PRECISION_HIGHP_BOOL) || defined(GLM_PRECISION_HIGHP_BOOL) # define GLM_CONFIG_PRECISION_BOOL GLM_HIGHP #elif defined(GLM_FORCE_PRECISION_MEDIUMP_BOOL) || defined(GLM_PRECISION_MEDIUMP_BOOL) # define GLM_CONFIG_PRECISION_BOOL GLM_MEDIUMP #elif defined(GLM_FORCE_PRECISION_LOWP_BOOL) || defined(GLM_PRECISION_LOWP_BOOL) # define GLM_CONFIG_PRECISION_BOOL GLM_LOWP #else # define GLM_CONFIG_PRECISION_BOOL GLM_HIGHP #endif #if defined(GLM_FORCE_PRECISION_HIGHP_INT) || defined(GLM_PRECISION_HIGHP_INT) # define GLM_CONFIG_PRECISION_INT GLM_HIGHP #elif defined(GLM_FORCE_PRECISION_MEDIUMP_INT) || defined(GLM_PRECISION_MEDIUMP_INT) # define GLM_CONFIG_PRECISION_INT GLM_MEDIUMP #elif defined(GLM_FORCE_PRECISION_LOWP_INT) || defined(GLM_PRECISION_LOWP_INT) # define GLM_CONFIG_PRECISION_INT GLM_LOWP #else # define GLM_CONFIG_PRECISION_INT GLM_HIGHP #endif #if defined(GLM_FORCE_PRECISION_HIGHP_UINT) || defined(GLM_PRECISION_HIGHP_UINT) # define GLM_CONFIG_PRECISION_UINT GLM_HIGHP #elif defined(GLM_FORCE_PRECISION_MEDIUMP_UINT) || defined(GLM_PRECISION_MEDIUMP_UINT) # define GLM_CONFIG_PRECISION_UINT GLM_MEDIUMP #elif defined(GLM_FORCE_PRECISION_LOWP_UINT) || defined(GLM_PRECISION_LOWP_UINT) # define GLM_CONFIG_PRECISION_UINT GLM_LOWP #else # define GLM_CONFIG_PRECISION_UINT GLM_HIGHP #endif #if defined(GLM_FORCE_PRECISION_HIGHP_FLOAT) || defined(GLM_PRECISION_HIGHP_FLOAT) # define GLM_CONFIG_PRECISION_FLOAT GLM_HIGHP #elif defined(GLM_FORCE_PRECISION_MEDIUMP_FLOAT) || defined(GLM_PRECISION_MEDIUMP_FLOAT) # define GLM_CONFIG_PRECISION_FLOAT GLM_MEDIUMP #elif defined(GLM_FORCE_PRECISION_LOWP_FLOAT) || defined(GLM_PRECISION_LOWP_FLOAT) # define GLM_CONFIG_PRECISION_FLOAT GLM_LOWP #else # define GLM_CONFIG_PRECISION_FLOAT GLM_HIGHP #endif #if defined(GLM_FORCE_PRECISION_HIGHP_DOUBLE) || defined(GLM_PRECISION_HIGHP_DOUBLE) # define GLM_CONFIG_PRECISION_DOUBLE GLM_HIGHP #elif defined(GLM_FORCE_PRECISION_MEDIUMP_DOUBLE) || defined(GLM_PRECISION_MEDIUMP_DOUBLE) # define GLM_CONFIG_PRECISION_DOUBLE GLM_MEDIUMP #elif defined(GLM_FORCE_PRECISION_LOWP_DOUBLE) || defined(GLM_PRECISION_LOWP_DOUBLE) # define GLM_CONFIG_PRECISION_DOUBLE GLM_LOWP #else # define GLM_CONFIG_PRECISION_DOUBLE GLM_HIGHP #endif /////////////////////////////////////////////////////////////////////////////////// // Check inclusions of different versions of GLM #elif ((GLM_SETUP_INCLUDED != GLM_VERSION) && !defined(GLM_FORCE_IGNORE_VERSION)) # error "GLM error: A different version of GLM is already included. Define GLM_FORCE_IGNORE_VERSION before including GLM headers to ignore this error." #elif GLM_SETUP_INCLUDED == GLM_VERSION /////////////////////////////////////////////////////////////////////////////////// // Messages #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_DISPLAYED) # define GLM_MESSAGE_DISPLAYED # define GLM_STR_HELPER(x) #x # define GLM_STR(x) GLM_STR_HELPER(x) // Report GLM version # pragma message (GLM_STR(GLM_VERSION_MESSAGE)) // Report C++ language # if (GLM_LANG & GLM_LANG_CXX2A_FLAG) && (GLM_LANG & GLM_LANG_EXT) # pragma message("GLM: C++ 2A with extensions") # elif (GLM_LANG & GLM_LANG_CXX2A_FLAG) # pragma message("GLM: C++ 2A") # elif (GLM_LANG & GLM_LANG_CXX17_FLAG) && (GLM_LANG & GLM_LANG_EXT) # pragma message("GLM: C++ 17 with extensions") # elif (GLM_LANG & GLM_LANG_CXX17_FLAG) # pragma message("GLM: C++ 17") # elif (GLM_LANG & GLM_LANG_CXX14_FLAG) && (GLM_LANG & GLM_LANG_EXT) # pragma message("GLM: C++ 14 with extensions") # elif (GLM_LANG & GLM_LANG_CXX14_FLAG) # pragma message("GLM: C++ 14") # elif (GLM_LANG & GLM_LANG_CXX11_FLAG) && (GLM_LANG & GLM_LANG_EXT) # pragma message("GLM: C++ 11 with extensions") # elif (GLM_LANG & GLM_LANG_CXX11_FLAG) # pragma message("GLM: C++ 11") # elif (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_LANG & GLM_LANG_EXT) # pragma message("GLM: C++ 0x with extensions") # elif (GLM_LANG & GLM_LANG_CXX0X_FLAG) # pragma message("GLM: C++ 0x") # elif (GLM_LANG & GLM_LANG_CXX03_FLAG) && (GLM_LANG & GLM_LANG_EXT) # pragma message("GLM: C++ 03 with extensions") # elif (GLM_LANG & GLM_LANG_CXX03_FLAG) # pragma message("GLM: C++ 03") # elif (GLM_LANG & GLM_LANG_CXX98_FLAG) && (GLM_LANG & GLM_LANG_EXT) # pragma message("GLM: C++ 98 with extensions") # elif (GLM_LANG & GLM_LANG_CXX98_FLAG) # pragma message("GLM: C++ 98") # else # pragma message("GLM: C++ language undetected") # endif//GLM_LANG // Report compiler detection # if GLM_COMPILER & GLM_COMPILER_CUDA # pragma message("GLM: CUDA compiler detected") # elif GLM_COMPILER & GLM_COMPILER_VC # pragma message("GLM: Visual C++ compiler detected") # elif GLM_COMPILER & GLM_COMPILER_CLANG # pragma message("GLM: Clang compiler detected") # elif GLM_COMPILER & GLM_COMPILER_INTEL # pragma message("GLM: Intel Compiler detected") # elif GLM_COMPILER & GLM_COMPILER_GCC # pragma message("GLM: GCC compiler detected") # else # pragma message("GLM: Compiler not detected") # endif // Report build target # if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: x86 64 bits with AVX2 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_AVX2_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: x86 32 bits with AVX2 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_AVX_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: x86 64 bits with AVX instruction set build target") # elif (GLM_ARCH & GLM_ARCH_AVX_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: x86 32 bits with AVX instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSE42_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: x86 64 bits with SSE4.2 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSE42_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: x86 32 bits with SSE4.2 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSE41_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: x86 64 bits with SSE4.1 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSE41_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: x86 32 bits with SSE4.1 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSSE3_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: x86 64 bits with SSSE3 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSSE3_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: x86 32 bits with SSSE3 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSE3_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: x86 64 bits with SSE3 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSE3_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: x86 32 bits with SSE3 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSE2_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: x86 64 bits with SSE2 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_SSE2_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: x86 32 bits with SSE2 instruction set build target") # elif (GLM_ARCH & GLM_ARCH_X86_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: x86 64 bits build target") # elif (GLM_ARCH & GLM_ARCH_X86_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: x86 32 bits build target") # elif (GLM_ARCH & GLM_ARCH_NEON_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: ARM 64 bits with Neon instruction set build target") # elif (GLM_ARCH & GLM_ARCH_NEON_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: ARM 32 bits with Neon instruction set build target") # elif (GLM_ARCH & GLM_ARCH_ARM_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: ARM 64 bits build target") # elif (GLM_ARCH & GLM_ARCH_ARM_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: ARM 32 bits build target") # elif (GLM_ARCH & GLM_ARCH_MIPS_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: MIPS 64 bits build target") # elif (GLM_ARCH & GLM_ARCH_MIPS_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: MIPS 32 bits build target") # elif (GLM_ARCH & GLM_ARCH_PPC_BIT) && (GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: PowerPC 64 bits build target") # elif (GLM_ARCH & GLM_ARCH_PPC_BIT) && (GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: PowerPC 32 bits build target") # else # pragma message("GLM: Unknown build target") # endif//GLM_ARCH // Report platform name # if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO) # pragma message("GLM: QNX platform detected") //# elif(GLM_PLATFORM & GLM_PLATFORM_IOS) //# pragma message("GLM: iOS platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_APPLE) # pragma message("GLM: Apple platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_WINCE) # pragma message("GLM: WinCE platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_WINDOWS) # pragma message("GLM: Windows platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL) # pragma message("GLM: Native Client detected") # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) # pragma message("GLM: Android platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_LINUX) # pragma message("GLM: Linux platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_UNIX) # pragma message("GLM: UNIX platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN) # pragma message("GLM: platform unknown") # else # pragma message("GLM: platform not detected") # endif // Report whether only xyzw component are used # if defined GLM_FORCE_XYZW_ONLY # pragma message("GLM: GLM_FORCE_XYZW_ONLY is defined. Only x, y, z and w component are available in vector type. This define disables swizzle operators and SIMD instruction sets.") # endif // Report swizzle operator support # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR # pragma message("GLM: GLM_FORCE_SWIZZLE is defined, swizzling operators enabled.") # elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION # pragma message("GLM: GLM_FORCE_SWIZZLE is defined, swizzling functions enabled. Enable compiler C++ language extensions to enable swizzle operators.") # else # pragma message("GLM: GLM_FORCE_SWIZZLE is undefined. swizzling functions or operators are disabled.") # endif // Report .length() type # if GLM_CONFIG_LENGTH_TYPE == GLM_LENGTH_SIZE_T # pragma message("GLM: GLM_FORCE_SIZE_T_LENGTH is defined. .length() returns a glm::length_t, a typedef of std::size_t.") # else # pragma message("GLM: GLM_FORCE_SIZE_T_LENGTH is undefined. .length() returns a glm::length_t, a typedef of int following GLSL.") # endif # if GLM_CONFIG_UNRESTRICTED_GENTYPE == GLM_ENABLE # pragma message("GLM: GLM_FORCE_UNRESTRICTED_GENTYPE is defined. Removes GLSL restrictions on valid function genTypes.") # else # pragma message("GLM: GLM_FORCE_UNRESTRICTED_GENTYPE is undefined. Follows strictly GLSL on valid function genTypes.") # endif # if GLM_SILENT_WARNINGS == GLM_ENABLE # pragma message("GLM: GLM_FORCE_SILENT_WARNINGS is defined. Ignores C++ warnings from using C++ language extensions.") # else # pragma message("GLM: GLM_FORCE_SILENT_WARNINGS is undefined. Shows C++ warnings from using C++ language extensions.") # endif # ifdef GLM_FORCE_SINGLE_ONLY # pragma message("GLM: GLM_FORCE_SINGLE_ONLY is defined. Using only single precision floating-point types.") # endif # if defined(GLM_FORCE_ALIGNED_GENTYPES) && (GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE) # undef GLM_FORCE_ALIGNED_GENTYPES # pragma message("GLM: GLM_FORCE_ALIGNED_GENTYPES is defined, allowing aligned types. This prevents the use of C++ constexpr.") # elif defined(GLM_FORCE_ALIGNED_GENTYPES) && (GLM_CONFIG_ALIGNED_GENTYPES == GLM_DISABLE) # undef GLM_FORCE_ALIGNED_GENTYPES # pragma message("GLM: GLM_FORCE_ALIGNED_GENTYPES is defined but is disabled. It requires C++11 and language extensions.") # endif # if defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES) # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_DISABLE # undef GLM_FORCE_DEFAULT_ALIGNED_GENTYPES # pragma message("GLM: GLM_FORCE_DEFAULT_ALIGNED_GENTYPES is defined but is disabled. It requires C++11 and language extensions.") # elif GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE # pragma message("GLM: GLM_FORCE_DEFAULT_ALIGNED_GENTYPES is defined. All gentypes (e.g. vec3) will be aligned and padded by default.") # endif # endif # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT # pragma message("GLM: GLM_FORCE_DEPTH_ZERO_TO_ONE is defined. Using zero to one depth clip space.") # else # pragma message("GLM: GLM_FORCE_DEPTH_ZERO_TO_ONE is undefined. Using negative one to one depth clip space.") # endif # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT # pragma message("GLM: GLM_FORCE_LEFT_HANDED is defined. Using left handed coordinate system.") # else # pragma message("GLM: GLM_FORCE_LEFT_HANDED is undefined. Using right handed coordinate system.") # endif #endif//GLM_MESSAGES #endif//GLM_SETUP_INCLUDED ================================================ FILE: android/src/glm/detail/type_float.hpp ================================================ #pragma once #include "setup.hpp" #if GLM_COMPILER == GLM_COMPILER_VC12 # pragma warning(push) # pragma warning(disable: 4512) // assignment operator could not be generated #endif namespace glm{ namespace detail { template union float_t {}; // https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ template <> union float_t { typedef int int_type; typedef float float_type; GLM_CONSTEXPR float_t(float_type Num = 0.0f) : f(Num) {} GLM_CONSTEXPR float_t& operator=(float_t const& x) { f = x.f; return *this; } // Portable extraction of components. GLM_CONSTEXPR bool negative() const { return i < 0; } GLM_CONSTEXPR int_type mantissa() const { return i & ((1 << 23) - 1); } GLM_CONSTEXPR int_type exponent() const { return (i >> 23) & ((1 << 8) - 1); } int_type i; float_type f; }; template <> union float_t { typedef detail::int64 int_type; typedef double float_type; GLM_CONSTEXPR float_t(float_type Num = static_cast(0)) : f(Num) {} GLM_CONSTEXPR float_t& operator=(float_t const& x) { f = x.f; return *this; } // Portable extraction of components. GLM_CONSTEXPR bool negative() const { return i < 0; } GLM_CONSTEXPR int_type mantissa() const { return i & ((int_type(1) << 52) - 1); } GLM_CONSTEXPR int_type exponent() const { return (i >> 52) & ((int_type(1) << 11) - 1); } int_type i; float_type f; }; }//namespace detail }//namespace glm #if GLM_COMPILER == GLM_COMPILER_VC12 # pragma warning(pop) #endif ================================================ FILE: android/src/glm/detail/type_half.hpp ================================================ #pragma once #include "setup.hpp" namespace glm{ namespace detail { typedef short hdata; GLM_FUNC_DECL float toFloat32(hdata value); GLM_FUNC_DECL hdata toFloat16(float const& value); }//namespace detail }//namespace glm #include "type_half.inl" ================================================ FILE: android/src/glm/detail/type_half.inl ================================================ namespace glm{ namespace detail { GLM_FUNC_QUALIFIER float overflow() { volatile float f = 1e10; for(int i = 0; i < 10; ++i) f *= f; // this will overflow before the for loop terminates return f; } union uif32 { GLM_FUNC_QUALIFIER uif32() : i(0) {} GLM_FUNC_QUALIFIER uif32(float f_) : f(f_) {} GLM_FUNC_QUALIFIER uif32(unsigned int i_) : i(i_) {} float f; unsigned int i; }; GLM_FUNC_QUALIFIER float toFloat32(hdata value) { int s = (value >> 15) & 0x00000001; int e = (value >> 10) & 0x0000001f; int m = value & 0x000003ff; if(e == 0) { if(m == 0) { // // Plus or minus zero // detail::uif32 result; result.i = static_cast(s << 31); return result.f; } else { // // Denormalized number -- renormalize it // while(!(m & 0x00000400)) { m <<= 1; e -= 1; } e += 1; m &= ~0x00000400; } } else if(e == 31) { if(m == 0) { // // Positive or negative infinity // uif32 result; result.i = static_cast((s << 31) | 0x7f800000); return result.f; } else { // // Nan -- preserve sign and significand bits // uif32 result; result.i = static_cast((s << 31) | 0x7f800000 | (m << 13)); return result.f; } } // // Normalized number // e = e + (127 - 15); m = m << 13; // // Assemble s, e and m. // uif32 Result; Result.i = static_cast((s << 31) | (e << 23) | m); return Result.f; } GLM_FUNC_QUALIFIER hdata toFloat16(float const& f) { uif32 Entry; Entry.f = f; int i = static_cast(Entry.i); // // Our floating point number, f, is represented by the bit // pattern in integer i. Disassemble that bit pattern into // the sign, s, the exponent, e, and the significand, m. // Shift s into the position where it will go in the // resulting half number. // Adjust e, accounting for the different exponent bias // of float and half (127 versus 15). // int s = (i >> 16) & 0x00008000; int e = ((i >> 23) & 0x000000ff) - (127 - 15); int m = i & 0x007fffff; // // Now reassemble s, e and m into a half: // if(e <= 0) { if(e < -10) { // // E is less than -10. The absolute value of f is // less than half_MIN (f may be a small normalized // float, a denormalized float or a zero). // // We convert f to a half zero. // return hdata(s); } // // E is between -10 and 0. F is a normalized float, // whose magnitude is less than __half_NRM_MIN. // // We convert f to a denormalized half. // m = (m | 0x00800000) >> (1 - e); // // Round to nearest, round "0.5" up. // // Rounding may cause the significand to overflow and make // our number normalized. Because of the way a half's bits // are laid out, we don't have to treat this case separately; // the code below will handle it correctly. // if(m & 0x00001000) m += 0x00002000; // // Assemble the half from s, e (zero) and m. // return hdata(s | (m >> 13)); } else if(e == 0xff - (127 - 15)) { if(m == 0) { // // F is an infinity; convert f to a half // infinity with the same sign as f. // return hdata(s | 0x7c00); } else { // // F is a NAN; we produce a half NAN that preserves // the sign bit and the 10 leftmost bits of the // significand of f, with one exception: If the 10 // leftmost bits are all zero, the NAN would turn // into an infinity, so we have to set at least one // bit in the significand. // m >>= 13; return hdata(s | 0x7c00 | m | (m == 0)); } } else { // // E is greater than zero. F is a normalized float. // We try to convert f to a normalized half. // // // Round to nearest, round "0.5" up // if(m & 0x00001000) { m += 0x00002000; if(m & 0x00800000) { m = 0; // overflow in significand, e += 1; // adjust exponent } } // // Handle exponent overflow // if (e > 30) { overflow(); // Cause a hardware floating point overflow; return hdata(s | 0x7c00); // if this returns, the half becomes an } // infinity with the same sign as f. // // Assemble the half from s, e and m. // return hdata(s | (e << 10) | (m >> 13)); } } }//namespace detail }//namespace glm ================================================ FILE: android/src/glm/detail/type_mat2x2.hpp ================================================ /// @ref core /// @file glm/detail/type_mat2x2.hpp #pragma once #include "type_vec2.hpp" #include #include namespace glm { template struct mat<2, 2, T, Q> { typedef vec<2, T, Q> col_type; typedef vec<2, T, Q> row_type; typedef mat<2, 2, T, Q> type; typedef mat<2, 2, T, Q> transpose_type; typedef T value_type; private: col_type value[2]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 2, T, P> const& m); GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR mat( T const& x1, T const& y1, T const& x2, T const& y2); GLM_FUNC_DECL GLM_CONSTEXPR mat( col_type const& v1, col_type const& v2); // -- Conversions -- template GLM_FUNC_DECL GLM_CONSTEXPR mat( U const& x1, V const& y1, M const& x2, N const& y2); template GLM_FUNC_DECL GLM_CONSTEXPR mat( vec<2, U, Q> const& v1, vec<2, V, Q> const& v2); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- template GLM_FUNC_DECL mat<2, 2, T, Q> & operator=(mat<2, 2, U, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(mat<2, 2, U, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(mat<2, 2, U, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(mat<2, 2, U, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(U s); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(mat<2, 2, U, Q> const& m); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<2, 2, T, Q> & operator++ (); GLM_FUNC_DECL mat<2, 2, T, Q> & operator-- (); GLM_FUNC_DECL mat<2, 2, T, Q> operator++(int); GLM_FUNC_DECL mat<2, 2, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator*(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator*(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); } //namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat2x2.inl" #endif ================================================ FILE: android/src/glm/detail/type_mat2x2.inl ================================================ #include "../matrix.hpp" namespace glm { // -- Constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat() # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST : value{col_type(1, 0), col_type(0, 1)} # endif { # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION this->value[0] = col_type(1, 0); this->value[1] = col_type(0, 1); # endif } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, T, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{m[0], m[1]} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(T scalar) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(scalar, 0), col_type(0, scalar)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(scalar, 0); this->value[1] = col_type(0, scalar); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat ( T const& x0, T const& y0, T const& x1, T const& y1 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0), col_type(x1, y1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0); this->value[1] = col_type(x1, y1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(col_type const& v0, col_type const& v1) # if GLM_HAS_INITIALIZER_LISTS : value{v0, v1} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = v0; this->value[1] = v1; # endif } // -- Conversion constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat ( X1 const& x1, Y1 const& y1, X2 const& x2, Y2 const& y2 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(static_cast(x1), value_type(y1)), col_type(static_cast(x2), value_type(y2)) } # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(static_cast(x1), value_type(y1)); this->value[1] = col_type(static_cast(x2), value_type(y2)); # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v1), col_type(v2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v1); this->value[1] = col_type(v2); # endif } // -- mat2x2 matrix conversions -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, U, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 2, T, Q>::col_type const& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator=(mat<2, 2, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(U scalar) { this->value[0] += scalar; this->value[1] += scalar; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(mat<2, 2, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(U scalar) { this->value[0] -= scalar; this->value[1] -= scalar; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(mat<2, 2, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(U scalar) { this->value[0] *= scalar; this->value[1] *= scalar; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(mat<2, 2, U, Q> const& m) { return (*this = *this * m); } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(U scalar) { this->value[0] /= scalar; this->value[1] /= scalar; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(mat<2, 2, U, Q> const& m) { return *this *= inverse(m); } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator--() { --this->value[0]; --this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator++(int) { mat<2, 2, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator--(int) { mat<2, 2, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( -m[0], -m[1]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar) { return mat<2, 2, T, Q>( m[0] + scalar, m[1] + scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( m[0] + scalar, m[1] + scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 2, T, Q>( m1[0] + m2[0], m1[1] + m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar) { return mat<2, 2, T, Q>( m[0] - scalar, m[1] - scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( scalar - m[0], scalar - m[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 2, T, Q>( m1[0] - m2[0], m1[1] - m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar) { return mat<2, 2, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator* ( mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v ) { return vec<2, T, Q>( m[0][0] * v.x + m[1][0] * v.y, m[0][1] * v.x + m[1][1] * v.y); } template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator* ( typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m ) { return vec<2, T, Q>( v.x * m[0][0] + v.y * m[0][1], v.x * m[1][0] + v.y * m[1][1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar) { return mat<2, 2, T, Q>( m[0] / scalar, m[1] / scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( scalar / m[0], scalar / m[1]); } template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v) { return inverse(m) * v; } template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m) { return v * inverse(m); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { mat<2, 2, T, Q> m1_copy(m1); return m1_copy /= m2; } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]); } } //namespace glm ================================================ FILE: android/src/glm/detail/type_mat2x3.hpp ================================================ /// @ref core /// @file glm/detail/type_mat2x3.hpp #pragma once #include "type_vec2.hpp" #include "type_vec3.hpp" #include #include namespace glm { template struct mat<2, 3, T, Q> { typedef vec<3, T, Q> col_type; typedef vec<2, T, Q> row_type; typedef mat<2, 3, T, Q> type; typedef mat<3, 2, T, Q> transpose_type; typedef T value_type; private: col_type value[2]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 3, T, P> const& m); GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR mat( T x0, T y0, T z0, T x1, T y1, T z1); GLM_FUNC_DECL GLM_CONSTEXPR mat( col_type const& v0, col_type const& v1); // -- Conversions -- template GLM_FUNC_DECL GLM_CONSTEXPR mat( X1 x1, Y1 y1, Z1 z1, X2 x2, Y2 y2, Z2 z2); template GLM_FUNC_DECL GLM_CONSTEXPR mat( vec<3, U, Q> const& v1, vec<3, V, Q> const& v2); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- template GLM_FUNC_DECL mat<2, 3, T, Q> & operator=(mat<2, 3, U, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(mat<2, 3, U, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(mat<2, 3, U, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<2, 3, T, Q> & operator++ (); GLM_FUNC_DECL mat<2, 3, T, Q> & operator-- (); GLM_FUNC_DECL mat<2, 3, T, Q> operator++(int); GLM_FUNC_DECL mat<2, 3, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m); template GLM_FUNC_DECL typename mat<2, 3, T, Q>::col_type operator*(mat<2, 3, T, Q> const& m, typename mat<2, 3, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<2, 3, T, Q>::row_type operator*(typename mat<2, 3, T, Q>::col_type const& v, mat<2, 3, T, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat2x3.inl" #endif ================================================ FILE: android/src/glm/detail/type_mat2x3.inl ================================================ namespace glm { // -- Constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat() # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST : value{col_type(1, 0, 0), col_type(0, 1, 0)} # endif { # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION this->value[0] = col_type(1, 0, 0); this->value[1] = col_type(0, 1, 0); # endif } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, T, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{m.value[0], m.value[1]} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m.value[0]; this->value[1] = m.value[1]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(T scalar) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(scalar, 0, 0), col_type(0, scalar, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(scalar, 0, 0); this->value[1] = col_type(0, scalar, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat ( T x0, T y0, T z0, T x1, T y1, T z1 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0, z0), col_type(x1, y1, z1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0, z0); this->value[1] = col_type(x1, y1, z1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(col_type const& v0, col_type const& v1) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v0); this->value[1] = col_type(v1); # endif } // -- Conversion constructors -- template template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2> GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat ( X1 x1, Y1 y1, Z1 z1, X2 x2, Y2 y2, Z2 z2 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x1, y1, z1), col_type(x2, y2, z2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x1, y1, z1); this->value[1] = col_type(x2, y2, z2); # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v1), col_type(v2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v1); this->value[1] = col_type(v2); # endif } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, U, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type & mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 3, T, Q>::col_type const& mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator=(mat<2, 3, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator+=(mat<2, 3, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(mat<2, 3, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator--() { --this->value[0]; --this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator++(int) { mat<2, 3, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator--(int) { mat<2, 3, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m) { return mat<2, 3, T, Q>( -m[0], -m[1]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar) { return mat<2, 3, T, Q>( m[0] + scalar, m[1] + scalar); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0] + m2[0], m1[1] + m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar) { return mat<2, 3, T, Q>( m[0] - scalar, m[1] - scalar); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0] - m2[0], m1[1] - m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar) { return mat<2, 3, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m) { return mat<2, 3, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type operator* ( mat<2, 3, T, Q> const& m, typename mat<2, 3, T, Q>::row_type const& v) { return typename mat<2, 3, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y, m[0][1] * v.x + m[1][1] * v.y, m[0][2] * v.x + m[1][2] * v.y); } template GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::row_type operator* ( typename mat<2, 3, T, Q>::col_type const& v, mat<2, 3, T, Q> const& m) { return typename mat<2, 3, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2], v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { T SrcA00 = m1[0][0]; T SrcA01 = m1[0][1]; T SrcA02 = m1[0][2]; T SrcA10 = m1[1][0]; T SrcA11 = m1[1][1]; T SrcA12 = m1[1][2]; T SrcB00 = m2[0][0]; T SrcB01 = m2[0][1]; T SrcB10 = m2[1][0]; T SrcB11 = m2[1][1]; T SrcB20 = m2[2][0]; T SrcB21 = m2[2][1]; mat<3, 3, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21; return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1], m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar) { return mat<2, 3, T, Q>( m[0] / scalar, m[1] / scalar); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m) { return mat<2, 3, T, Q>( scalar / m[0], scalar / m[1]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]); } } //namespace glm ================================================ FILE: android/src/glm/detail/type_mat2x4.hpp ================================================ /// @ref core /// @file glm/detail/type_mat2x4.hpp #pragma once #include "type_vec2.hpp" #include "type_vec4.hpp" #include #include namespace glm { template struct mat<2, 4, T, Q> { typedef vec<4, T, Q> col_type; typedef vec<2, T, Q> row_type; typedef mat<2, 4, T, Q> type; typedef mat<4, 2, T, Q> transpose_type; typedef T value_type; private: col_type value[2]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 4, T, P> const& m); GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR mat( T x0, T y0, T z0, T w0, T x1, T y1, T z1, T w1); GLM_FUNC_DECL GLM_CONSTEXPR mat( col_type const& v0, col_type const& v1); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2> GLM_FUNC_DECL GLM_CONSTEXPR mat( X1 x1, Y1 y1, Z1 z1, W1 w1, X2 x2, Y2 y2, Z2 z2, W2 w2); template GLM_FUNC_DECL GLM_CONSTEXPR mat( vec<4, U, Q> const& v1, vec<4, V, Q> const& v2); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- template GLM_FUNC_DECL mat<2, 4, T, Q> & operator=(mat<2, 4, U, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(mat<2, 4, U, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(mat<2, 4, U, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<2, 4, T, Q> & operator++ (); GLM_FUNC_DECL mat<2, 4, T, Q> & operator-- (); GLM_FUNC_DECL mat<2, 4, T, Q> operator++(int); GLM_FUNC_DECL mat<2, 4, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m); template GLM_FUNC_DECL typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat2x4.inl" #endif ================================================ FILE: android/src/glm/detail/type_mat2x4.inl ================================================ namespace glm { // -- Constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat() # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST : value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0)} # endif { # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION this->value[0] = col_type(1, 0, 0, 0); this->value[1] = col_type(0, 1, 0, 0); # endif } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, T, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{m[0], m[1]} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(T s) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(s, 0, 0, 0); this->value[1] = col_type(0, s, 0, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat ( T x0, T y0, T z0, T w0, T x1, T y1, T z1, T w1 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0, z0, w0), col_type(x1, y1, z1, w1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0, z0, w0); this->value[1] = col_type(x1, y1, z1, w1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(col_type const& v0, col_type const& v1) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = v0; this->value[1] = v1; # endif } // -- Conversion constructors -- template template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2> GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat ( X1 x1, Y1 y1, Z1 z1, W1 w1, X2 x2, Y2 y2, Z2 z2, W2 w2 ) # if GLM_HAS_INITIALIZER_LISTS : value{ col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x1, y1, z1, w1); this->value[1] = col_type(x2, y2, z2, w2); # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v1), col_type(v2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v1); this->value[1] = col_type(v2); # endif } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, U, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); # endif } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type & mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 4, T, Q>::col_type const& mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator=(mat<2, 4, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(mat<2, 4, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(mat<2, 4, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> & mat<2, 4, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator--() { --this->value[0]; --this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator++(int) { mat<2, 4, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator--(int) { mat<2, 4, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m) { return mat<2, 4, T, Q>( -m[0], -m[1]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar) { return mat<2, 4, T, Q>( m[0] + scalar, m[1] + scalar); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0] + m2[0], m1[1] + m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar) { return mat<2, 4, T, Q>( m[0] - scalar, m[1] - scalar); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0] - m2[0], m1[1] - m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar) { return mat<2, 4, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m) { return mat<2, 4, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v) { return typename mat<2, 4, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y, m[0][1] * v.x + m[1][1] * v.y, m[0][2] * v.x + m[1][2] * v.y, m[0][3] * v.x + m[1][3] * v.y); } template GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m) { return typename mat<2, 4, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3], v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { T SrcA00 = m1[0][0]; T SrcA01 = m1[0][1]; T SrcA02 = m1[0][2]; T SrcA03 = m1[0][3]; T SrcA10 = m1[1][0]; T SrcA11 = m1[1][1]; T SrcA12 = m1[1][2]; T SrcA13 = m1[1][3]; T SrcB00 = m2[0][0]; T SrcB01 = m2[0][1]; T SrcB10 = m2[1][0]; T SrcB11 = m2[1][1]; T SrcB20 = m2[2][0]; T SrcB21 = m2[2][1]; T SrcB30 = m2[3][0]; T SrcB31 = m2[3][1]; mat<4, 4, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01; Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11; Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21; Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21; Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31; Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31; Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31; Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31; return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1], m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar) { return mat<2, 4, T, Q>( m[0] / scalar, m[1] / scalar); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m) { return mat<2, 4, T, Q>( scalar / m[0], scalar / m[1]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]); } } //namespace glm ================================================ FILE: android/src/glm/detail/type_mat3x2.hpp ================================================ /// @ref core /// @file glm/detail/type_mat3x2.hpp #pragma once #include "type_vec2.hpp" #include "type_vec3.hpp" #include #include namespace glm { template struct mat<3, 2, T, Q> { typedef vec<2, T, Q> col_type; typedef vec<3, T, Q> row_type; typedef mat<3, 2, T, Q> type; typedef mat<2, 3, T, Q> transpose_type; typedef T value_type; private: col_type value[3]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 2, T, P> const& m); GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR mat( T x0, T y0, T x1, T y1, T x2, T y2); GLM_FUNC_DECL GLM_CONSTEXPR mat( col_type const& v0, col_type const& v1, col_type const& v2); // -- Conversions -- template< typename X1, typename Y1, typename X2, typename Y2, typename X3, typename Y3> GLM_FUNC_DECL GLM_CONSTEXPR mat( X1 x1, Y1 y1, X2 x2, Y2 y2, X3 x3, Y3 y3); template GLM_FUNC_DECL GLM_CONSTEXPR mat( vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- template GLM_FUNC_DECL mat<3, 2, T, Q> & operator=(mat<3, 2, U, Q> const& m); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(mat<3, 2, U, Q> const& m); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(mat<3, 2, U, Q> const& m); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<3, 2, T, Q> & operator++ (); GLM_FUNC_DECL mat<3, 2, T, Q> & operator-- (); GLM_FUNC_DECL mat<3, 2, T, Q> operator++(int); GLM_FUNC_DECL mat<3, 2, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m); template GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m); template GLM_FUNC_DECL typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat3x2.inl" #endif ================================================ FILE: android/src/glm/detail/type_mat3x2.inl ================================================ namespace glm { // -- Constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat() # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST : value{col_type(1, 0), col_type(0, 1), col_type(0, 0)} # endif { # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION this->value[0] = col_type(1, 0); this->value[1] = col_type(0, 1); this->value[2] = col_type(0, 0); # endif } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, T, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(T s) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(s, 0), col_type(0, s), col_type(0, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(s, 0); this->value[1] = col_type(0, s); this->value[2] = col_type(0, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat ( T x0, T y0, T x1, T y1, T x2, T y2 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0); this->value[1] = col_type(x1, y1); this->value[2] = col_type(x2, y2); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1), col_type(v2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; # endif } // -- Conversion constructors -- template template< typename X0, typename Y0, typename X1, typename Y1, typename X2, typename Y2> GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat ( X0 x0, Y0 y0, X1 x1, Y1 y1, X2 x2, Y2 y2 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0); this->value[1] = col_type(x1, y1); this->value[2] = col_type(x2, y2); # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1), col_type(v2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v0); this->value[1] = col_type(v1); this->value[2] = col_type(v2); # endif } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, U, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type & mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 2, T, Q>::col_type const& mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator=(mat<3, 2, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(mat<3, 2, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(mat<3, 2, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> & mat<3, 2, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator++(int) { mat<3, 2, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator--(int) { mat<3, 2, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m) { return mat<3, 2, T, Q>( -m[0], -m[1], -m[2]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar) { return mat<3, 2, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar) { return mat<3, 2, T, Q>( m[0] - scalar, m[1] - scalar, m[2] - scalar); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar) { return mat<3, 2, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m) { return mat<3, 2, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v) { return typename mat<3, 2, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z); } template GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m) { return typename mat<3, 2, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1], v.x * m[1][0] + v.y * m[1][1], v.x * m[2][0] + v.y * m[2][1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { const T SrcA00 = m1[0][0]; const T SrcA01 = m1[0][1]; const T SrcA10 = m1[1][0]; const T SrcA11 = m1[1][1]; const T SrcA20 = m1[2][0]; const T SrcA21 = m1[2][1]; const T SrcB00 = m2[0][0]; const T SrcB01 = m2[0][1]; const T SrcB02 = m2[0][2]; const T SrcB10 = m2[1][0]; const T SrcB11 = m2[1][1]; const T SrcB12 = m2[1][2]; mat<2, 2, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12; return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar) { return mat<3, 2, T, Q>( m[0] / scalar, m[1] / scalar, m[2] / scalar); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m) { return mat<3, 2, T, Q>( scalar / m[0], scalar / m[1], scalar / m[2]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); } } //namespace glm ================================================ FILE: android/src/glm/detail/type_mat3x3.hpp ================================================ /// @ref core /// @file glm/detail/type_mat3x3.hpp #pragma once #include "type_vec3.hpp" #include #include namespace glm { template struct mat<3, 3, T, Q> { typedef vec<3, T, Q> col_type; typedef vec<3, T, Q> row_type; typedef mat<3, 3, T, Q> type; typedef mat<3, 3, T, Q> transpose_type; typedef T value_type; private: col_type value[3]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 3, T, P> const& m); GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR mat( T x0, T y0, T z0, T x1, T y1, T z1, T x2, T y2, T z2); GLM_FUNC_DECL GLM_CONSTEXPR mat( col_type const& v0, col_type const& v1, col_type const& v2); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, typename X3, typename Y3, typename Z3> GLM_FUNC_DECL GLM_CONSTEXPR mat( X1 x1, Y1 y1, Z1 z1, X2 x2, Y2 y2, Z2 z2, X3 x3, Y3 y3, Z3 z3); template GLM_FUNC_DECL GLM_CONSTEXPR mat( vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- template GLM_FUNC_DECL mat<3, 3, T, Q> & operator=(mat<3, 3, U, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(mat<3, 3, U, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(mat<3, 3, U, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(mat<3, 3, U, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(U s); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(mat<3, 3, U, Q> const& m); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<3, 3, T, Q> & operator++(); GLM_FUNC_DECL mat<3, 3, T, Q> & operator--(); GLM_FUNC_DECL mat<3, 3, T, Q> operator++(int); GLM_FUNC_DECL mat<3, 3, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); // -- Boolean operators -- template GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat3x3.inl" #endif ================================================ FILE: android/src/glm/detail/type_mat3x3.inl ================================================ #include "../matrix.hpp" namespace glm { // -- Constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat() # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST : value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1)} # endif { # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION this->value[0] = col_type(1, 0, 0); this->value[1] = col_type(0, 1, 0); this->value[2] = col_type(0, 0, 1); # endif } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, T, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(T s) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(s, 0, 0); this->value[1] = col_type(0, s, 0); this->value[2] = col_type(0, 0, s); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat ( T x0, T y0, T z0, T x1, T y1, T z1, T x2, T y2, T z2 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0, z0); this->value[1] = col_type(x1, y1, z1); this->value[2] = col_type(x2, y2, z2); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1), col_type(v2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v0); this->value[1] = col_type(v1); this->value[2] = col_type(v2); # endif } // -- Conversion constructors -- template template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, typename X3, typename Y3, typename Z3> GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat ( X1 x1, Y1 y1, Z1 z1, X2 x2, Y2 y2, Z2 z2, X3 x3, Y3 y3, Z3 z3 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x1, y1, z1); this->value[1] = col_type(x2, y2, z2); this->value[2] = col_type(x3, y3, z3); # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v1), col_type(v2), col_type(v3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v1); this->value[1] = col_type(v2); this->value[2] = col_type(v3); # endif } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, U, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type & mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 3, T, Q>::col_type const& mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator=(mat<3, 3, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(mat<3, 3, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(mat<3, 3, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(mat<3, 3, U, Q> const& m) { return (*this = *this * m); } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(mat<3, 3, U, Q> const& m) { return *this *= inverse(m); } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator++(int) { mat<3, 3, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator--(int) { mat<3, 3, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( -m[0], -m[1], -m[2]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar) { return mat<3, 3, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return mat<3, 3, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar) { return mat<3, 3, T, Q>( m[0] - scalar, m[1] - scalar, m[2] - scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( scalar - m[0], scalar - m[1], scalar - m[2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return mat<3, 3, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar) { return mat<3, 3, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v) { return typename mat<3, 3, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z, m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z); } template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m) { return typename mat<3, 3, T, Q>::row_type( m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z, m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z, m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { T const SrcA00 = m1[0][0]; T const SrcA01 = m1[0][1]; T const SrcA02 = m1[0][2]; T const SrcA10 = m1[1][0]; T const SrcA11 = m1[1][1]; T const SrcA12 = m1[1][2]; T const SrcA20 = m1[2][0]; T const SrcA21 = m1[2][1]; T const SrcA22 = m1[2][2]; T const SrcB00 = m2[0][0]; T const SrcB01 = m2[0][1]; T const SrcB02 = m2[0][2]; T const SrcB10 = m2[1][0]; T const SrcB11 = m2[1][1]; T const SrcB12 = m2[1][2]; T const SrcB20 = m2[2][0]; T const SrcB21 = m2[2][1]; T const SrcB22 = m2[2][2]; mat<3, 3, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22; return Result; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2], m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m, T scalar) { return mat<3, 3, T, Q>( m[0] / scalar, m[1] / scalar, m[2] / scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( scalar / m[0], scalar / m[1], scalar / m[2]); } template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v) { return inverse(m) * v; } template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m) { return v * inverse(m); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { mat<3, 3, T, Q> m1_copy(m1); return m1_copy /= m2; } // -- Boolean operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); } } //namespace glm ================================================ FILE: android/src/glm/detail/type_mat3x4.hpp ================================================ /// @ref core /// @file glm/detail/type_mat3x4.hpp #pragma once #include "type_vec3.hpp" #include "type_vec4.hpp" #include #include namespace glm { template struct mat<3, 4, T, Q> { typedef vec<4, T, Q> col_type; typedef vec<3, T, Q> row_type; typedef mat<3, 4, T, Q> type; typedef mat<4, 3, T, Q> transpose_type; typedef T value_type; private: col_type value[3]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 4, T, P> const& m); GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR mat( T x0, T y0, T z0, T w0, T x1, T y1, T z1, T w1, T x2, T y2, T z2, T w2); GLM_FUNC_DECL GLM_CONSTEXPR mat( col_type const& v0, col_type const& v1, col_type const& v2); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2, typename X3, typename Y3, typename Z3, typename W3> GLM_FUNC_DECL GLM_CONSTEXPR mat( X1 x1, Y1 y1, Z1 z1, W1 w1, X2 x2, Y2 y2, Z2 z2, W2 w2, X3 x3, Y3 y3, Z3 z3, W3 w3); template GLM_FUNC_DECL GLM_CONSTEXPR mat( vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- template GLM_FUNC_DECL mat<3, 4, T, Q> & operator=(mat<3, 4, U, Q> const& m); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(mat<3, 4, U, Q> const& m); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(mat<3, 4, U, Q> const& m); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<3, 4, T, Q> & operator++(); GLM_FUNC_DECL mat<3, 4, T, Q> & operator--(); GLM_FUNC_DECL mat<3, 4, T, Q> operator++(int); GLM_FUNC_DECL mat<3, 4, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m); template GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m); template GLM_FUNC_DECL typename mat<3, 4, T, Q>::col_type operator*(mat<3, 4, T, Q> const& m, typename mat<3, 4, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<3, 4, T, Q>::row_type operator*(typename mat<3, 4, T, Q>::col_type const& v, mat<3, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat3x4.inl" #endif ================================================ FILE: android/src/glm/detail/type_mat3x4.inl ================================================ namespace glm { // -- Constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat() # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST : value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0)} # endif { # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION this->value[0] = col_type(1, 0, 0, 0); this->value[1] = col_type(0, 1, 0, 0); this->value[2] = col_type(0, 0, 1, 0); # endif } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, T, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(T s) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(s, 0, 0, 0); this->value[1] = col_type(0, s, 0, 0); this->value[2] = col_type(0, 0, s, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat ( T x0, T y0, T z0, T w0, T x1, T y1, T z1, T w1, T x2, T y2, T z2, T w2 ) # if GLM_HAS_INITIALIZER_LISTS : value{ col_type(x0, y0, z0, w0), col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0, z0, w0); this->value[1] = col_type(x1, y1, z1, w1); this->value[2] = col_type(x2, y2, z2, w2); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1), col_type(v2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; # endif } // -- Conversion constructors -- template template< typename X0, typename Y0, typename Z0, typename W0, typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2> GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat ( X0 x0, Y0 y0, Z0 z0, W0 w0, X1 x1, Y1 y1, Z1 z1, W1 w1, X2 x2, Y2 y2, Z2 z2, W2 w2 ) # if GLM_HAS_INITIALIZER_LISTS : value{ col_type(x0, y0, z0, w0), col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0, z0, w0); this->value[1] = col_type(x1, y1, z1, w1); this->value[2] = col_type(x2, y2, z2, w2); # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(vec<4, V1, Q> const& v0, vec<4, V2, Q> const& v1, vec<4, V3, Q> const& v2) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1), col_type(v2)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v0); this->value[1] = col_type(v1); this->value[2] = col_type(v2); # endif } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, U, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(0, 0, 1, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(0, 0, 1, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(m[2], 1, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0, 0, 1, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(m[2], 1, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 0); # endif } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type & mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 4, T, Q>::col_type const& mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator=(mat<3, 4, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(mat<3, 4, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(mat<3, 4, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> & mat<3, 4, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator++(int) { mat<3, 4, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator--(int) { mat<3, 4, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m) { return mat<3, 4, T, Q>( -m[0], -m[1], -m[2]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar) { return mat<3, 4, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m, T scalar) { return mat<3, 4, T, Q>( m[0] - scalar, m[1] - scalar, m[2] - scalar); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar) { return mat<3, 4, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m) { return mat<3, 4, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type operator* ( mat<3, 4, T, Q> const& m, typename mat<3, 4, T, Q>::row_type const& v ) { return typename mat<3, 4, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z, m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z, m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z); } template GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::row_type operator* ( typename mat<3, 4, T, Q>::col_type const& v, mat<3, 4, T, Q> const& m ) { return typename mat<3, 4, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3], v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3], v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { const T SrcA00 = m1[0][0]; const T SrcA01 = m1[0][1]; const T SrcA02 = m1[0][2]; const T SrcA03 = m1[0][3]; const T SrcA10 = m1[1][0]; const T SrcA11 = m1[1][1]; const T SrcA12 = m1[1][2]; const T SrcA13 = m1[1][3]; const T SrcA20 = m1[2][0]; const T SrcA21 = m1[2][1]; const T SrcA22 = m1[2][2]; const T SrcA23 = m1[2][3]; const T SrcB00 = m2[0][0]; const T SrcB01 = m2[0][1]; const T SrcB02 = m2[0][2]; const T SrcB10 = m2[1][0]; const T SrcB11 = m2[1][1]; const T SrcB12 = m2[1][2]; const T SrcB20 = m2[2][0]; const T SrcB21 = m2[2][1]; const T SrcB22 = m2[2][2]; const T SrcB30 = m2[3][0]; const T SrcB31 = m2[3][1]; const T SrcB32 = m2[3][2]; mat<4, 4, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02; Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12; Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22; Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22; Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32; Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32; Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32; Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32; return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2], m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m, T scalar) { return mat<3, 4, T, Q>( m[0] / scalar, m[1] / scalar, m[2] / scalar); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m) { return mat<3, 4, T, Q>( scalar / m[0], scalar / m[1], scalar / m[2]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); } } //namespace glm ================================================ FILE: android/src/glm/detail/type_mat4x2.hpp ================================================ /// @ref core /// @file glm/detail/type_mat4x2.hpp #pragma once #include "type_vec2.hpp" #include "type_vec4.hpp" #include #include namespace glm { template struct mat<4, 2, T, Q> { typedef vec<2, T, Q> col_type; typedef vec<4, T, Q> row_type; typedef mat<4, 2, T, Q> type; typedef mat<2, 4, T, Q> transpose_type; typedef T value_type; private: col_type value[4]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 2, T, P> const& m); GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR mat( T x0, T y0, T x1, T y1, T x2, T y2, T x3, T y3); GLM_FUNC_DECL GLM_CONSTEXPR mat( col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3); // -- Conversions -- template< typename X0, typename Y0, typename X1, typename Y1, typename X2, typename Y2, typename X3, typename Y3> GLM_FUNC_DECL GLM_CONSTEXPR mat( X0 x0, Y0 y0, X1 x1, Y1 y1, X2 x2, Y2 y2, X3 x3, Y3 y3); template GLM_FUNC_DECL GLM_CONSTEXPR mat( vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3, vec<2, V4, Q> const& v4); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x); // -- Unary arithmetic operators -- template GLM_FUNC_DECL mat<4, 2, T, Q> & operator=(mat<4, 2, U, Q> const& m); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(mat<4, 2, U, Q> const& m); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(mat<4, 2, U, Q> const& m); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<4, 2, T, Q> & operator++ (); GLM_FUNC_DECL mat<4, 2, T, Q> & operator-- (); GLM_FUNC_DECL mat<4, 2, T, Q> operator++(int); GLM_FUNC_DECL mat<4, 2, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m); template GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m); template GLM_FUNC_DECL typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat4x2.inl" #endif ================================================ FILE: android/src/glm/detail/type_mat4x2.inl ================================================ namespace glm { // -- Constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat() # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST : value{col_type(1, 0), col_type(0, 1), col_type(0, 0), col_type(0, 0)} # endif { # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION this->value[0] = col_type(1, 0); this->value[1] = col_type(0, 1); this->value[2] = col_type(0, 0); this->value[3] = col_type(0, 0); # endif } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, T, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(T s) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(s, 0), col_type(0, s), col_type(0, 0), col_type(0, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(s, 0); this->value[1] = col_type(0, s); this->value[2] = col_type(0, 0); this->value[3] = col_type(0, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat ( T x0, T y0, T x1, T y1, T x2, T y2, T x3, T y3 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0); this->value[1] = col_type(x1, y1); this->value[2] = col_type(x2, y2); this->value[3] = col_type(x3, y3); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; this->value[3] = v3; # endif } // -- Conversion constructors -- template template< typename X0, typename Y0, typename X1, typename Y1, typename X2, typename Y2, typename X3, typename Y3> GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat ( X0 x0, Y0 y0, X1 x1, Y1 y1, X2 x2, Y2 y2, X3 x3, Y3 y3 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0); this->value[1] = col_type(x1, y1); this->value[2] = col_type(x2, y2); this->value[3] = col_type(x3, y3); # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v0); this->value[1] = col_type(v1); this->value[2] = col_type(v2); this->value[3] = col_type(v3); # endif } // -- Conversion -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, U, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); # endif } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type & mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 2, T, Q>::col_type const& mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>& mat<4, 2, T, Q>::operator=(mat<4, 2, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; this->value[3] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(mat<4, 2, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; this->value[3] += m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; this->value[3] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(mat<4, 2, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; this->value[3] -= m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; this->value[3] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; this->value[3] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; ++this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; --this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator++(int) { mat<4, 2, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator--(int) { mat<4, 2, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m) { return mat<4, 2, T, Q>( -m[0], -m[1], -m[2], -m[3]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar) { return mat<4, 2, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar, m[3] + scalar); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar) { return mat<4, 2, T, Q>( m[0] - scalar, m[1] - scalar, m[2] - scalar, m[3] - scalar); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar) { return mat<4, 2, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar, m[3] * scalar); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m) { return mat<4, 2, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar, m[3] * scalar); } template GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v) { return typename mat<4, 2, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w); } template GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m) { return typename mat<4, 2, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1], v.x * m[1][0] + v.y * m[1][1], v.x * m[2][0] + v.y * m[2][1], v.x * m[3][0] + v.y * m[3][1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { T const SrcA00 = m1[0][0]; T const SrcA01 = m1[0][1]; T const SrcA10 = m1[1][0]; T const SrcA11 = m1[1][1]; T const SrcA20 = m1[2][0]; T const SrcA21 = m1[2][1]; T const SrcA30 = m1[3][0]; T const SrcA31 = m1[3][1]; T const SrcB00 = m2[0][0]; T const SrcB01 = m2[0][1]; T const SrcB02 = m2[0][2]; T const SrcB03 = m2[0][3]; T const SrcB10 = m2[1][0]; T const SrcB11 = m2[1][1]; T const SrcB12 = m2[1][2]; T const SrcB13 = m2[1][3]; mat<2, 2, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13; return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar) { return mat<4, 2, T, Q>( m[0] / scalar, m[1] / scalar, m[2] / scalar, m[3] / scalar); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m) { return mat<4, 2, T, Q>( scalar / m[0], scalar / m[1], scalar / m[2], scalar / m[3]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]); } } //namespace glm ================================================ FILE: android/src/glm/detail/type_mat4x3.hpp ================================================ /// @ref core /// @file glm/detail/type_mat4x3.hpp #pragma once #include "type_vec3.hpp" #include "type_vec4.hpp" #include #include namespace glm { template struct mat<4, 3, T, Q> { typedef vec<3, T, Q> col_type; typedef vec<4, T, Q> row_type; typedef mat<4, 3, T, Q> type; typedef mat<3, 4, T, Q> transpose_type; typedef T value_type; private: col_type value[4]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 3, T, P> const& m); GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T const& x); GLM_FUNC_DECL GLM_CONSTEXPR mat( T const& x0, T const& y0, T const& z0, T const& x1, T const& y1, T const& z1, T const& x2, T const& y2, T const& z2, T const& x3, T const& y3, T const& z3); GLM_FUNC_DECL GLM_CONSTEXPR mat( col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, typename X3, typename Y3, typename Z3, typename X4, typename Y4, typename Z4> GLM_FUNC_DECL GLM_CONSTEXPR mat( X1 const& x1, Y1 const& y1, Z1 const& z1, X2 const& x2, Y2 const& y2, Z2 const& z2, X3 const& x3, Y3 const& y3, Z3 const& z3, X4 const& x4, Y4 const& y4, Z4 const& z4); template GLM_FUNC_DECL GLM_CONSTEXPR mat( vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3, vec<3, V4, Q> const& v4); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x); // -- Unary arithmetic operators -- template GLM_FUNC_DECL mat<4, 3, T, Q> & operator=(mat<4, 3, U, Q> const& m); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(mat<4, 3, U, Q> const& m); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(mat<4, 3, U, Q> const& m); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<4, 3, T, Q>& operator++(); GLM_FUNC_DECL mat<4, 3, T, Q>& operator--(); GLM_FUNC_DECL mat<4, 3, T, Q> operator++(int); GLM_FUNC_DECL mat<4, 3, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m); template GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m); template GLM_FUNC_DECL typename mat<4, 3, T, Q>::col_type operator*(mat<4, 3, T, Q> const& m, typename mat<4, 3, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<4, 3, T, Q>::row_type operator*(typename mat<4, 3, T, Q>::col_type const& v, mat<4, 3, T, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat4x3.inl" #endif //GLM_EXTERNAL_TEMPLATE ================================================ FILE: android/src/glm/detail/type_mat4x3.inl ================================================ namespace glm { // -- Constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat() # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST : value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1), col_type(0, 0, 0)} # endif { # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION this->value[0] = col_type(1, 0, 0); this->value[1] = col_type(0, 1, 0); this->value[2] = col_type(0, 0, 1); this->value[3] = col_type(0, 0, 0); # endif } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, T, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(T const& s) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s), col_type(0, 0, 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(s, 0, 0); this->value[1] = col_type(0, s, 0); this->value[2] = col_type(0, 0, s); this->value[3] = col_type(0, 0, 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat ( T const& x0, T const& y0, T const& z0, T const& x1, T const& y1, T const& z1, T const& x2, T const& y2, T const& z2, T const& x3, T const& y3, T const& z3 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0, z0); this->value[1] = col_type(x1, y1, z1); this->value[2] = col_type(x2, y2, z2); this->value[3] = col_type(x3, y3, z3); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; this->value[3] = v3; # endif } // -- Conversion constructors -- template template< typename X0, typename Y0, typename Z0, typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, typename X3, typename Y3, typename Z3> GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat ( X0 const& x0, Y0 const& y0, Z0 const& z0, X1 const& x1, Y1 const& y1, Z1 const& z1, X2 const& x2, Y2 const& y2, Z2 const& z2, X3 const& x3, Y3 const& y3, Z3 const& z3 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0, z0); this->value[1] = col_type(x1, y1, z1); this->value[2] = col_type(x2, y2, z2); this->value[3] = col_type(x3, y3, z3); # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3, vec<3, V4, Q> const& v4) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v1); this->value[1] = col_type(v2); this->value[2] = col_type(v3); this->value[3] = col_type(v4); # endif } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, U, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(0, 0, 1); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0, 0, 1); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 1); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0, 0, 1); this->value[3] = col_type(0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(m[3], 0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 1); this->value[3] = col_type(m[3], 0); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); # endif } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type & mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 3, T, Q>::col_type const& mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>& mat<4, 3, T, Q>::operator=(mat<4, 3, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; this->value[3] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(mat<4, 3, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; this->value[3] += m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; this->value[3] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(mat<4, 3, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; this->value[3] -= m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; this->value[3] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; this->value[3] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; ++this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; --this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator++(int) { mat<4, 3, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator--(int) { mat<4, 3, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m) { return mat<4, 3, T, Q>( -m[0], -m[1], -m[2], -m[3]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s) { return mat<4, 3, T, Q>( m[0] + s, m[1] + s, m[2] + s, m[3] + s); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s) { return mat<4, 3, T, Q>( m[0] - s, m[1] - s, m[2] - s, m[3] - s); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s) { return mat<4, 3, T, Q>( m[0] * s, m[1] * s, m[2] * s, m[3] * s); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m) { return mat<4, 3, T, Q>( m[0] * s, m[1] * s, m[2] * s, m[3] * s); } template GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type operator* ( mat<4, 3, T, Q> const& m, typename mat<4, 3, T, Q>::row_type const& v) { return typename mat<4, 3, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w, m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w); } template GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::row_type operator* ( typename mat<4, 3, T, Q>::col_type const& v, mat<4, 3, T, Q> const& m) { return typename mat<4, 3, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2], v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2], v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2], v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { T const SrcA00 = m1[0][0]; T const SrcA01 = m1[0][1]; T const SrcA02 = m1[0][2]; T const SrcA10 = m1[1][0]; T const SrcA11 = m1[1][1]; T const SrcA12 = m1[1][2]; T const SrcA20 = m1[2][0]; T const SrcA21 = m1[2][1]; T const SrcA22 = m1[2][2]; T const SrcA30 = m1[3][0]; T const SrcA31 = m1[3][1]; T const SrcA32 = m1[3][2]; T const SrcB00 = m2[0][0]; T const SrcB01 = m2[0][1]; T const SrcB02 = m2[0][2]; T const SrcB03 = m2[0][3]; T const SrcB10 = m2[1][0]; T const SrcB11 = m2[1][1]; T const SrcB12 = m2[1][2]; T const SrcB13 = m2[1][3]; T const SrcB20 = m2[2][0]; T const SrcB21 = m2[2][1]; T const SrcB22 = m2[2][2]; T const SrcB23 = m2[2][3]; mat<3, 3, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12 + SrcA32 * SrcB13; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22 + SrcA30 * SrcB23; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22 + SrcA31 * SrcB23; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22 + SrcA32 * SrcB23; return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3], m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s) { return mat<4, 3, T, Q>( m[0] / s, m[1] / s, m[2] / s, m[3] / s); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m) { return mat<4, 3, T, Q>( s / m[0], s / m[1], s / m[2], s / m[3]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]); } } //namespace glm ================================================ FILE: android/src/glm/detail/type_mat4x4.hpp ================================================ /// @ref core /// @file glm/detail/type_mat4x4.hpp #pragma once #include "type_vec4.hpp" #include #include namespace glm { template struct mat<4, 4, T, Q> { typedef vec<4, T, Q> col_type; typedef vec<4, T, Q> row_type; typedef mat<4, 4, T, Q> type; typedef mat<4, 4, T, Q> transpose_type; typedef T value_type; private: col_type value[4]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;} GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 4, T, P> const& m); GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T const& x); GLM_FUNC_DECL GLM_CONSTEXPR mat( T const& x0, T const& y0, T const& z0, T const& w0, T const& x1, T const& y1, T const& z1, T const& w1, T const& x2, T const& y2, T const& z2, T const& w2, T const& x3, T const& y3, T const& z3, T const& w3); GLM_FUNC_DECL GLM_CONSTEXPR mat( col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2, typename X3, typename Y3, typename Z3, typename W3, typename X4, typename Y4, typename Z4, typename W4> GLM_FUNC_DECL GLM_CONSTEXPR mat( X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1, X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2, X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3, X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4); template GLM_FUNC_DECL GLM_CONSTEXPR mat( vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3, vec<4, V4, Q> const& v4); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- template GLM_FUNC_DECL mat<4, 4, T, Q> & operator=(mat<4, 4, U, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(mat<4, 4, U, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(mat<4, 4, U, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(mat<4, 4, U, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(U s); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(mat<4, 4, U, Q> const& m); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<4, 4, T, Q> & operator++(); GLM_FUNC_DECL mat<4, 4, T, Q> & operator--(); GLM_FUNC_DECL mat<4, 4, T, Q> operator++(int); GLM_FUNC_DECL mat<4, 4, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator*(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator*(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 4, T, Q> operator/(T const& s, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat4x4.inl" #endif//GLM_EXTERNAL_TEMPLATE ================================================ FILE: android/src/glm/detail/type_mat4x4.inl ================================================ #include "../matrix.hpp" namespace glm { // -- Constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat() # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST : value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)} # endif { # if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION this->value[0] = col_type(1, 0, 0, 0); this->value[1] = col_type(0, 1, 0, 0); this->value[2] = col_type(0, 0, 1, 0); this->value[3] = col_type(0, 0, 0, 1); # endif } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, T, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(T const& s) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0), col_type(0, 0, 0, s)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(s, 0, 0, 0); this->value[1] = col_type(0, s, 0, 0); this->value[2] = col_type(0, 0, s, 0); this->value[3] = col_type(0, 0, 0, s); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat ( T const& x0, T const& y0, T const& z0, T const& w0, T const& x1, T const& y1, T const& z1, T const& w1, T const& x2, T const& y2, T const& z2, T const& w2, T const& x3, T const& y3, T const& z3, T const& w3 ) # if GLM_HAS_INITIALIZER_LISTS : value{ col_type(x0, y0, z0, w0), col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2), col_type(x3, y3, z3, w3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x0, y0, z0, w0); this->value[1] = col_type(x1, y1, z1, w1); this->value[2] = col_type(x2, y2, z2, w2); this->value[3] = col_type(x3, y3, z3, w3); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; this->value[3] = v3; # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, U, P> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); # endif } // -- Conversions -- template template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2, typename X3, typename Y3, typename Z3, typename W3, typename X4, typename Y4, typename Z4, typename W4> GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat ( X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1, X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2, X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3, X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4 ) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2), col_type(x3, y3, z3, w3), col_type(x4, y4, z4, w4)} # endif { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid."); # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x1, y1, z1, w1); this->value[1] = col_type(x2, y2, z2, w2); this->value[2] = col_type(x3, y3, z3, w3); this->value[3] = col_type(x4, y4, z4, w4); # endif } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3, vec<4, V4, Q> const& v4) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)} # endif { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid."); # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v1); this->value[1] = col_type(v2); this->value[2] = col_type(v3); this->value[3] = col_type(v4); # endif } // -- Matrix conversions -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(0, 0, 1, 0); this->value[3] = col_type(0, 0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(0, 0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 0); this->value[3] = col_type(0, 0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(0, 0, 1, 0); this->value[3] = col_type(0, 0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0), col_type(0, 0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(m[2], 1, 0); this->value[3] = col_type(0, 0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = col_type(0, 0, 1, 0); this->value[3] = col_type(0, 0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 2, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(0, 0, 1, 0); this->value[3] = col_type(0, 0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 4, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0, 0, 0, 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = col_type(0, 0, 0, 1); # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 3, T, Q> const& m) # if GLM_HAS_INITIALIZER_LISTS : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(m[3], 1)} # endif { # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 0); this->value[3] = col_type(m[3], 1); # endif } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type & mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 4, T, Q>::col_type const& mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary arithmetic operators -- template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator=(mat<4, 4, U, Q> const& m) { //memcpy could be faster //memcpy(&this->value, &m.value, 16 * sizeof(valType)); this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; this->value[3] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(mat<4, 4, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; this->value[3] += m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; this->value[3] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(mat<4, 4, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; this->value[3] -= m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; this->value[3] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(mat<4, 4, U, Q> const& m) { return (*this = *this * m); } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; this->value[3] /= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(mat<4, 4, U, Q> const& m) { return *this *= inverse(m); } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; ++this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; --this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator++(int) { mat<4, 4, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator--(int) { mat<4, 4, T, Q> Result(*this); --*this; return Result; } // -- Unary constant operators -- template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( -m[0], -m[1], -m[2], -m[3]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s) { return mat<4, 4, T, Q>( m[0] + s, m[1] + s, m[2] + s, m[3] + s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( m[0] + s, m[1] + s, m[2] + s, m[3] + s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return mat<4, 4, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s) { return mat<4, 4, T, Q>( m[0] - s, m[1] - s, m[2] - s, m[3] - s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( s - m[0], s - m[1], s - m[2], s - m[3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return mat<4, 4, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const & s) { return mat<4, 4, T, Q>( m[0] * s, m[1] * s, m[2] * s, m[3] * s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( m[0] * s, m[1] * s, m[2] * s, m[3] * s); } template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator* ( mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v ) { /* __m128 v0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(0, 0, 0, 0)); __m128 v1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(1, 1, 1, 1)); __m128 v2 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(2, 2, 2, 2)); __m128 v3 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(m[0].data, v0); __m128 m1 = _mm_mul_ps(m[1].data, v1); __m128 a0 = _mm_add_ps(m0, m1); __m128 m2 = _mm_mul_ps(m[2].data, v2); __m128 m3 = _mm_mul_ps(m[3].data, v3); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); return typename mat<4, 4, T, Q>::col_type(a2); */ typename mat<4, 4, T, Q>::col_type const Mov0(v[0]); typename mat<4, 4, T, Q>::col_type const Mov1(v[1]); typename mat<4, 4, T, Q>::col_type const Mul0 = m[0] * Mov0; typename mat<4, 4, T, Q>::col_type const Mul1 = m[1] * Mov1; typename mat<4, 4, T, Q>::col_type const Add0 = Mul0 + Mul1; typename mat<4, 4, T, Q>::col_type const Mov2(v[2]); typename mat<4, 4, T, Q>::col_type const Mov3(v[3]); typename mat<4, 4, T, Q>::col_type const Mul2 = m[2] * Mov2; typename mat<4, 4, T, Q>::col_type const Mul3 = m[3] * Mov3; typename mat<4, 4, T, Q>::col_type const Add1 = Mul2 + Mul3; typename mat<4, 4, T, Q>::col_type const Add2 = Add0 + Add1; return Add2; /* return typename mat<4, 4, T, Q>::col_type( m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0] * v[3], m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1] * v[3], m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2] * v[3], m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3] * v[3]); */ } template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator* ( typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m ) { return typename mat<4, 4, T, Q>::row_type( m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3] * v[3], m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3] * v[3], m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3] * v[3], m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3], m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { typename mat<4, 4, T, Q>::col_type const SrcA0 = m1[0]; typename mat<4, 4, T, Q>::col_type const SrcA1 = m1[1]; typename mat<4, 4, T, Q>::col_type const SrcA2 = m1[2]; typename mat<4, 4, T, Q>::col_type const SrcA3 = m1[3]; typename mat<4, 4, T, Q>::col_type const SrcB0 = m2[0]; typename mat<4, 4, T, Q>::col_type const SrcB1 = m2[1]; typename mat<4, 4, T, Q>::col_type const SrcB2 = m2[2]; typename mat<4, 4, T, Q>::col_type const SrcB3 = m2[3]; mat<4, 4, T, Q> Result; Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3]; Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3]; Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3]; Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] + SrcA3 * SrcB3[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s) { return mat<4, 4, T, Q>( m[0] / s, m[1] / s, m[2] / s, m[3] / s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(T const& s, mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( s / m[0], s / m[1], s / m[2], s / m[3]); } template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v) { return inverse(m) * v; } template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m) { return v * inverse(m); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { mat<4, 4, T, Q> m1_copy(m1); return m1_copy /= m2; } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "type_mat4x4_simd.inl" #endif ================================================ FILE: android/src/glm/detail/type_mat4x4_simd.inl ================================================ /// @ref core namespace glm { }//namespace glm ================================================ FILE: android/src/glm/detail/type_quat.hpp ================================================ /// @ref core /// @file glm/detail/type_quat.hpp #pragma once // Dependency: #include "../detail/type_mat3x3.hpp" #include "../detail/type_mat4x4.hpp" #include "../detail/type_vec3.hpp" #include "../detail/type_vec4.hpp" #include "../ext/vector_relational.hpp" #include "../ext/quaternion_relational.hpp" #include "../gtc/constants.hpp" #include "../gtc/matrix_transform.hpp" namespace glm { template struct qua { // -- Implementation detail -- typedef qua type; typedef T value_type; // -- Data -- # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # elif GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union # endif # endif # if GLM_LANG & GLM_LANG_CXXMS_FLAG union { # ifdef GLM_FORCE_QUAT_DATA_WXYZ struct { T w, x, y, z; }; # else struct { T x, y, z, w; }; # endif typename detail::storage<4, T, detail::is_aligned::value>::type data; }; # else # ifdef GLM_FORCE_QUAT_DATA_WXYZ T w, x, y, z; # else T x, y, z, w; # endif # endif # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif # endif // -- Component accesses -- typedef length_t length_type; /// Return the count of components of a quaternion GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;} GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR qua() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR qua(qua const& q) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR qua(qua const& q); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR qua(T s, vec<3, T, Q> const& v); GLM_FUNC_DECL GLM_CONSTEXPR qua(T w, T x, T y, T z); // -- Conversion constructors -- template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT qua(qua const& q); /// Explicit conversion operators # if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS GLM_FUNC_DECL explicit operator mat<3, 3, T, Q>() const; GLM_FUNC_DECL explicit operator mat<4, 4, T, Q>() const; # endif /// Create a quaternion from two normalized axis /// /// @param u A first normalized axis /// @param v A second normalized axis /// @see gtc_quaternion /// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors GLM_FUNC_DECL qua(vec<3, T, Q> const& u, vec<3, T, Q> const& v); /// Build a quaternion from euler angles (pitch, yaw, roll), in radians. GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT qua(vec<3, T, Q> const& eulerAngles); GLM_FUNC_DECL GLM_EXPLICIT qua(mat<3, 3, T, Q> const& q); GLM_FUNC_DECL GLM_EXPLICIT qua(mat<4, 4, T, Q> const& q); // -- Unary arithmetic operators -- GLM_FUNC_DECL GLM_CONSTEXPR qua& operator=(qua const& q) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR qua& operator=(qua const& q); template GLM_FUNC_DECL GLM_CONSTEXPR qua& operator+=(qua const& q); template GLM_FUNC_DECL GLM_CONSTEXPR qua& operator-=(qua const& q); template GLM_FUNC_DECL GLM_CONSTEXPR qua& operator*=(qua const& q); template GLM_FUNC_DECL GLM_CONSTEXPR qua& operator*=(U s); template GLM_FUNC_DECL GLM_CONSTEXPR qua& operator/=(U s); }; // -- Unary bit operators -- template GLM_FUNC_DECL GLM_CONSTEXPR qua operator+(qua const& q); template GLM_FUNC_DECL GLM_CONSTEXPR qua operator-(qua const& q); // -- Binary operators -- template GLM_FUNC_DECL GLM_CONSTEXPR qua operator+(qua const& q, qua const& p); template GLM_FUNC_DECL GLM_CONSTEXPR qua operator-(qua const& q, qua const& p); template GLM_FUNC_DECL GLM_CONSTEXPR qua operator*(qua const& q, qua const& p); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(qua const& q, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, qua const& q); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(qua const& q, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, qua const& q); template GLM_FUNC_DECL GLM_CONSTEXPR qua operator*(qua const& q, T const& s); template GLM_FUNC_DECL GLM_CONSTEXPR qua operator*(T const& s, qua const& q); template GLM_FUNC_DECL GLM_CONSTEXPR qua operator/(qua const& q, T const& s); // -- Boolean operators -- template GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(qua const& q1, qua const& q2); template GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(qua const& q1, qua const& q2); } //namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_quat.inl" #endif//GLM_EXTERNAL_TEMPLATE ================================================ FILE: android/src/glm/detail/type_quat.inl ================================================ #include "../trigonometric.hpp" #include "../exponential.hpp" #include "../ext/quaternion_geometric.hpp" #include namespace glm{ namespace detail { template struct genTypeTrait > { static const genTypeEnum GENTYPE = GENTYPE_QUAT; }; template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(qua const& a, qua const& b) { vec<4, T, Q> tmp(a.w * b.w, a.x * b.x, a.y * b.y, a.z * b.z); return (tmp.x + tmp.y) + (tmp.z + tmp.w); } }; template struct compute_quat_add { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua call(qua const& q, qua const& p) { return qua(q.w + p.w, q.x + p.x, q.y + p.y, q.z + p.z); } }; template struct compute_quat_sub { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua call(qua const& q, qua const& p) { return qua(q.w - p.w, q.x - p.x, q.y - p.y, q.z - p.z); } }; template struct compute_quat_mul_scalar { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua call(qua const& q, T s) { return qua(q.w * s, q.x * s, q.y * s, q.z * s); } }; template struct compute_quat_div_scalar { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua call(qua const& q, T s) { return qua(q.w / s, q.x / s, q.y / s, q.z / s); } }; template struct compute_quat_mul_vec4 { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(qua const& q, vec<4, T, Q> const& v) { return vec<4, T, Q>(q * vec<3, T, Q>(v), v.w); } }; }//namespace detail // -- Component accesses -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & qua::operator[](typename qua::length_type i) { assert(i >= 0 && i < this->length()); # ifdef GLM_FORCE_QUAT_DATA_WXYZ return (&w)[i]; # else return (&x)[i]; # endif } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& qua::operator[](typename qua::length_type i) const { assert(i >= 0 && i < this->length()); # ifdef GLM_FORCE_QUAT_DATA_WXYZ return (&w)[i]; # else return (&x)[i]; # endif } // -- Implicit basic constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua::qua() # if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE # ifdef GLM_FORCE_QUAT_DATA_WXYZ : w(1), x(0), y(0), z(0) # else : x(0), y(0), z(0), w(1) # endif # endif {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua::qua(qua const& q) # ifdef GLM_FORCE_QUAT_DATA_WXYZ : w(q.w), x(q.x), y(q.y), z(q.z) # else : x(q.x), y(q.y), z(q.z), w(q.w) # endif {} # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua::qua(qua const& q) # ifdef GLM_FORCE_QUAT_DATA_WXYZ : w(q.w), x(q.x), y(q.y), z(q.z) # else : x(q.x), y(q.y), z(q.z), w(q.w) # endif {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua::qua(T s, vec<3, T, Q> const& v) # ifdef GLM_FORCE_QUAT_DATA_WXYZ : w(s), x(v.x), y(v.y), z(v.z) # else : x(v.x), y(v.y), z(v.z), w(s) # endif {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua::qua(T _w, T _x, T _y, T _z) # ifdef GLM_FORCE_QUAT_DATA_WXYZ : w(_w), x(_x), y(_y), z(_z) # else : x(_x), y(_y), z(_z), w(_w) # endif {} // -- Conversion constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua::qua(qua const& q) # ifdef GLM_FORCE_QUAT_DATA_WXYZ : w(static_cast(q.w)), x(static_cast(q.x)), y(static_cast(q.y)), z(static_cast(q.z)) # else : x(static_cast(q.x)), y(static_cast(q.y)), z(static_cast(q.z)), w(static_cast(q.w)) # endif {} //template //GLM_FUNC_QUALIFIER qua::qua //( // valType const& pitch, // valType const& yaw, // valType const& roll //) //{ // vec<3, valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5)); // vec<3, valType> c = glm::cos(eulerAngle * valType(0.5)); // vec<3, valType> s = glm::sin(eulerAngle * valType(0.5)); // // this->w = c.x * c.y * c.z + s.x * s.y * s.z; // this->x = s.x * c.y * c.z - c.x * s.y * s.z; // this->y = c.x * s.y * c.z + s.x * c.y * s.z; // this->z = c.x * c.y * s.z - s.x * s.y * c.z; //} template GLM_FUNC_QUALIFIER qua::qua(vec<3, T, Q> const& u, vec<3, T, Q> const& v) { T norm_u_norm_v = sqrt(dot(u, u) * dot(v, v)); T real_part = norm_u_norm_v + dot(u, v); vec<3, T, Q> t; if(real_part < static_cast(1.e-6f) * norm_u_norm_v) { // If u and v are exactly opposite, rotate 180 degrees // around an arbitrary orthogonal axis. Axis normalisation // can happen later, when we normalise the quaternion. real_part = static_cast(0); t = abs(u.x) > abs(u.z) ? vec<3, T, Q>(-u.y, u.x, static_cast(0)) : vec<3, T, Q>(static_cast(0), -u.z, u.y); } else { // Otherwise, build quaternion the standard way. t = cross(u, v); } *this = normalize(qua(real_part, t.x, t.y, t.z)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua::qua(vec<3, T, Q> const& eulerAngle) { vec<3, T, Q> c = glm::cos(eulerAngle * T(0.5)); vec<3, T, Q> s = glm::sin(eulerAngle * T(0.5)); this->w = c.x * c.y * c.z + s.x * s.y * s.z; this->x = s.x * c.y * c.z - c.x * s.y * s.z; this->y = c.x * s.y * c.z + s.x * c.y * s.z; this->z = c.x * c.y * s.z - s.x * s.y * c.z; } template GLM_FUNC_QUALIFIER qua::qua(mat<3, 3, T, Q> const& m) { *this = quat_cast(m); } template GLM_FUNC_QUALIFIER qua::qua(mat<4, 4, T, Q> const& m) { *this = quat_cast(m); } # if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS template GLM_FUNC_QUALIFIER qua::operator mat<3, 3, T, Q>() const { return mat3_cast(*this); } template GLM_FUNC_QUALIFIER qua::operator mat<4, 4, T, Q>() const { return mat4_cast(*this); } # endif//GLM_HAS_EXPLICIT_CONVERSION_OPERATORS // -- Unary arithmetic operators -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua & qua::operator=(qua const& q) { this->w = q.w; this->x = q.x; this->y = q.y; this->z = q.z; return *this; } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua & qua::operator=(qua const& q) { this->w = static_cast(q.w); this->x = static_cast(q.x); this->y = static_cast(q.y); this->z = static_cast(q.z); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua & qua::operator+=(qua const& q) { return (*this = detail::compute_quat_add::value>::call(*this, qua(q))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua & qua::operator-=(qua const& q) { return (*this = detail::compute_quat_sub::value>::call(*this, qua(q))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua & qua::operator*=(qua const& r) { qua const p(*this); qua const q(r); this->w = p.w * q.w - p.x * q.x - p.y * q.y - p.z * q.z; this->x = p.w * q.x + p.x * q.w + p.y * q.z - p.z * q.y; this->y = p.w * q.y + p.y * q.w + p.z * q.x - p.x * q.z; this->z = p.w * q.z + p.z * q.w + p.x * q.y - p.y * q.x; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua & qua::operator*=(U s) { return (*this = detail::compute_quat_mul_scalar::value>::call(*this, static_cast(s))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua & qua::operator/=(U s) { return (*this = detail::compute_quat_div_scalar::value>::call(*this, static_cast(s))); } // -- Unary bit operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua operator+(qua const& q) { return q; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua operator-(qua const& q) { return qua(-q.w, -q.x, -q.y, -q.z); } // -- Binary operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua operator+(qua const& q, qua const& p) { return qua(q) += p; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua operator-(qua const& q, qua const& p) { return qua(q) -= p; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua operator*(qua const& q, qua const& p) { return qua(q) *= p; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(qua const& q, vec<3, T, Q> const& v) { vec<3, T, Q> const QuatVector(q.x, q.y, q.z); vec<3, T, Q> const uv(glm::cross(QuatVector, v)); vec<3, T, Q> const uuv(glm::cross(QuatVector, uv)); return v + ((uv * q.w) + uuv) * static_cast(2); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, qua const& q) { return glm::inverse(q) * v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(qua const& q, vec<4, T, Q> const& v) { return detail::compute_quat_mul_vec4::value>::call(q, v); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, qua const& q) { return glm::inverse(q) * v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua operator*(qua const& q, T const& s) { return qua( q.w * s, q.x * s, q.y * s, q.z * s); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua operator*(T const& s, qua const& q) { return q * s; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua operator/(qua const& q, T const& s) { return qua( q.w / s, q.x / s, q.y / s, q.z / s); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(qua const& q1, qua const& q2) { return q1.x == q2.x && q1.y == q2.y && q1.z == q2.z && q1.w == q2.w; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(qua const& q1, qua const& q2) { return q1.x != q2.x || q1.y != q2.y || q1.z != q2.z || q1.w != q2.w; } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "type_quat_simd.inl" #endif ================================================ FILE: android/src/glm/detail/type_quat_simd.inl ================================================ /// @ref core #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { /* template struct compute_quat_mul { static qua call(qua const& q1, qua const& q2) { // SSE2 STATS: 11 shuffle, 8 mul, 8 add // SSE4 STATS: 3 shuffle, 4 mul, 4 dpps __m128 const mul0 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(0, 1, 2, 3))); __m128 const mul1 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(1, 0, 3, 2))); __m128 const mul2 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(2, 3, 0, 1))); __m128 const mul3 = _mm_mul_ps(q1.Data, q2.Data); # if GLM_ARCH & GLM_ARCH_SSE41_BIT __m128 const add0 = _mm_dp_ps(mul0, _mm_set_ps(1.0f, -1.0f, 1.0f, 1.0f), 0xff); __m128 const add1 = _mm_dp_ps(mul1, _mm_set_ps(1.0f, 1.0f, 1.0f, -1.0f), 0xff); __m128 const add2 = _mm_dp_ps(mul2, _mm_set_ps(1.0f, 1.0f, -1.0f, 1.0f), 0xff); __m128 const add3 = _mm_dp_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f), 0xff); # else __m128 const mul4 = _mm_mul_ps(mul0, _mm_set_ps(1.0f, -1.0f, 1.0f, 1.0f)); __m128 const add0 = _mm_add_ps(mul0, _mm_movehl_ps(mul4, mul4)); __m128 const add4 = _mm_add_ss(add0, _mm_shuffle_ps(add0, add0, 1)); __m128 const mul5 = _mm_mul_ps(mul1, _mm_set_ps(1.0f, 1.0f, 1.0f, -1.0f)); __m128 const add1 = _mm_add_ps(mul1, _mm_movehl_ps(mul5, mul5)); __m128 const add5 = _mm_add_ss(add1, _mm_shuffle_ps(add1, add1, 1)); __m128 const mul6 = _mm_mul_ps(mul2, _mm_set_ps(1.0f, 1.0f, -1.0f, 1.0f)); __m128 const add2 = _mm_add_ps(mul6, _mm_movehl_ps(mul6, mul6)); __m128 const add6 = _mm_add_ss(add2, _mm_shuffle_ps(add2, add2, 1)); __m128 const mul7 = _mm_mul_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f)); __m128 const add3 = _mm_add_ps(mul3, _mm_movehl_ps(mul7, mul7)); __m128 const add7 = _mm_add_ss(add3, _mm_shuffle_ps(add3, add3, 1)); #endif // This SIMD code is a politically correct way of doing this, but in every test I've tried it has been slower than // the final code below. I'll keep this here for reference - maybe somebody else can do something better... // //__m128 xxyy = _mm_shuffle_ps(add4, add5, _MM_SHUFFLE(0, 0, 0, 0)); //__m128 zzww = _mm_shuffle_ps(add6, add7, _MM_SHUFFLE(0, 0, 0, 0)); // //return _mm_shuffle_ps(xxyy, zzww, _MM_SHUFFLE(2, 0, 2, 0)); qua Result; _mm_store_ss(&Result.x, add4); _mm_store_ss(&Result.y, add5); _mm_store_ss(&Result.z, add6); _mm_store_ss(&Result.w, add7); return Result; } }; */ template struct compute_quat_add { static qua call(qua const& q, qua const& p) { qua Result; Result.data = _mm_add_ps(q.data, p.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_quat_add { static qua call(qua const& a, qua const& b) { qua Result; Result.data = _mm256_add_pd(a.data, b.data); return Result; } }; # endif template struct compute_quat_sub { static qua call(qua const& q, qua const& p) { vec<4, float, Q> Result; Result.data = _mm_sub_ps(q.data, p.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_quat_sub { static qua call(qua const& a, qua const& b) { qua Result; Result.data = _mm256_sub_pd(a.data, b.data); return Result; } }; # endif template struct compute_quat_mul_scalar { static qua call(qua const& q, float s) { vec<4, float, Q> Result; Result.data = _mm_mul_ps(q.data, _mm_set_ps1(s)); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_quat_mul_scalar { static qua call(qua const& q, double s) { qua Result; Result.data = _mm256_mul_pd(q.data, _mm_set_ps1(s)); return Result; } }; # endif template struct compute_quat_div_scalar { static qua call(qua const& q, float s) { vec<4, float, Q> Result; Result.data = _mm_div_ps(q.data, _mm_set_ps1(s)); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_quat_div_scalar { static qua call(qua const& q, double s) { qua Result; Result.data = _mm256_div_pd(q.data, _mm_set_ps1(s)); return Result; } }; # endif template struct compute_quat_mul_vec4 { static vec<4, float, Q> call(qua const& q, vec<4, float, Q> const& v) { __m128 const q_wwww = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 3, 3, 3)); __m128 const q_swp0 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 0, 2, 1)); __m128 const q_swp1 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 1, 0, 2)); __m128 const v_swp0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 0, 2, 1)); __m128 const v_swp1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 1, 0, 2)); __m128 uv = _mm_sub_ps(_mm_mul_ps(q_swp0, v_swp1), _mm_mul_ps(q_swp1, v_swp0)); __m128 uv_swp0 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 0, 2, 1)); __m128 uv_swp1 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 1, 0, 2)); __m128 uuv = _mm_sub_ps(_mm_mul_ps(q_swp0, uv_swp1), _mm_mul_ps(q_swp1, uv_swp0)); __m128 const two = _mm_set1_ps(2.0f); uv = _mm_mul_ps(uv, _mm_mul_ps(q_wwww, two)); uuv = _mm_mul_ps(uuv, two); vec<4, float, Q> Result; Result.data = _mm_add_ps(v.Data, _mm_add_ps(uv, uuv)); return Result; } }; }//namespace detail }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/detail/type_vec1.hpp ================================================ /// @ref core /// @file glm/detail/type_vec1.hpp #pragma once #include "qualifier.hpp" #if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR # include "_swizzle.hpp" #elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION # include "_swizzle_func.hpp" #endif #include namespace glm { template struct vec<1, T, Q> { // -- Implementation detail -- typedef T value_type; typedef vec<1, T, Q> type; typedef vec<1, bool, Q> bool_type; // -- Data -- # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # elif GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union # endif # endif # if GLM_CONFIG_XYZW_ONLY T x; # elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE union { T x; T r; T s; typename detail::storage<1, T, detail::is_aligned::value>::type data; /* # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR _GLM_SWIZZLE1_2_MEMBERS(T, Q, x) _GLM_SWIZZLE1_2_MEMBERS(T, Q, r) _GLM_SWIZZLE1_2_MEMBERS(T, Q, s) _GLM_SWIZZLE1_3_MEMBERS(T, Q, x) _GLM_SWIZZLE1_3_MEMBERS(T, Q, r) _GLM_SWIZZLE1_3_MEMBERS(T, Q, s) _GLM_SWIZZLE1_4_MEMBERS(T, Q, x) _GLM_SWIZZLE1_4_MEMBERS(T, Q, r) _GLM_SWIZZLE1_4_MEMBERS(T, Q, s) # endif */ }; # else union {T x, r, s;}; /* # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, Q) # endif */ # endif # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif # endif // -- Component accesses -- /// Return the count of components of the vector typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 1;} GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, T, P> const& v); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar); // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<1, U, P> const& v); // -- Swizzle constructors -- /* # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR template GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<1, T, Q, E0, -1,-2,-3> const& that) { *this = that(); } # endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR */ // -- Unary arithmetic operators -- GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator+=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator+=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator-=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator-=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator*=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator*=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator/=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator/=(vec<1, U, Q> const& v); // -- Increment and decrement operators -- GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator++(); GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator--(); GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator++(int); GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator--(int); // -- Unary bit operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator%=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator%=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator&=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator&=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator|=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator|=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator^=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator^=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator<<=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator<<=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator>>=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator>>=(vec<1, U, Q> const& v); }; // -- Unary operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v); // -- Binary operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator~(vec<1, T, Q> const& v); // -- Boolean operators -- template GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_vec1.inl" #endif//GLM_EXTERNAL_TEMPLATE ================================================ FILE: android/src/glm/detail/type_vec1.inl ================================================ /// @ref core #include "./compute_vector_relational.hpp" namespace glm { // -- Implicit basic constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec() # if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE : x(0) # endif {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, Q> const& v) : x(v.x) {} # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, P> const& v) : x(v.x) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(T scalar) : x(scalar) {} // -- Conversion vector constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, U, P> const& v) : x(static_cast(v.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<2, U, P> const& v) : x(static_cast(v.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<3, U, P> const& v) : x(static_cast(v.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<4, U, P> const& v) : x(static_cast(v.x)) {} // -- Component accesses -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type) { return x; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type) const { return x; } // -- Unary arithmetic operators -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, T, Q> const& v) { this->x = v.x; return *this; } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, U, Q> const& v) { this->x = static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator+=(U scalar) { this->x += static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator+=(vec<1, U, Q> const& v) { this->x += static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator-=(U scalar) { this->x -= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator-=(vec<1, U, Q> const& v) { this->x -= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator*=(U scalar) { this->x *= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator*=(vec<1, U, Q> const& v) { this->x *= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator/=(U scalar) { this->x /= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator/=(vec<1, U, Q> const& v) { this->x /= static_cast(v.x); return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator++() { ++this->x; return *this; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator--() { --this->x; return *this; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> vec<1, T, Q>::operator++(int) { vec<1, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> vec<1, T, Q>::operator--(int) { vec<1, T, Q> Result(*this); --*this; return Result; } // -- Unary bit operators -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator%=(U scalar) { this->x %= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator%=(vec<1, U, Q> const& v) { this->x %= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator&=(U scalar) { this->x &= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator&=(vec<1, U, Q> const& v) { this->x &= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator|=(U scalar) { this->x |= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator|=(vec<1, U, Q> const& v) { this->x |= U(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator^=(U scalar) { this->x ^= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator^=(vec<1, U, Q> const& v) { this->x ^= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator<<=(U scalar) { this->x <<= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator<<=(vec<1, U, Q> const& v) { this->x <<= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator>>=(U scalar) { this->x >>= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator>>=(vec<1, U, Q> const& v) { this->x >>= static_cast(v.x); return *this; } // -- Unary constant operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v) { return vec<1, T, Q>( -v.x); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x + scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar + v.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x + v2.x); } //operator- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x - scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar - v.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x - v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x * scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar * v.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x * v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x / scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar / v.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x / v2.x); } // -- Binary bit operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x % scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar % v.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x % v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x & scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar & v.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x & v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x | scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar | v.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x | v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x ^ scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar ^ v.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x ^ v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( static_cast(v.x << scalar)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( static_cast(scalar << v.x)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( static_cast(v1.x << v2.x)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( static_cast(v.x >> scalar)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( static_cast(scalar >> v.x)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( static_cast(v1.x >> v2.x)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator~(vec<1, T, Q> const& v) { return vec<1, T, Q>( ~v.x); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return detail::compute_equal::is_iec559>::call(v1.x, v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return !(v1 == v2); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2) { return vec<1, bool, Q>(v1.x && v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2) { return vec<1, bool, Q>(v1.x || v2.x); } }//namespace glm ================================================ FILE: android/src/glm/detail/type_vec2.hpp ================================================ /// @ref core /// @file glm/detail/type_vec2.hpp #pragma once #include "qualifier.hpp" #if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR # include "_swizzle.hpp" #elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION # include "_swizzle_func.hpp" #endif #include namespace glm { template struct vec<2, T, Q> { // -- Implementation detail -- typedef T value_type; typedef vec<2, T, Q> type; typedef vec<2, bool, Q> bool_type; // -- Data -- # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # elif GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union # endif # endif # if GLM_CONFIG_XYZW_ONLY T x, y; # elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE union { struct{ T x, y; }; struct{ T r, g; }; struct{ T s, t; }; typename detail::storage<2, T, detail::is_aligned::value>::type data; # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR GLM_SWIZZLE2_2_MEMBERS(T, Q, x, y) GLM_SWIZZLE2_2_MEMBERS(T, Q, r, g) GLM_SWIZZLE2_2_MEMBERS(T, Q, s, t) GLM_SWIZZLE2_3_MEMBERS(T, Q, x, y) GLM_SWIZZLE2_3_MEMBERS(T, Q, r, g) GLM_SWIZZLE2_3_MEMBERS(T, Q, s, t) GLM_SWIZZLE2_4_MEMBERS(T, Q, x, y) GLM_SWIZZLE2_4_MEMBERS(T, Q, r, g) GLM_SWIZZLE2_4_MEMBERS(T, Q, s, t) # endif }; # else union {T x, r, s;}; union {T y, g, t;}; # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, Q) # endif//GLM_CONFIG_SWIZZLE # endif # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif # endif // -- Component accesses -- /// Return the count of components of the vector typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;} GLM_FUNC_DECL GLM_CONSTEXPR T& operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, T, P> const& v); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR vec(T x, T y); // -- Conversion constructors -- template GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, B y); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const& x, B y); template GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, vec<1, B, Q> const& y); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const& x, vec<1, B, Q> const& y); // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, P> const& v); // -- Swizzle constructors -- # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR template GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1,-1,-2> const& that) { *this = that(); } # endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR // -- Unary arithmetic operators -- GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec<2, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(vec<2, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(vec<2, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(vec<2, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(vec<2, U, Q> const& v); // -- Increment and decrement operators -- GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator++(); GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator--(); GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator++(int); GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator--(int); // -- Unary bit operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(vec<2, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(vec<2, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(vec<2, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(vec<2, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(vec<2, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(vec<2, U, Q> const& v); }; // -- Unary operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v); // -- Binary operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator~(vec<2, T, Q> const& v); // -- Boolean operators -- template GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_vec2.inl" #endif//GLM_EXTERNAL_TEMPLATE ================================================ FILE: android/src/glm/detail/type_vec2.inl ================================================ /// @ref core #include "./compute_vector_relational.hpp" namespace glm { // -- Implicit basic constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec() # if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE : x(0), y(0) # endif {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, T, Q> const& v) : x(v.x), y(v.y) {} # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, T, P> const& v) : x(v.x), y(v.y) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(T scalar) : x(scalar), y(scalar) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(T _x, T _y) : x(_x), y(_y) {} // -- Conversion scalar constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(A _x, B _y) : x(static_cast(_x)) , y(static_cast(_y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, A, Q> const& _x, B _y) : x(static_cast(_x.x)) , y(static_cast(_y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(A _x, vec<1, B, Q> const& _y) : x(static_cast(_x)) , y(static_cast(_y.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, A, Q> const& _x, vec<1, B, Q> const& _y) : x(static_cast(_x.x)) , y(static_cast(_y.x)) {} // -- Conversion vector constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<3, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<4, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) {} // -- Component accesses -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i) { assert(i >= 0 && i < this->length()); switch(i) { default: case 0: return x; case 1: return y; } } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i) const { assert(i >= 0 && i < this->length()); switch(i) { default: case 0: return x; case 1: return y; } } // -- Unary arithmetic operators -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, T, Q> const& v) { this->x = v.x; this->y = v.y; return *this; } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, U, Q> const& v) { this->x = static_cast(v.x); this->y = static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(U scalar) { this->x += static_cast(scalar); this->y += static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<1, U, Q> const& v) { this->x += static_cast(v.x); this->y += static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<2, U, Q> const& v) { this->x += static_cast(v.x); this->y += static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(U scalar) { this->x -= static_cast(scalar); this->y -= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<1, U, Q> const& v) { this->x -= static_cast(v.x); this->y -= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<2, U, Q> const& v) { this->x -= static_cast(v.x); this->y -= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(U scalar) { this->x *= static_cast(scalar); this->y *= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<1, U, Q> const& v) { this->x *= static_cast(v.x); this->y *= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<2, U, Q> const& v) { this->x *= static_cast(v.x); this->y *= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(U scalar) { this->x /= static_cast(scalar); this->y /= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<1, U, Q> const& v) { this->x /= static_cast(v.x); this->y /= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<2, U, Q> const& v) { this->x /= static_cast(v.x); this->y /= static_cast(v.y); return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator++() { ++this->x; ++this->y; return *this; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator--() { --this->x; --this->y; return *this; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> vec<2, T, Q>::operator++(int) { vec<2, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> vec<2, T, Q>::operator--(int) { vec<2, T, Q> Result(*this); --*this; return Result; } // -- Unary bit operators -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(U scalar) { this->x %= static_cast(scalar); this->y %= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<1, U, Q> const& v) { this->x %= static_cast(v.x); this->y %= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<2, U, Q> const& v) { this->x %= static_cast(v.x); this->y %= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(U scalar) { this->x &= static_cast(scalar); this->y &= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<1, U, Q> const& v) { this->x &= static_cast(v.x); this->y &= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<2, U, Q> const& v) { this->x &= static_cast(v.x); this->y &= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(U scalar) { this->x |= static_cast(scalar); this->y |= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<1, U, Q> const& v) { this->x |= static_cast(v.x); this->y |= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<2, U, Q> const& v) { this->x |= static_cast(v.x); this->y |= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(U scalar) { this->x ^= static_cast(scalar); this->y ^= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<1, U, Q> const& v) { this->x ^= static_cast(v.x); this->y ^= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<2, U, Q> const& v) { this->x ^= static_cast(v.x); this->y ^= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(U scalar) { this->x <<= static_cast(scalar); this->y <<= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<1, U, Q> const& v) { this->x <<= static_cast(v.x); this->y <<= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<2, U, Q> const& v) { this->x <<= static_cast(v.x); this->y <<= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(U scalar) { this->x >>= static_cast(scalar); this->y >>= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<1, U, Q> const& v) { this->x >>= static_cast(v.x); this->y >>= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<2, U, Q> const& v) { this->x >>= static_cast(v.x); this->y >>= static_cast(v.y); return *this; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v) { return vec<2, T, Q>( -v.x, -v.y); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x + scalar, v.y + scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x + v2.x, v1.y + v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar + v.x, scalar + v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x + v2.x, v1.x + v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x + v2.x, v1.y + v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x - scalar, v.y - scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x - v2.x, v1.y - v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar - v.x, scalar - v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x - v2.x, v1.x - v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x - v2.x, v1.y - v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x * scalar, v.y * scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x * v2.x, v1.y * v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar * v.x, scalar * v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x * v2.x, v1.x * v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x * v2.x, v1.y * v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x / scalar, v.y / scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x / v2.x, v1.y / v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar / v.x, scalar / v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x / v2.x, v1.x / v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x / v2.x, v1.y / v2.y); } // -- Binary bit operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x % scalar, v.y % scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x % v2.x, v1.y % v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar % v.x, scalar % v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x % v2.x, v1.x % v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x % v2.x, v1.y % v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x & scalar, v.y & scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x & v2.x, v1.y & v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar & v.x, scalar & v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x & v2.x, v1.x & v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x & v2.x, v1.y & v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x | scalar, v.y | scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x | v2.x, v1.y | v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar | v.x, scalar | v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x | v2.x, v1.x | v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x | v2.x, v1.y | v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x ^ scalar, v.y ^ scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x ^ v2.x, v1.y ^ v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar ^ v.x, scalar ^ v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x ^ v2.x, v1.x ^ v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x ^ v2.x, v1.y ^ v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x << scalar, v.y << scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x << v2.x, v1.y << v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar << v.x, scalar << v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x << v2.x, v1.x << v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x << v2.x, v1.y << v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x >> scalar, v.y >> scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x >> v2.x, v1.y >> v2.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar >> v.x, scalar >> v.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x >> v2.x, v1.x >> v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x >> v2.x, v1.y >> v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator~(vec<2, T, Q> const& v) { return vec<2, T, Q>( ~v.x, ~v.y); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return detail::compute_equal::is_iec559>::call(v1.x, v2.x) && detail::compute_equal::is_iec559>::call(v1.y, v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return !(v1 == v2); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2) { return vec<2, bool, Q>(v1.x && v2.x, v1.y && v2.y); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2) { return vec<2, bool, Q>(v1.x || v2.x, v1.y || v2.y); } }//namespace glm ================================================ FILE: android/src/glm/detail/type_vec3.hpp ================================================ /// @ref core /// @file glm/detail/type_vec3.hpp #pragma once #include "qualifier.hpp" #if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR # include "_swizzle.hpp" #elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION # include "_swizzle_func.hpp" #endif #include namespace glm { template struct vec<3, T, Q> { // -- Implementation detail -- typedef T value_type; typedef vec<3, T, Q> type; typedef vec<3, bool, Q> bool_type; // -- Data -- # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # elif GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE # pragma warning(disable: 4324) // structure was padded due to alignment specifier # endif # endif # endif # if GLM_CONFIG_XYZW_ONLY T x, y, z; # elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE union { struct{ T x, y, z; }; struct{ T r, g, b; }; struct{ T s, t, p; }; typename detail::storage<3, T, detail::is_aligned::value>::type data; # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR GLM_SWIZZLE3_2_MEMBERS(T, Q, x, y, z) GLM_SWIZZLE3_2_MEMBERS(T, Q, r, g, b) GLM_SWIZZLE3_2_MEMBERS(T, Q, s, t, p) GLM_SWIZZLE3_3_MEMBERS(T, Q, x, y, z) GLM_SWIZZLE3_3_MEMBERS(T, Q, r, g, b) GLM_SWIZZLE3_3_MEMBERS(T, Q, s, t, p) GLM_SWIZZLE3_4_MEMBERS(T, Q, x, y, z) GLM_SWIZZLE3_4_MEMBERS(T, Q, r, g, b) GLM_SWIZZLE3_4_MEMBERS(T, Q, s, t, p) # endif }; # else union { T x, r, s; }; union { T y, g, t; }; union { T z, b, p; }; # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, Q) # endif//GLM_CONFIG_SWIZZLE # endif//GLM_LANG # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif # endif // -- Component accesses -- /// Return the count of components of the vector typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 3;} GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, T, P> const& v); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR vec(T a, T b, T c); // -- Conversion scalar constructors -- template GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(X x, Y y, Z z); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z); template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z); template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z); template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z); // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v); // -- Swizzle constructors -- # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR template GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& that) { *this = that(); } template GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& scalar) { *this = vec(v(), scalar); } template GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& scalar, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v) { *this = vec(scalar, v()); } # endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR // -- Unary arithmetic operators -- GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q>& operator=(vec<3, T, Q> const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator=(vec<3, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(vec<3, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(vec<3, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(vec<3, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(vec<3, U, Q> const& v); // -- Increment and decrement operators -- GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator++(); GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator--(); GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator++(int); GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator--(int); // -- Unary bit operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(vec<3, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(vec<3, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(vec<3, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(vec<3, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(vec<3, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(vec<3, U, Q> const& v); }; // -- Unary operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v); // -- Binary operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator~(vec<3, T, Q> const& v); // -- Boolean operators -- template GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_vec3.inl" #endif//GLM_EXTERNAL_TEMPLATE ================================================ FILE: android/src/glm/detail/type_vec3.inl ================================================ /// @ref core #include "compute_vector_relational.hpp" namespace glm { // -- Implicit basic constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec() # if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE : x(0), y(0), z(0) # endif {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, T, Q> const& v) : x(v.x), y(v.y), z(v.z) {} # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, T, P> const& v) : x(v.x), y(v.y), z(v.z) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(T scalar) : x(scalar), y(scalar), z(scalar) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {} // -- Conversion scalar constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.x)) , z(static_cast(v.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, Y _y, Z _z) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z) : x(static_cast(_x.x)) , y(static_cast(_y)) , z(static_cast(_z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z) : x(static_cast(_x)) , y(static_cast(_y.x)) , z(static_cast(_z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z) : x(static_cast(_x.x)) , y(static_cast(_y.x)) , z(static_cast(_z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_z.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z) : x(static_cast(_x.x)) , y(static_cast(_y)) , z(static_cast(_z.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z) : x(static_cast(_x)) , y(static_cast(_y.x)) , z(static_cast(_z.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z) : x(static_cast(_x.x)) , y(static_cast(_y.x)) , z(static_cast(_z.x)) {} // -- Conversion vector constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, B _z) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(A _x, vec<2, B, P> const& _yz) : x(static_cast(_x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz) : x(static_cast(_x.x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) , z(static_cast(v.z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<4, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) , z(static_cast(v.z)) {} // -- Component accesses -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i) { assert(i >= 0 && i < this->length()); switch(i) { default: case 0: return x; case 1: return y; case 2: return z; } } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i) const { assert(i >= 0 && i < this->length()); switch(i) { default: case 0: return x; case 1: return y; case 2: return z; } } // -- Unary arithmetic operators -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, T, Q> const& v) { this->x = v.x; this->y = v.y; this->z = v.z; return *this; } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, U, Q> const& v) { this->x = static_cast(v.x); this->y = static_cast(v.y); this->z = static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(U scalar) { this->x += static_cast(scalar); this->y += static_cast(scalar); this->z += static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<1, U, Q> const& v) { this->x += static_cast(v.x); this->y += static_cast(v.x); this->z += static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<3, U, Q> const& v) { this->x += static_cast(v.x); this->y += static_cast(v.y); this->z += static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(U scalar) { this->x -= static_cast(scalar); this->y -= static_cast(scalar); this->z -= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<1, U, Q> const& v) { this->x -= static_cast(v.x); this->y -= static_cast(v.x); this->z -= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<3, U, Q> const& v) { this->x -= static_cast(v.x); this->y -= static_cast(v.y); this->z -= static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(U scalar) { this->x *= static_cast(scalar); this->y *= static_cast(scalar); this->z *= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<1, U, Q> const& v) { this->x *= static_cast(v.x); this->y *= static_cast(v.x); this->z *= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<3, U, Q> const& v) { this->x *= static_cast(v.x); this->y *= static_cast(v.y); this->z *= static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(U v) { this->x /= static_cast(v); this->y /= static_cast(v); this->z /= static_cast(v); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<1, U, Q> const& v) { this->x /= static_cast(v.x); this->y /= static_cast(v.x); this->z /= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<3, U, Q> const& v) { this->x /= static_cast(v.x); this->y /= static_cast(v.y); this->z /= static_cast(v.z); return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator++() { ++this->x; ++this->y; ++this->z; return *this; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator--() { --this->x; --this->y; --this->z; return *this; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> vec<3, T, Q>::operator++(int) { vec<3, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> vec<3, T, Q>::operator--(int) { vec<3, T, Q> Result(*this); --*this; return Result; } // -- Unary bit operators -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(U scalar) { this->x %= scalar; this->y %= scalar; this->z %= scalar; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<1, U, Q> const& v) { this->x %= v.x; this->y %= v.x; this->z %= v.x; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<3, U, Q> const& v) { this->x %= v.x; this->y %= v.y; this->z %= v.z; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(U scalar) { this->x &= scalar; this->y &= scalar; this->z &= scalar; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<1, U, Q> const& v) { this->x &= v.x; this->y &= v.x; this->z &= v.x; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<3, U, Q> const& v) { this->x &= v.x; this->y &= v.y; this->z &= v.z; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(U scalar) { this->x |= scalar; this->y |= scalar; this->z |= scalar; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<1, U, Q> const& v) { this->x |= v.x; this->y |= v.x; this->z |= v.x; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<3, U, Q> const& v) { this->x |= v.x; this->y |= v.y; this->z |= v.z; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(U scalar) { this->x ^= scalar; this->y ^= scalar; this->z ^= scalar; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<1, U, Q> const& v) { this->x ^= v.x; this->y ^= v.x; this->z ^= v.x; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<3, U, Q> const& v) { this->x ^= v.x; this->y ^= v.y; this->z ^= v.z; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(U scalar) { this->x <<= scalar; this->y <<= scalar; this->z <<= scalar; return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<1, U, Q> const& v) { this->x <<= static_cast(v.x); this->y <<= static_cast(v.x); this->z <<= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<3, U, Q> const& v) { this->x <<= static_cast(v.x); this->y <<= static_cast(v.y); this->z <<= static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(U scalar) { this->x >>= static_cast(scalar); this->y >>= static_cast(scalar); this->z >>= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<1, U, Q> const& v) { this->x >>= static_cast(v.x); this->y >>= static_cast(v.x); this->z >>= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<3, U, Q> const& v) { this->x >>= static_cast(v.x); this->y >>= static_cast(v.y); this->z >>= static_cast(v.z); return *this; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v) { return vec<3, T, Q>( -v.x, -v.y, -v.z); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x + scalar, v.y + scalar, v.z + scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x + scalar.x, v.y + scalar.x, v.z + scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar + v.x, scalar + v.y, scalar + v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x + v.x, scalar.x + v.y, scalar.x + v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x - scalar, v.y - scalar, v.z - scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x - scalar.x, v.y - scalar.x, v.z - scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar - v.x, scalar - v.y, scalar - v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x - v.x, scalar.x - v.y, scalar.x - v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x * scalar, v.y * scalar, v.z * scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x * scalar.x, v.y * scalar.x, v.z * scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar * v.x, scalar * v.y, scalar * v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x * v.x, scalar.x * v.y, scalar.x * v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x * v2.x, v1.y * v2.y, v1.z * v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x / scalar, v.y / scalar, v.z / scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x / scalar.x, v.y / scalar.x, v.z / scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar / v.x, scalar / v.y, scalar / v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x / v.x, scalar.x / v.y, scalar.x / v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x / v2.x, v1.y / v2.y, v1.z / v2.z); } // -- Binary bit operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x % scalar, v.y % scalar, v.z % scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x % scalar.x, v.y % scalar.x, v.z % scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar % v.x, scalar % v.y, scalar % v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x % v.x, scalar.x % v.y, scalar.x % v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x % v2.x, v1.y % v2.y, v1.z % v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x & scalar, v.y & scalar, v.z & scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x & scalar.x, v.y & scalar.x, v.z & scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar & v.x, scalar & v.y, scalar & v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x & v.x, scalar.x & v.y, scalar.x & v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x & v2.x, v1.y & v2.y, v1.z & v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x | scalar, v.y | scalar, v.z | scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x | scalar.x, v.y | scalar.x, v.z | scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar | v.x, scalar | v.y, scalar | v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x | v.x, scalar.x | v.y, scalar.x | v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x | v2.x, v1.y | v2.y, v1.z | v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x ^ scalar, v.y ^ scalar, v.z ^ scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x ^ scalar.x, v.y ^ scalar.x, v.z ^ scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar ^ v.x, scalar ^ v.y, scalar ^ v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x ^ v.x, scalar.x ^ v.y, scalar.x ^ v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x ^ v2.x, v1.y ^ v2.y, v1.z ^ v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x << scalar, v.y << scalar, v.z << scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x << scalar.x, v.y << scalar.x, v.z << scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar << v.x, scalar << v.y, scalar << v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x << v.x, scalar.x << v.y, scalar.x << v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x << v2.x, v1.y << v2.y, v1.z << v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x >> scalar, v.y >> scalar, v.z >> scalar); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x >> scalar.x, v.y >> scalar.x, v.z >> scalar.x); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar >> v.x, scalar >> v.y, scalar >> v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x >> v.x, scalar.x >> v.y, scalar.x >> v.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x >> v2.x, v1.y >> v2.y, v1.z >> v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator~(vec<3, T, Q> const& v) { return vec<3, T, Q>( ~v.x, ~v.y, ~v.z); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return detail::compute_equal::is_iec559>::call(v1.x, v2.x) && detail::compute_equal::is_iec559>::call(v1.y, v2.y) && detail::compute_equal::is_iec559>::call(v1.z, v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return !(v1 == v2); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2) { return vec<3, bool, Q>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2) { return vec<3, bool, Q>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z); } }//namespace glm ================================================ FILE: android/src/glm/detail/type_vec4.hpp ================================================ /// @ref core /// @file glm/detail/type_vec4.hpp #pragma once #include "qualifier.hpp" #if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR # include "_swizzle.hpp" #elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION # include "_swizzle_func.hpp" #endif #include namespace glm { template struct vec<4, T, Q> { // -- Implementation detail -- typedef T value_type; typedef vec<4, T, Q> type; typedef vec<4, bool, Q> bool_type; // -- Data -- # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # elif GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union # endif # endif # if GLM_CONFIG_XYZW_ONLY T x, y, z, w; # elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE union { struct { T x, y, z, w; }; struct { T r, g, b, a; }; struct { T s, t, p, q; }; typename detail::storage<4, T, detail::is_aligned::value>::type data; # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR GLM_SWIZZLE4_2_MEMBERS(T, Q, x, y, z, w) GLM_SWIZZLE4_2_MEMBERS(T, Q, r, g, b, a) GLM_SWIZZLE4_2_MEMBERS(T, Q, s, t, p, q) GLM_SWIZZLE4_3_MEMBERS(T, Q, x, y, z, w) GLM_SWIZZLE4_3_MEMBERS(T, Q, r, g, b, a) GLM_SWIZZLE4_3_MEMBERS(T, Q, s, t, p, q) GLM_SWIZZLE4_4_MEMBERS(T, Q, x, y, z, w) GLM_SWIZZLE4_4_MEMBERS(T, Q, r, g, b, a) GLM_SWIZZLE4_4_MEMBERS(T, Q, s, t, p, q) # endif }; # else union { T x, r, s; }; union { T y, g, t; }; union { T z, b, p; }; union { T w, a, q; }; # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, Q) # endif # endif # if GLM_SILENT_WARNINGS == GLM_ENABLE # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # elif GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif # endif // -- Component accesses -- typedef length_t length_type; /// Return the count of components of the vector GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;} GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i); GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, Q> const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, P> const& v); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR vec(T x, T y, T z, T w); // -- Conversion scalar constructors -- template GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, Z _z, W _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z, W _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z, W _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, W _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z, W _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, W _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z, vec<1, W, Q> const& _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w); template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _Y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w); // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z, C _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, C _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z, vec<1, C, P> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, vec<1, C, P> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz, C _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, C _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, B _y, vec<2, C, P> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, B _y, vec<2, C, P> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, P> const& _xyz, B _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, P> const& _xyz, vec<1, B, P> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<3, B, P> const& _yzw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<3, B, P> const& _yzw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<2, B, P> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v); // -- Swizzle constructors -- # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR template GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<4, T, Q, E0, E1, E2, E3> const& that) { *this = that(); } template GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, detail::_swizzle<2, T, Q, F0, F1, -1, -2> const& u) { *this = vec<4, T, Q>(v(), u()); } template GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, T const& y, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v) { *this = vec<4, T, Q>(x, y, v()); } template GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& w) { *this = vec<4, T, Q>(x, v(), w); } template GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& z, T const& w) { *this = vec<4, T, Q>(v(), z, w); } template GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v, T const& w) { *this = vec<4, T, Q>(v(), w); } template GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v) { *this = vec<4, T, Q>(x, v()); } # endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR // -- Unary arithmetic operators -- GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, T, Q> const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(vec<4, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(vec<4, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(vec<4, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(vec<4, U, Q> const& v); // -- Increment and decrement operators -- GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator++(); GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator--(); GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator++(int); GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator--(int); // -- Unary bit operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(vec<4, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(vec<4, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(vec<4, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(vec<4, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(vec<4, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(U scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(vec<1, U, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(vec<4, U, Q> const& v); }; // -- Unary operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v); // -- Binary operators -- template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v, T const & scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v, T const & scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, T const & scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v, T const & scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator~(vec<4, T, Q> const& v); // -- Boolean operators -- template GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> operator&&(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2); template GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> operator||(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_vec4.inl" #endif//GLM_EXTERNAL_TEMPLATE ================================================ FILE: android/src/glm/detail/type_vec4.inl ================================================ /// @ref core #include "compute_vector_relational.hpp" namespace glm{ namespace detail { template struct compute_vec4_add { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); } }; template struct compute_vec4_sub { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w); } }; template struct compute_vec4_mul { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); } }; template struct compute_vec4_div { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w); } }; template struct compute_vec4_mod { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x % b.x, a.y % b.y, a.z % b.z, a.w % b.w); } }; template struct compute_vec4_and { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x & b.x, a.y & b.y, a.z & b.z, a.w & b.w); } }; template struct compute_vec4_or { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x | b.x, a.y | b.y, a.z | b.z, a.w | b.w); } }; template struct compute_vec4_xor { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w); } }; template struct compute_vec4_shift_left { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x << b.x, a.y << b.y, a.z << b.z, a.w << b.w); } }; template struct compute_vec4_shift_right { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x >> b.x, a.y >> b.y, a.z >> b.z, a.w >> b.w); } }; template struct compute_vec4_equal { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return detail::compute_equal::is_iec559>::call(v1.x, v2.x) && detail::compute_equal::is_iec559>::call(v1.y, v2.y) && detail::compute_equal::is_iec559>::call(v1.z, v2.z) && detail::compute_equal::is_iec559>::call(v1.w, v2.w); } }; template struct compute_vec4_nequal { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return !compute_vec4_equal::value, sizeof(T) * 8, detail::is_aligned::value>::call(v1, v2); } }; template struct compute_vec4_bitwise_not { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& v) { return vec<4, T, Q>(~v.x, ~v.y, ~v.z, ~v.w); } }; }//namespace detail // -- Implicit basic constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec() # if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE : x(0), y(0), z(0), w(0) # endif {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, T, Q> const& v) : x(v.x), y(v.y), z(v.z), w(v.w) {} # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, T, P> const& v) : x(v.x), y(v.y), z(v.z), w(v.w) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(T scalar) : x(scalar), y(scalar), z(scalar), w(scalar) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(T _x, T _y, T _z, T _w) : x(_x), y(_y), z(_z), w(_w) {} // -- Conversion scalar constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.x)) , z(static_cast(v.x)) , w(static_cast(v.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, Y _y, Z _z, W _w) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_z)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z, W _w) : x(static_cast(_x.x)) , y(static_cast(_y)) , z(static_cast(_z)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z, W _w) : x(static_cast(_x)) , y(static_cast(_y.x)) , z(static_cast(_z)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, W _w) : x(static_cast(_x.x)) , y(static_cast(_y.x)) , z(static_cast(_z)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z, W _w) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_z.x)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, W _w) : x(static_cast(_x.x)) , y(static_cast(_y)) , z(static_cast(_z.x)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w) : x(static_cast(_x)) , y(static_cast(_y.x)) , z(static_cast(_z.x)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w) : x(static_cast(_x.x)) , y(static_cast(_y.x)) , z(static_cast(_z.x)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z, vec<1, W, Q> const& _w) : x(static_cast(_x.x)) , y(static_cast(_y)) , z(static_cast(_z)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w) : x(static_cast(_x)) , y(static_cast(_y.x)) , z(static_cast(_z)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w) : x(static_cast(_x.x)) , y(static_cast(_y.x)) , z(static_cast(_z)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_z.x)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w) : x(static_cast(_x.x)) , y(static_cast(_y)) , z(static_cast(_z.x)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w) : x(static_cast(_x)) , y(static_cast(_y.x)) , z(static_cast(_z.x)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w) : x(static_cast(_x.x)) , y(static_cast(_y.x)) , z(static_cast(_z.x)) , w(static_cast(_w.x)) {} // -- Conversion vector constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, B _z, C _w) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, C _w) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z.x)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, B _z, vec<1, C, P> const& _w) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, vec<1, C, P> const& _w) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z.x)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<2, B, P> const& _yz, C _w) : x(static_cast(_x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, C _w) : x(static_cast(_x.x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w) : x(static_cast(_x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w) : x(static_cast(_x.x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, B _y, vec<2, C, P> const& _zw) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_zw.x)) , w(static_cast(_zw.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, B _y, vec<2, C, P> const& _zw) : x(static_cast(_x.x)) , y(static_cast(_y)) , z(static_cast(_zw.x)) , w(static_cast(_zw.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw) : x(static_cast(_x)) , y(static_cast(_y.x)) , z(static_cast(_zw.x)) , w(static_cast(_zw.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw) : x(static_cast(_x.x)) , y(static_cast(_y.x)) , z(static_cast(_zw.x)) , w(static_cast(_zw.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<3, A, P> const& _xyz, B _w) : x(static_cast(_xyz.x)) , y(static_cast(_xyz.y)) , z(static_cast(_xyz.z)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<3, A, P> const& _xyz, vec<1, B, P> const& _w) : x(static_cast(_xyz.x)) , y(static_cast(_xyz.y)) , z(static_cast(_xyz.z)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<3, B, P> const& _yzw) : x(static_cast(_x)) , y(static_cast(_yzw.x)) , z(static_cast(_yzw.y)) , w(static_cast(_yzw.z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<3, B, P> const& _yzw) : x(static_cast(_x.x)) , y(static_cast(_yzw.x)) , z(static_cast(_yzw.y)) , w(static_cast(_yzw.z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<2, B, P> const& _zw) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_zw.x)) , w(static_cast(_zw.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) , z(static_cast(v.z)) , w(static_cast(v.w)) {} // -- Component accesses -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i) { assert(i >= 0 && i < this->length()); switch(i) { default: case 0: return x; case 1: return y; case 2: return z; case 3: return w; } } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i) const { assert(i >= 0 && i < this->length()); switch(i) { default: case 0: return x; case 1: return y; case 2: return z; case 3: return w; } } // -- Unary arithmetic operators -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, T, Q> const& v) { this->x = v.x; this->y = v.y; this->z = v.z; this->w = v.w; return *this; } # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, U, Q> const& v) { this->x = static_cast(v.x); this->y = static_cast(v.y); this->z = static_cast(v.z); this->w = static_cast(v.w); return *this; } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator+=(U scalar) { return (*this = detail::compute_vec4_add::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator+=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_add::value>::call(*this, vec<4, T, Q>(v.x))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator+=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_add::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator-=(U scalar) { return (*this = detail::compute_vec4_sub::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator-=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_sub::value>::call(*this, vec<4, T, Q>(v.x))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator-=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_sub::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator*=(U scalar) { return (*this = detail::compute_vec4_mul::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator*=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_mul::value>::call(*this, vec<4, T, Q>(v.x))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator*=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_mul::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator/=(U scalar) { return (*this = detail::compute_vec4_div::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator/=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_div::value>::call(*this, vec<4, T, Q>(v.x))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator/=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_div::value>::call(*this, vec<4, T, Q>(v))); } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator++() { ++this->x; ++this->y; ++this->z; ++this->w; return *this; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator--() { --this->x; --this->y; --this->z; --this->w; return *this; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> vec<4, T, Q>::operator++(int) { vec<4, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> vec<4, T, Q>::operator--(int) { vec<4, T, Q> Result(*this); --*this; return Result; } // -- Unary bit operators -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator%=(U scalar) { return (*this = detail::compute_vec4_mod::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator%=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_mod::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator%=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_mod::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator&=(U scalar) { return (*this = detail::compute_vec4_and::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator&=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_and::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator&=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_and::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator|=(U scalar) { return (*this = detail::compute_vec4_or::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator|=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_or::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator|=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_or::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator^=(U scalar) { return (*this = detail::compute_vec4_xor::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator^=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_xor::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator^=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_xor::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator<<=(U scalar) { return (*this = detail::compute_vec4_shift_left::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator<<=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_shift_left::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator<<=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_shift_left::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator>>=(U scalar) { return (*this = detail::compute_vec4_shift_right::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator>>=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_shift_right::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator>>=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_shift_right::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } // -- Unary constant operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v) { return vec<4, T, Q>(0) -= v; } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v, T const & scalar) { return vec<4, T, Q>(v) += scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) += v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(v) += scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v2) += v1; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) += v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v, T const & scalar) { return vec<4, T, Q>(v) -= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) -= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) -= v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) -= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) -= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, T const & scalar) { return vec<4, T, Q>(v) *= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) *= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(v) *= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v2) *= v1; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) *= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v, T const & scalar) { return vec<4, T, Q>(v) /= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) /= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) /= v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) /= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) /= v2; } // -- Binary bit operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) %= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) %= v2.x; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) %= v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar.x) %= v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) %= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) &= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<4, T, Q>(v) &= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) &= v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) &= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) &= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) |= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) |= v2.x; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) |= v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) |= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) |= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) ^= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) ^= v2.x; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) ^= v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) ^= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) ^= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) <<= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) <<= v2.x; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) <<= v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) <<= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) <<= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) >>= scalar; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) >>= v2.x; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) >>= v; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) >>= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) >>= v2; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator~(vec<4, T, Q> const& v) { return detail::compute_vec4_bitwise_not::value, sizeof(T) * 8, detail::is_aligned::value>::call(v); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return detail::compute_vec4_equal::value, sizeof(T) * 8, detail::is_aligned::value>::call(v1, v2); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return detail::compute_vec4_nequal::value, sizeof(T) * 8, detail::is_aligned::value>::call(v1, v2); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> operator&&(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2) { return vec<4, bool, Q>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z, v1.w && v2.w); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> operator||(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2) { return vec<4, bool, Q>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z, v1.w || v2.w); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "type_vec4_simd.inl" #endif ================================================ FILE: android/src/glm/detail/type_vec4_simd.inl ================================================ #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { # if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR template struct _swizzle_base1<4, float, Q, E0,E1,E2,E3, true> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, float, Q> operator ()() const { __m128 data = *reinterpret_cast<__m128 const*>(&this->_buffer); vec<4, float, Q> Result; # if GLM_ARCH & GLM_ARCH_AVX_BIT Result.data = _mm_permute_ps(data, _MM_SHUFFLE(E3, E2, E1, E0)); # else Result.data = _mm_shuffle_ps(data, data, _MM_SHUFFLE(E3, E2, E1, E0)); # endif return Result; } }; template struct _swizzle_base1<4, int, Q, E0,E1,E2,E3, true> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, int, Q> operator ()() const { __m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer); vec<4, int, Q> Result; Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0)); return Result; } }; template struct _swizzle_base1<4, uint, Q, E0,E1,E2,E3, true> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, uint, Q> operator ()() const { __m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer); vec<4, uint, Q> Result; Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0)); return Result; } }; # endif// GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR template struct compute_vec4_add { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = _mm_add_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_vec4_add { static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b) { vec<4, double, Q> Result; Result.data = _mm256_add_pd(a.data, b.data); return Result; } }; # endif template struct compute_vec4_sub { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = _mm_sub_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_vec4_sub { static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b) { vec<4, double, Q> Result; Result.data = _mm256_sub_pd(a.data, b.data); return Result; } }; # endif template struct compute_vec4_mul { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = _mm_mul_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_vec4_mul { static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b) { vec<4, double, Q> Result; Result.data = _mm256_mul_pd(a.data, b.data); return Result; } }; # endif template struct compute_vec4_div { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = _mm_div_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_vec4_div { static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b) { vec<4, double, Q> Result; Result.data = _mm256_div_pd(a.data, b.data); return Result; } }; # endif template<> struct compute_vec4_div { static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& a, vec<4, float, aligned_lowp> const& b) { vec<4, float, aligned_lowp> Result; Result.data = _mm_mul_ps(a.data, _mm_rcp_ps(b.data)); return Result; } }; template struct compute_vec4_and { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_and_si128(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_and { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_and_si256(a.data, b.data); return Result; } }; # endif template struct compute_vec4_or { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_or_si128(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_or { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_or_si256(a.data, b.data); return Result; } }; # endif template struct compute_vec4_xor { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_xor_si128(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_xor { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_xor_si256(a.data, b.data); return Result; } }; # endif template struct compute_vec4_shift_left { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_sll_epi32(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_shift_left { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_sll_epi64(a.data, b.data); return Result; } }; # endif template struct compute_vec4_shift_right { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_srl_epi32(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_shift_right { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_srl_epi64(a.data, b.data); return Result; } }; # endif template struct compute_vec4_bitwise_not { static vec<4, T, Q> call(vec<4, T, Q> const& v) { vec<4, T, Q> Result; Result.data = _mm_xor_si128(v.data, _mm_set1_epi32(-1)); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_bitwise_not { static vec<4, T, Q> call(vec<4, T, Q> const& v) { vec<4, T, Q> Result; Result.data = _mm256_xor_si256(v.data, _mm_set1_epi32(-1)); return Result; } }; # endif template struct compute_vec4_equal { static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { return _mm_movemask_ps(_mm_cmpeq_ps(v1.data, v2.data)) != 0; } }; # if GLM_ARCH & GLM_ARCH_SSE41_BIT template struct compute_vec4_equal { static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2) { //return _mm_movemask_epi8(_mm_cmpeq_epi32(v1.data, v2.data)) != 0; __m128i neq = _mm_xor_si128(v1.data, v2.data); return _mm_test_all_zeros(neq, neq) == 0; } }; # endif template struct compute_vec4_nequal { static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { return _mm_movemask_ps(_mm_cmpneq_ps(v1.data, v2.data)) != 0; } }; # if GLM_ARCH & GLM_ARCH_SSE41_BIT template struct compute_vec4_nequal { static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2) { //return _mm_movemask_epi8(_mm_cmpneq_epi32(v1.data, v2.data)) != 0; __m128i neq = _mm_xor_si128(v1.data, v2.data); return _mm_test_all_zeros(neq, neq) != 0; } }; # endif }//namespace detail template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _s) : data(_mm_set1_ps(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _s) : data(_mm_set1_ps(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _s) : data(_mm_set1_ps(_s)) {} # if GLM_ARCH & GLM_ARCH_AVX_BIT template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_lowp>::vec(double _s) : data(_mm256_set1_pd(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_mediump>::vec(double _s) : data(_mm256_set1_pd(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_highp>::vec(double _s) : data(_mm256_set1_pd(_s)) {} # endif template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _s) : data(_mm_set1_epi32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _s) : data(_mm_set1_epi32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _s) : data(_mm_set1_epi32(_s)) {} # if GLM_ARCH & GLM_ARCH_AVX2_BIT template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_lowp>::vec(detail::int64 _s) : data(_mm256_set1_epi64x(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_mediump>::vec(detail::int64 _s) : data(_mm256_set1_epi64x(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_highp>::vec(detail::int64 _s) : data(_mm256_set1_epi64x(_s)) {} # endif template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _x, float _y, float _z, float _w) : data(_mm_set_ps(_w, _z, _y, _x)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _x, float _y, float _z, float _w) : data(_mm_set_ps(_w, _z, _y, _x)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _x, float _y, float _z, float _w) : data(_mm_set_ps(_w, _z, _y, _x)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _x, int _y, int _z, int _w) : data(_mm_set_epi32(_w, _z, _y, _x)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _x, int _y, int _z, int _w) : data(_mm_set_epi32(_w, _z, _y, _x)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _x, int _y, int _z, int _w) : data(_mm_set_epi32(_w, _z, _y, _x)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(int _x, int _y, int _z, int _w) : data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x))) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(int _x, int _y, int _z, int _w) : data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x))) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(int _x, int _y, int _z, int _w) : data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x))) {} }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT #if GLM_ARCH & GLM_ARCH_NEON_BIT namespace glm { namespace detail { template struct compute_vec4_add { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = vaddq_f32(a.data, b.data); return Result; } }; template struct compute_vec4_add { static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b) { vec<4, uint, Q> Result; Result.data = vaddq_u32(a.data, b.data); return Result; } }; template struct compute_vec4_add { static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b) { vec<4, uint, Q> Result; Result.data = vaddq_s32(a.data, b.data); return Result; } }; template struct compute_vec4_sub { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = vsubq_f32(a.data, b.data); return Result; } }; template struct compute_vec4_sub { static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b) { vec<4, uint, Q> Result; Result.data = vsubq_u32(a.data, b.data); return Result; } }; template struct compute_vec4_sub { static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b) { vec<4, int, Q> Result; Result.data = vsubq_s32(a.data, b.data); return Result; } }; template struct compute_vec4_mul { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = vmulq_f32(a.data, b.data); return Result; } }; template struct compute_vec4_mul { static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b) { vec<4, uint, Q> Result; Result.data = vmulq_u32(a.data, b.data); return Result; } }; template struct compute_vec4_mul { static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b) { vec<4, int, Q> Result; Result.data = vmulq_s32(a.data, b.data); return Result; } }; template struct compute_vec4_div { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = vdivq_f32(a.data, b.data); return Result; } }; template struct compute_vec4_equal { static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { uint32x4_t cmp = vceqq_f32(v1.data, v2.data); #if GLM_ARCH & GLM_ARCH_ARMV8_BIT cmp = vpminq_u32(cmp, cmp); cmp = vpminq_u32(cmp, cmp); uint32_t r = cmp[0]; #else uint32x2_t cmpx2 = vpmin_u32(vget_low_f32(cmp), vget_high_f32(cmp)); cmpx2 = vpmin_u32(cmpx2, cmpx2); uint32_t r = cmpx2[0]; #endif return r == ~0u; } }; template struct compute_vec4_equal { static bool call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2) { uint32x4_t cmp = vceqq_u32(v1.data, v2.data); #if GLM_ARCH & GLM_ARCH_ARMV8_BIT cmp = vpminq_u32(cmp, cmp); cmp = vpminq_u32(cmp, cmp); uint32_t r = cmp[0]; #else uint32x2_t cmpx2 = vpmin_u32(vget_low_f32(cmp), vget_high_f32(cmp)); cmpx2 = vpmin_u32(cmpx2, cmpx2); uint32_t r = cmpx2[0]; #endif return r == ~0u; } }; template struct compute_vec4_equal { static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2) { uint32x4_t cmp = vceqq_s32(v1.data, v2.data); #if GLM_ARCH & GLM_ARCH_ARMV8_BIT cmp = vpminq_u32(cmp, cmp); cmp = vpminq_u32(cmp, cmp); uint32_t r = cmp[0]; #else uint32x2_t cmpx2 = vpmin_u32(vget_low_f32(cmp), vget_high_f32(cmp)); cmpx2 = vpmin_u32(cmpx2, cmpx2); uint32_t r = cmpx2[0]; #endif return r == ~0u; } }; template struct compute_vec4_nequal { static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { return !compute_vec4_equal::call(v1, v2); } }; template struct compute_vec4_nequal { static bool call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2) { return !compute_vec4_equal::call(v1, v2); } }; template struct compute_vec4_nequal { static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2) { return !compute_vec4_equal::call(v1, v2); } }; }//namespace detail #if !GLM_CONFIG_XYZW_ONLY template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _s) : data(vdupq_n_f32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _s) : data(vdupq_n_f32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _s) : data(vdupq_n_f32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _s) : data(vdupq_n_s32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _s) : data(vdupq_n_s32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _s) : data(vdupq_n_s32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, uint, aligned_lowp>::vec(uint _s) : data(vdupq_n_u32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, uint, aligned_mediump>::vec(uint _s) : data(vdupq_n_u32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, uint, aligned_highp>::vec(uint _s) : data(vdupq_n_u32(_s)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(const vec<4, float, aligned_highp>& rhs) : data(rhs.data) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(const vec<4, int, aligned_highp>& rhs) : data(vcvtq_f32_s32(rhs.data)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(const vec<4, uint, aligned_highp>& rhs) : data(vcvtq_f32_u32(rhs.data)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(int _x, int _y, int _z, int _w) : data(vcvtq_f32_s32(vec<4, int, aligned_lowp>(_x, _y, _z, _w).data)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(int _x, int _y, int _z, int _w) : data(vcvtq_f32_s32(vec<4, int, aligned_mediump>(_x, _y, _z, _w).data)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(int _x, int _y, int _z, int _w) : data(vcvtq_f32_s32(vec<4, int, aligned_highp>(_x, _y, _z, _w).data)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(uint _x, uint _y, uint _z, uint _w) : data(vcvtq_f32_u32(vec<4, uint, aligned_lowp>(_x, _y, _z, _w).data)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(uint _x, uint _y, uint _z, uint _w) : data(vcvtq_f32_u32(vec<4, uint, aligned_mediump>(_x, _y, _z, _w).data)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(uint _x, uint _y, uint _z, uint _w) : data(vcvtq_f32_u32(vec<4, uint, aligned_highp>(_x, _y, _z, _w).data)) {} #endif }//namespace glm #endif ================================================ FILE: android/src/glm/exponential.hpp ================================================ /// @ref core /// @file glm/exponential.hpp /// /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions /// /// @defgroup core_func_exponential Exponential functions /// @ingroup core /// /// Provides GLSL exponential functions /// /// These all operate component-wise. The description is per component. /// /// Include to use these core features. #pragma once #include "detail/type_vec1.hpp" #include "detail/type_vec2.hpp" #include "detail/type_vec3.hpp" #include "detail/type_vec4.hpp" #include namespace glm { /// @addtogroup core_func_exponential /// @{ /// Returns 'base' raised to the power 'exponent'. /// /// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type qualifier. /// @param exponent Floating point value representing the 'exponent'. /// /// @see GLSL pow man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec pow(vec const& base, vec const& exponent); /// Returns the natural exponentiation of x, i.e., e^x. /// /// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL exp man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec exp(vec const& v); /// Returns the natural logarithm of v, i.e., /// returns the value y which satisfies the equation x = e^y. /// Results are undefined if v <= 0. /// /// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL log man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec log(vec const& v); /// Returns 2 raised to the v power. /// /// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL exp2 man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec exp2(vec const& v); /// Returns the base 2 log of x, i.e., returns the value y, /// which satisfies the equation x = 2 ^ y. /// /// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL log2 man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec log2(vec const& v); /// Returns the positive square root of v. /// /// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL sqrt man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec sqrt(vec const& v); /// Returns the reciprocal of the positive square root of v. /// /// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL inversesqrt man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec inversesqrt(vec const& v); /// @} }//namespace glm #include "detail/func_exponential.inl" ================================================ FILE: android/src/glm/ext/matrix_clip_space.hpp ================================================ /// @ref ext_matrix_clip_space /// @file glm/ext/matrix_clip_space.hpp /// /// @defgroup ext_matrix_clip_space GLM_EXT_matrix_clip_space /// @ingroup ext /// /// Defines functions that generate clip space transformation matrices. /// /// The matrices generated by this extension use standard OpenGL fixed-function /// conventions. For example, the lookAt function generates a transform from world /// space into the specific eye space that the projective matrix functions /// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility /// specifications defines the particular layout of this eye space. /// /// Include to use the features of this extension. /// /// @see ext_matrix_transform /// @see ext_matrix_projection #pragma once // Dependencies #include "../ext/scalar_constants.hpp" #include "../geometric.hpp" #include "../trigonometric.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_clip_space extension included") #endif namespace glm { /// @addtogroup ext_matrix_clip_space /// @{ /// Creates a matrix for projecting two-dimensional coordinates onto the screen. /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top, T const& zNear, T const& zFar) /// @see gluOrtho2D man page template GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho( T left, T right, T bottom, T top); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_ZO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume using right-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_NO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_ZO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_NO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoZO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoNO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using the default handedness and default near and far clip planes definition. /// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @tparam T A floating-point scalar type /// /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see glOrtho man page template GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a left handed frustum matrix. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_ZO( T left, T right, T bottom, T top, T near, T far); /// Creates a left handed frustum matrix. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_NO( T left, T right, T bottom, T top, T near, T far); /// Creates a right handed frustum matrix. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_ZO( T left, T right, T bottom, T top, T near, T far); /// Creates a right handed frustum matrix. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_NO( T left, T right, T bottom, T top, T near, T far); /// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumZO( T left, T right, T bottom, T top, T near, T far); /// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumNO( T left, T right, T bottom, T top, T near, T far); /// Creates a left handed frustum matrix. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH( T left, T right, T bottom, T top, T near, T far); /// Creates a right handed frustum matrix. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH( T left, T right, T bottom, T top, T near, T far); /// Creates a frustum matrix with default handedness, using the default handedness and default near and far clip planes definition. /// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @tparam T A floating-point scalar type /// @see glFrustum man page template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustum( T left, T right, T bottom, T top, T near, T far); /// Creates a matrix for a right handed, symetric perspective-view frustum. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_ZO( T fovy, T aspect, T near, T far); /// Creates a matrix for a right handed, symetric perspective-view frustum. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_NO( T fovy, T aspect, T near, T far); /// Creates a matrix for a left handed, symetric perspective-view frustum. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_ZO( T fovy, T aspect, T near, T far); /// Creates a matrix for a left handed, symetric perspective-view frustum. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_NO( T fovy, T aspect, T near, T far); /// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveZO( T fovy, T aspect, T near, T far); /// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveNO( T fovy, T aspect, T near, T far); /// Creates a matrix for a right handed, symetric perspective-view frustum. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH( T fovy, T aspect, T near, T far); /// Creates a matrix for a left handed, symetric perspective-view frustum. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH( T fovy, T aspect, T near, T far); /// Creates a matrix for a symetric perspective-view frustum based on the default handedness and default near and far clip planes definition. /// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @param fovy Specifies the field of view angle in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type /// @see gluPerspective man page template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspective( T fovy, T aspect, T near, T far); /// Builds a perspective projection matrix based on a field of view using right-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_ZO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using right-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_NO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_ZO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_NO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovZO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovNO( T fov, T width, T height, T near, T far); /// Builds a right handed perspective projection matrix based on a field of view. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH( T fov, T width, T height, T near, T far); /// Builds a left handed perspective projection matrix based on a field of view. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view and the default handedness and default near and far clip planes definition. /// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov( T fov, T width, T height, T near, T far); /// Creates a matrix for a left handed, symmetric perspective-view frustum with far plane at infinite. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveLH( T fovy, T aspect, T near); /// Creates a matrix for a right handed, symmetric perspective-view frustum with far plane at infinite. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH( T fovy, T aspect, T near); /// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite with default handedness. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective( T fovy, T aspect, T near); /// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective( T fovy, T aspect, T near); /// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param ep Epsilon /// /// @tparam T A floating-point scalar type template GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective( T fovy, T aspect, T near, T ep); /// @} }//namespace glm #include "matrix_clip_space.inl" ================================================ FILE: android/src/glm/ext/matrix_clip_space.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top) { mat<4, 4, T, defaultp> Result(static_cast(1)); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[2][2] = - static_cast(1); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_ZO(T left, T right, T bottom, T top, T zNear, T zFar) { mat<4, 4, T, defaultp> Result(1); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[2][2] = static_cast(1) / (zFar - zNear); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); Result[3][2] = - zNear / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_NO(T left, T right, T bottom, T top, T zNear, T zFar) { mat<4, 4, T, defaultp> Result(1); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[2][2] = static_cast(2) / (zFar - zNear); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); Result[3][2] = - (zFar + zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_ZO(T left, T right, T bottom, T top, T zNear, T zFar) { mat<4, 4, T, defaultp> Result(1); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[2][2] = - static_cast(1) / (zFar - zNear); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); Result[3][2] = - zNear / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_NO(T left, T right, T bottom, T top, T zNear, T zFar) { mat<4, 4, T, defaultp> Result(1); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[2][2] = - static_cast(2) / (zFar - zNear); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); Result[3][2] = - (zFar + zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoZO(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return orthoLH_ZO(left, right, bottom, top, zNear, zFar); # else return orthoRH_ZO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoNO(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return orthoLH_NO(left, right, bottom, top, zNear, zFar); # else return orthoRH_NO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return orthoLH_ZO(left, right, bottom, top, zNear, zFar); # else return orthoLH_NO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return orthoRH_ZO(left, right, bottom, top, zNear, zFar); # else return orthoRH_NO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO return orthoLH_ZO(left, right, bottom, top, zNear, zFar); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO return orthoLH_NO(left, right, bottom, top, zNear, zFar); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO return orthoRH_ZO(left, right, bottom, top, zNear, zFar); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO return orthoRH_NO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal) { mat<4, 4, T, defaultp> Result(0); Result[0][0] = (static_cast(2) * nearVal) / (right - left); Result[1][1] = (static_cast(2) * nearVal) / (top - bottom); Result[2][0] = (right + left) / (right - left); Result[2][1] = (top + bottom) / (top - bottom); Result[2][2] = farVal / (farVal - nearVal); Result[2][3] = static_cast(1); Result[3][2] = -(farVal * nearVal) / (farVal - nearVal); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_NO(T left, T right, T bottom, T top, T nearVal, T farVal) { mat<4, 4, T, defaultp> Result(0); Result[0][0] = (static_cast(2) * nearVal) / (right - left); Result[1][1] = (static_cast(2) * nearVal) / (top - bottom); Result[2][0] = (right + left) / (right - left); Result[2][1] = (top + bottom) / (top - bottom); Result[2][2] = (farVal + nearVal) / (farVal - nearVal); Result[2][3] = static_cast(1); Result[3][2] = - (static_cast(2) * farVal * nearVal) / (farVal - nearVal); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal) { mat<4, 4, T, defaultp> Result(0); Result[0][0] = (static_cast(2) * nearVal) / (right - left); Result[1][1] = (static_cast(2) * nearVal) / (top - bottom); Result[2][0] = (right + left) / (right - left); Result[2][1] = (top + bottom) / (top - bottom); Result[2][2] = farVal / (nearVal - farVal); Result[2][3] = static_cast(-1); Result[3][2] = -(farVal * nearVal) / (farVal - nearVal); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_NO(T left, T right, T bottom, T top, T nearVal, T farVal) { mat<4, 4, T, defaultp> Result(0); Result[0][0] = (static_cast(2) * nearVal) / (right - left); Result[1][1] = (static_cast(2) * nearVal) / (top - bottom); Result[2][0] = (right + left) / (right - left); Result[2][1] = (top + bottom) / (top - bottom); Result[2][2] = - (farVal + nearVal) / (farVal - nearVal); Result[2][3] = static_cast(-1); Result[3][2] = - (static_cast(2) * farVal * nearVal) / (farVal - nearVal); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumZO(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return frustumLH_ZO(left, right, bottom, top, nearVal, farVal); # else return frustumRH_ZO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumNO(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return frustumLH_NO(left, right, bottom, top, nearVal, farVal); # else return frustumRH_NO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return frustumLH_ZO(left, right, bottom, top, nearVal, farVal); # else return frustumLH_NO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return frustumRH_ZO(left, right, bottom, top, nearVal, farVal); # else return frustumRH_NO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustum(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO return frustumLH_ZO(left, right, bottom, top, nearVal, farVal); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO return frustumLH_NO(left, right, bottom, top, nearVal, farVal); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO return frustumRH_ZO(left, right, bottom, top, nearVal, farVal); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO return frustumRH_NO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_ZO(T fovy, T aspect, T zNear, T zFar) { assert(abs(aspect - std::numeric_limits::epsilon()) > static_cast(0)); T const tanHalfFovy = tan(fovy / static_cast(2)); mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = static_cast(1) / (aspect * tanHalfFovy); Result[1][1] = static_cast(1) / (tanHalfFovy); Result[2][2] = zFar / (zNear - zFar); Result[2][3] = - static_cast(1); Result[3][2] = -(zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_NO(T fovy, T aspect, T zNear, T zFar) { assert(abs(aspect - std::numeric_limits::epsilon()) > static_cast(0)); T const tanHalfFovy = tan(fovy / static_cast(2)); mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = static_cast(1) / (aspect * tanHalfFovy); Result[1][1] = static_cast(1) / (tanHalfFovy); Result[2][2] = - (zFar + zNear) / (zFar - zNear); Result[2][3] = - static_cast(1); Result[3][2] = - (static_cast(2) * zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_ZO(T fovy, T aspect, T zNear, T zFar) { assert(abs(aspect - std::numeric_limits::epsilon()) > static_cast(0)); T const tanHalfFovy = tan(fovy / static_cast(2)); mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = static_cast(1) / (aspect * tanHalfFovy); Result[1][1] = static_cast(1) / (tanHalfFovy); Result[2][2] = zFar / (zFar - zNear); Result[2][3] = static_cast(1); Result[3][2] = -(zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_NO(T fovy, T aspect, T zNear, T zFar) { assert(abs(aspect - std::numeric_limits::epsilon()) > static_cast(0)); T const tanHalfFovy = tan(fovy / static_cast(2)); mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = static_cast(1) / (aspect * tanHalfFovy); Result[1][1] = static_cast(1) / (tanHalfFovy); Result[2][2] = (zFar + zNear) / (zFar - zNear); Result[2][3] = static_cast(1); Result[3][2] = - (static_cast(2) * zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveZO(T fovy, T aspect, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return perspectiveLH_ZO(fovy, aspect, zNear, zFar); # else return perspectiveRH_ZO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveNO(T fovy, T aspect, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return perspectiveLH_NO(fovy, aspect, zNear, zFar); # else return perspectiveRH_NO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH(T fovy, T aspect, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return perspectiveLH_ZO(fovy, aspect, zNear, zFar); # else return perspectiveLH_NO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH(T fovy, T aspect, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return perspectiveRH_ZO(fovy, aspect, zNear, zFar); # else return perspectiveRH_NO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspective(T fovy, T aspect, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO return perspectiveLH_ZO(fovy, aspect, zNear, zFar); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO return perspectiveLH_NO(fovy, aspect, zNear, zFar); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO return perspectiveRH_ZO(fovy, aspect, zNear, zFar); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO return perspectiveRH_NO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_ZO(T fov, T width, T height, T zNear, T zFar) { assert(width > static_cast(0)); assert(height > static_cast(0)); assert(fov > static_cast(0)); T const rad = fov; T const h = glm::cos(static_cast(0.5) * rad) / glm::sin(static_cast(0.5) * rad); T const w = h * height / width; ///todo max(width , Height) / min(width , Height)? mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = w; Result[1][1] = h; Result[2][2] = zFar / (zNear - zFar); Result[2][3] = - static_cast(1); Result[3][2] = -(zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_NO(T fov, T width, T height, T zNear, T zFar) { assert(width > static_cast(0)); assert(height > static_cast(0)); assert(fov > static_cast(0)); T const rad = fov; T const h = glm::cos(static_cast(0.5) * rad) / glm::sin(static_cast(0.5) * rad); T const w = h * height / width; ///todo max(width , Height) / min(width , Height)? mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = w; Result[1][1] = h; Result[2][2] = - (zFar + zNear) / (zFar - zNear); Result[2][3] = - static_cast(1); Result[3][2] = - (static_cast(2) * zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_ZO(T fov, T width, T height, T zNear, T zFar) { assert(width > static_cast(0)); assert(height > static_cast(0)); assert(fov > static_cast(0)); T const rad = fov; T const h = glm::cos(static_cast(0.5) * rad) / glm::sin(static_cast(0.5) * rad); T const w = h * height / width; ///todo max(width , Height) / min(width , Height)? mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = w; Result[1][1] = h; Result[2][2] = zFar / (zFar - zNear); Result[2][3] = static_cast(1); Result[3][2] = -(zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_NO(T fov, T width, T height, T zNear, T zFar) { assert(width > static_cast(0)); assert(height > static_cast(0)); assert(fov > static_cast(0)); T const rad = fov; T const h = glm::cos(static_cast(0.5) * rad) / glm::sin(static_cast(0.5) * rad); T const w = h * height / width; ///todo max(width , Height) / min(width , Height)? mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = w; Result[1][1] = h; Result[2][2] = (zFar + zNear) / (zFar - zNear); Result[2][3] = static_cast(1); Result[3][2] = - (static_cast(2) * zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovZO(T fov, T width, T height, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return perspectiveFovLH_ZO(fov, width, height, zNear, zFar); # else return perspectiveFovRH_ZO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovNO(T fov, T width, T height, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return perspectiveFovLH_NO(fov, width, height, zNear, zFar); # else return perspectiveFovRH_NO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH(T fov, T width, T height, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return perspectiveFovLH_ZO(fov, width, height, zNear, zFar); # else return perspectiveFovLH_NO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH(T fov, T width, T height, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return perspectiveFovRH_ZO(fov, width, height, zNear, zFar); # else return perspectiveFovRH_NO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFov(T fov, T width, T height, T zNear, T zFar) { # if GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO return perspectiveFovLH_ZO(fov, width, height, zNear, zFar); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO return perspectiveFovLH_NO(fov, width, height, zNear, zFar); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO return perspectiveFovRH_ZO(fov, width, height, zNear, zFar); # elif GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO return perspectiveFovRH_NO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveRH(T fovy, T aspect, T zNear) { T const range = tan(fovy / static_cast(2)) * zNear; T const left = -range * aspect; T const right = range * aspect; T const bottom = -range; T const top = range; mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = (static_cast(2) * zNear) / (right - left); Result[1][1] = (static_cast(2) * zNear) / (top - bottom); Result[2][2] = - static_cast(1); Result[2][3] = - static_cast(1); Result[3][2] = - static_cast(2) * zNear; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveLH(T fovy, T aspect, T zNear) { T const range = tan(fovy / static_cast(2)) * zNear; T const left = -range * aspect; T const right = range * aspect; T const bottom = -range; T const top = range; mat<4, 4, T, defaultp> Result(T(0)); Result[0][0] = (static_cast(2) * zNear) / (right - left); Result[1][1] = (static_cast(2) * zNear) / (top - bottom); Result[2][2] = static_cast(1); Result[2][3] = static_cast(1); Result[3][2] = - static_cast(2) * zNear; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspective(T fovy, T aspect, T zNear) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return infinitePerspectiveLH(fovy, aspect, zNear); # else return infinitePerspectiveRH(fovy, aspect, zNear); # endif } // Infinite projection matrix: http://www.terathon.com/gdc07_lengyel.pdf template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear, T ep) { T const range = tan(fovy / static_cast(2)) * zNear; T const left = -range * aspect; T const right = range * aspect; T const bottom = -range; T const top = range; mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = (static_cast(2) * zNear) / (right - left); Result[1][1] = (static_cast(2) * zNear) / (top - bottom); Result[2][2] = ep - static_cast(1); Result[2][3] = static_cast(-1); Result[3][2] = (ep - static_cast(2)) * zNear; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear) { return tweakedInfinitePerspective(fovy, aspect, zNear, epsilon()); } }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_common.hpp ================================================ /// @ref ext_matrix_common /// @file glm/ext/matrix_common.hpp /// /// @defgroup ext_matrix_common GLM_EXT_matrix_common /// @ingroup ext /// /// Defines functions for common matrix operations. /// /// Include to use the features of this extension. /// /// @see ext_matrix_common #pragma once #include "../detail/qualifier.hpp" #include "../detail/_fixes.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_transform extension included") #endif namespace glm { /// @addtogroup ext_matrix_common /// @{ template GLM_FUNC_DECL mat mix(mat const& x, mat const& y, mat const& a); template GLM_FUNC_DECL mat mix(mat const& x, mat const& y, U a); /// @} }//namespace glm #include "matrix_common.inl" ================================================ FILE: android/src/glm/ext/matrix_common.inl ================================================ #include "../matrix.hpp" namespace glm { template GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, U a) { return mat(x) * (static_cast(1) - a) + mat(y) * a; } template GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, mat const& a) { return matrixCompMult(mat(x), static_cast(1) - a) + matrixCompMult(mat(y), a); } }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double2x2.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double2x2.hpp #pragma once #include "../detail/type_mat2x2.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 2 columns of 2 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<2, 2, double, defaultp> dmat2x2; /// 2 columns of 2 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<2, 2, double, defaultp> dmat2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double2x2_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double2x2_precision.hpp #pragma once #include "../detail/type_mat2x2.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 2 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, lowp> lowp_dmat2; /// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, mediump> mediump_dmat2; /// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, highp> highp_dmat2; /// 2 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, lowp> lowp_dmat2x2; /// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, mediump> mediump_dmat2x2; /// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, highp> highp_dmat2x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double2x3.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double2x3.hpp #pragma once #include "../detail/type_mat2x3.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 2 columns of 3 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<2, 3, double, defaultp> dmat2x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double2x3_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double2x3_precision.hpp #pragma once #include "../detail/type_mat2x3.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 2 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, double, lowp> lowp_dmat2x3; /// 2 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, double, mediump> mediump_dmat2x3; /// 2 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, double, highp> highp_dmat2x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double2x4.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double2x4.hpp #pragma once #include "../detail/type_mat2x4.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 2 columns of 4 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<2, 4, double, defaultp> dmat2x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double2x4_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double2x4_precision.hpp #pragma once #include "../detail/type_mat2x4.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 2 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, double, lowp> lowp_dmat2x4; /// 2 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, double, mediump> mediump_dmat2x4; /// 2 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, double, highp> highp_dmat2x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double3x2.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double3x2.hpp #pragma once #include "../detail/type_mat3x2.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 3 columns of 2 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<3, 2, double, defaultp> dmat3x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double3x2_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double3x2_precision.hpp #pragma once #include "../detail/type_mat3x2.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 3 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, double, lowp> lowp_dmat3x2; /// 3 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, double, mediump> mediump_dmat3x2; /// 3 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, double, highp> highp_dmat3x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double3x3.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double3x3.hpp #pragma once #include "../detail/type_mat3x3.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 3 columns of 3 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<3, 3, double, defaultp> dmat3x3; /// 3 columns of 3 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<3, 3, double, defaultp> dmat3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double3x3_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double3x3_precision.hpp #pragma once #include "../detail/type_mat3x3.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 3 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, lowp> lowp_dmat3; /// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, mediump> mediump_dmat3; /// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, highp> highp_dmat3; /// 3 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, lowp> lowp_dmat3x3; /// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, mediump> mediump_dmat3x3; /// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, highp> highp_dmat3x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double3x4.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double3x4.hpp #pragma once #include "../detail/type_mat3x4.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 3 columns of 4 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<3, 4, double, defaultp> dmat3x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double3x4_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double3x4_precision.hpp #pragma once #include "../detail/type_mat3x4.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 3 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, double, lowp> lowp_dmat3x4; /// 3 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, double, mediump> mediump_dmat3x4; /// 3 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, double, highp> highp_dmat3x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double4x2.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double4x2.hpp #pragma once #include "../detail/type_mat4x2.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 4 columns of 2 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<4, 2, double, defaultp> dmat4x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double4x2_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double4x2_precision.hpp #pragma once #include "../detail/type_mat4x2.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 4 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, double, lowp> lowp_dmat4x2; /// 4 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, double, mediump> mediump_dmat4x2; /// 4 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, double, highp> highp_dmat4x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double4x3.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double4x3.hpp #pragma once #include "../detail/type_mat4x3.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 4 columns of 3 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<4, 3, double, defaultp> dmat4x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double4x3_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double4x3_precision.hpp #pragma once #include "../detail/type_mat4x3.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 4 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, double, lowp> lowp_dmat4x3; /// 4 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, double, mediump> mediump_dmat4x3; /// 4 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, double, highp> highp_dmat4x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double4x4.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double4x4.hpp #pragma once #include "../detail/type_mat4x4.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 4 columns of 4 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<4, 4, double, defaultp> dmat4x4; /// 4 columns of 4 components matrix of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<4, 4, double, defaultp> dmat4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_double4x4_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_double4x4_precision.hpp #pragma once #include "../detail/type_mat4x4.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 4 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, lowp> lowp_dmat4; /// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, mediump> mediump_dmat4; /// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, highp> highp_dmat4; /// 4 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, lowp> lowp_dmat4x4; /// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, mediump> mediump_dmat4x4; /// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, highp> highp_dmat4x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float2x2.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float2x2.hpp #pragma once #include "../detail/type_mat2x2.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 2 columns of 2 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<2, 2, float, defaultp> mat2x2; /// 2 columns of 2 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<2, 2, float, defaultp> mat2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float2x2_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float2x2_precision.hpp #pragma once #include "../detail/type_mat2x2.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 2 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2; /// 2 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2; /// 2 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, highp> highp_mat2; /// 2 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2x2; /// 2 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2x2; /// 2 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, highp> highp_mat2x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float2x3.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float2x3.hpp #pragma once #include "../detail/type_mat2x3.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 2 columns of 3 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<2, 3, float, defaultp> mat2x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float2x3_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float2x3_precision.hpp #pragma once #include "../detail/type_mat2x3.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 2 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, lowp> lowp_mat2x3; /// 2 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, mediump> mediump_mat2x3; /// 2 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, highp> highp_mat2x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float2x4.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float2x4.hpp #pragma once #include "../detail/type_mat2x4.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 2 columns of 4 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<2, 4, float, defaultp> mat2x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float2x4_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float2x4_precision.hpp #pragma once #include "../detail/type_mat2x4.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 2 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, lowp> lowp_mat2x4; /// 2 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, mediump> mediump_mat2x4; /// 2 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, highp> highp_mat2x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float3x2.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float3x2.hpp #pragma once #include "../detail/type_mat3x2.hpp" namespace glm { /// @addtogroup core /// @{ /// 3 columns of 2 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<3, 2, float, defaultp> mat3x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float3x2_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float3x2_precision.hpp #pragma once #include "../detail/type_mat3x2.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 3 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, lowp> lowp_mat3x2; /// 3 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, mediump> mediump_mat3x2; /// 3 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, highp> highp_mat3x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float3x3.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float3x3.hpp #pragma once #include "../detail/type_mat3x3.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 3 columns of 3 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<3, 3, float, defaultp> mat3x3; /// 3 columns of 3 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<3, 3, float, defaultp> mat3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float3x3_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float3x3_precision.hpp #pragma once #include "../detail/type_mat3x3.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 3 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3; /// 3 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3; /// 3 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, highp> highp_mat3; /// 3 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3x3; /// 3 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3x3; /// 3 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, highp> highp_mat3x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float3x4.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float3x4.hpp #pragma once #include "../detail/type_mat3x4.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 3 columns of 4 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<3, 4, float, defaultp> mat3x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float3x4_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float3x4_precision.hpp #pragma once #include "../detail/type_mat3x4.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 3 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, lowp> lowp_mat3x4; /// 3 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, mediump> mediump_mat3x4; /// 3 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, highp> highp_mat3x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float4x2.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float4x2.hpp #pragma once #include "../detail/type_mat4x2.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 4 columns of 2 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<4, 2, float, defaultp> mat4x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float4x2_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float2x2_precision.hpp #pragma once #include "../detail/type_mat2x2.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 4 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, lowp> lowp_mat4x2; /// 4 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, mediump> mediump_mat4x2; /// 4 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, highp> highp_mat4x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float4x3.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float4x3.hpp #pragma once #include "../detail/type_mat4x3.hpp" namespace glm { /// @addtogroup core_matrix /// @{ /// 4 columns of 3 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<4, 3, float, defaultp> mat4x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float4x3_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float4x3_precision.hpp #pragma once #include "../detail/type_mat4x3.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 4 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, lowp> lowp_mat4x3; /// 4 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, mediump> mediump_mat4x3; /// 4 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, highp> highp_mat4x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float4x4.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float4x4.hpp #pragma once #include "../detail/type_mat4x4.hpp" namespace glm { /// @ingroup core_matrix /// @{ /// 4 columns of 4 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<4, 4, float, defaultp> mat4x4; /// 4 columns of 4 components matrix of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat<4, 4, float, defaultp> mat4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_float4x4_precision.hpp ================================================ /// @ref core /// @file glm/ext/matrix_float4x4_precision.hpp #pragma once #include "../detail/type_mat4x4.hpp" namespace glm { /// @addtogroup core_matrix_precision /// @{ /// 4 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4; /// 4 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4; /// 4 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, highp> highp_mat4; /// 4 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4x4; /// 4 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4x4; /// 4 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, highp> highp_mat4x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int2x2.hpp ================================================ /// @ref ext_matrix_int2x2 /// @file glm/ext/matrix_int2x2.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int2x2 GLM_EXT_matrix_int2x2 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x2.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int2x2 extension included") #endif namespace glm { /// @addtogroup ext_matrix_int2x2 /// @{ /// Signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2 typedef mat<2, 2, int, defaultp> imat2x2; /// Signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2 typedef mat<2, 2, int, defaultp> imat2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int2x2_sized.hpp ================================================ /// @ref ext_matrix_int2x2_sized /// @file glm/ext/matrix_int2x2_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int2x2_sized GLM_EXT_matrix_int2x2_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x2.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int2x2_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_int2x2_sized /// @{ /// 8 bit signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2_sized typedef mat<2, 2, int8, defaultp> i8mat2x2; /// 16 bit signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2_sized typedef mat<2, 2, int16, defaultp> i16mat2x2; /// 32 bit signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2_sized typedef mat<2, 2, int32, defaultp> i32mat2x2; /// 64 bit signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2_sized typedef mat<2, 2, int64, defaultp> i64mat2x2; /// 8 bit signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2_sized typedef mat<2, 2, int8, defaultp> i8mat2; /// 16 bit signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2_sized typedef mat<2, 2, int16, defaultp> i16mat2; /// 32 bit signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2_sized typedef mat<2, 2, int32, defaultp> i32mat2; /// 64 bit signed integer 2x2 matrix. /// /// @see ext_matrix_int2x2_sized typedef mat<2, 2, int64, defaultp> i64mat2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int2x3.hpp ================================================ /// @ref ext_matrix_int2x3 /// @file glm/ext/matrix_int2x3.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_int2x3 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x3.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int2x3 extension included") #endif namespace glm { /// @addtogroup ext_matrix_int2x3 /// @{ /// Signed integer 2x3 matrix. /// /// @see ext_matrix_int2x3 typedef mat<2, 3, int, defaultp> imat2x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int2x3_sized.hpp ================================================ /// @ref ext_matrix_int2x3_sized /// @file glm/ext/matrix_int2x3_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int2x3_sized GLM_EXT_matrix_int2x3_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x3.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int2x3_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_int2x3_sized /// @{ /// 8 bit signed integer 2x3 matrix. /// /// @see ext_matrix_int2x3_sized typedef mat<2, 3, int8, defaultp> i8mat2x3; /// 16 bit signed integer 2x3 matrix. /// /// @see ext_matrix_int2x3_sized typedef mat<2, 3, int16, defaultp> i16mat2x3; /// 32 bit signed integer 2x3 matrix. /// /// @see ext_matrix_int2x3_sized typedef mat<2, 3, int32, defaultp> i32mat2x3; /// 64 bit signed integer 2x3 matrix. /// /// @see ext_matrix_int2x3_sized typedef mat<2, 3, int64, defaultp> i64mat2x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int2x4.hpp ================================================ /// @ref ext_matrix_int2x4 /// @file glm/ext/matrix_int2x4.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int2x4 GLM_EXT_matrix_int2x4 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int2x4 extension included") #endif namespace glm { /// @addtogroup ext_matrix_int2x4 /// @{ /// Signed integer 2x4 matrix. /// /// @see ext_matrix_int2x4 typedef mat<2, 4, int, defaultp> imat2x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int2x4_sized.hpp ================================================ /// @ref ext_matrix_int2x4_sized /// @file glm/ext/matrix_int2x4_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int2x4_sized GLM_EXT_matrix_int2x4_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x4.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int2x4_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_int2x4_sized /// @{ /// 8 bit signed integer 2x4 matrix. /// /// @see ext_matrix_int2x4_sized typedef mat<2, 4, int8, defaultp> i8mat2x4; /// 16 bit signed integer 2x4 matrix. /// /// @see ext_matrix_int2x4_sized typedef mat<2, 4, int16, defaultp> i16mat2x4; /// 32 bit signed integer 2x4 matrix. /// /// @see ext_matrix_int2x4_sized typedef mat<2, 4, int32, defaultp> i32mat2x4; /// 64 bit signed integer 2x4 matrix. /// /// @see ext_matrix_int2x4_sized typedef mat<2, 4, int64, defaultp> i64mat2x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int3x2.hpp ================================================ /// @ref ext_matrix_int3x2 /// @file glm/ext/matrix_int3x2.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_int3x2 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x2.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int3x2 extension included") #endif namespace glm { /// @addtogroup ext_matrix_int3x2 /// @{ /// Signed integer 3x2 matrix. /// /// @see ext_matrix_int3x2 typedef mat<3, 2, int, defaultp> imat3x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int3x2_sized.hpp ================================================ /// @ref ext_matrix_int3x2_sized /// @file glm/ext/matrix_int3x2_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int3x2_sized GLM_EXT_matrix_int3x2_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x2.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int3x2_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_int3x2_sized /// @{ /// 8 bit signed integer 3x2 matrix. /// /// @see ext_matrix_int3x2_sized typedef mat<3, 2, int8, defaultp> i8mat3x2; /// 16 bit signed integer 3x2 matrix. /// /// @see ext_matrix_int3x2_sized typedef mat<3, 2, int16, defaultp> i16mat3x2; /// 32 bit signed integer 3x2 matrix. /// /// @see ext_matrix_int3x2_sized typedef mat<3, 2, int32, defaultp> i32mat3x2; /// 64 bit signed integer 3x2 matrix. /// /// @see ext_matrix_int3x2_sized typedef mat<3, 2, int64, defaultp> i64mat3x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int3x3.hpp ================================================ /// @ref ext_matrix_int3x3 /// @file glm/ext/matrix_int3x3.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int3x3 GLM_EXT_matrix_int3x3 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x3.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int3x3 extension included") #endif namespace glm { /// @addtogroup ext_matrix_int3x3 /// @{ /// Signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3 typedef mat<3, 3, int, defaultp> imat3x3; /// Signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3 typedef mat<3, 3, int, defaultp> imat3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int3x3_sized.hpp ================================================ /// @ref ext_matrix_int3x3_sized /// @file glm/ext/matrix_int3x3_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int3x3_sized GLM_EXT_matrix_int3x3_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x3.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int3x3_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_int3x3_sized /// @{ /// 8 bit signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3_sized typedef mat<3, 3, int8, defaultp> i8mat3x3; /// 16 bit signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3_sized typedef mat<3, 3, int16, defaultp> i16mat3x3; /// 32 bit signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3_sized typedef mat<3, 3, int32, defaultp> i32mat3x3; /// 64 bit signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3_sized typedef mat<3, 3, int64, defaultp> i64mat3x3; /// 8 bit signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3_sized typedef mat<3, 3, int8, defaultp> i8mat3; /// 16 bit signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3_sized typedef mat<3, 3, int16, defaultp> i16mat3; /// 32 bit signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3_sized typedef mat<3, 3, int32, defaultp> i32mat3; /// 64 bit signed integer 3x3 matrix. /// /// @see ext_matrix_int3x3_sized typedef mat<3, 3, int64, defaultp> i64mat3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int3x4.hpp ================================================ /// @ref ext_matrix_int3x4 /// @file glm/ext/matrix_int3x4.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int3x4 GLM_EXT_matrix_int3x4 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int3x4 extension included") #endif namespace glm { /// @addtogroup ext_matrix_int3x4 /// @{ /// Signed integer 3x4 matrix. /// /// @see ext_matrix_int3x4 typedef mat<3, 4, int, defaultp> imat3x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int3x4_sized.hpp ================================================ /// @ref ext_matrix_int3x4_sized /// @file glm/ext/matrix_int3x2_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int3x4_sized GLM_EXT_matrix_int3x4_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x4.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int3x4_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_int3x4_sized /// @{ /// 8 bit signed integer 3x4 matrix. /// /// @see ext_matrix_int3x4_sized typedef mat<3, 4, int8, defaultp> i8mat3x4; /// 16 bit signed integer 3x4 matrix. /// /// @see ext_matrix_int3x4_sized typedef mat<3, 4, int16, defaultp> i16mat3x4; /// 32 bit signed integer 3x4 matrix. /// /// @see ext_matrix_int3x4_sized typedef mat<3, 4, int32, defaultp> i32mat3x4; /// 64 bit signed integer 3x4 matrix. /// /// @see ext_matrix_int3x4_sized typedef mat<3, 4, int64, defaultp> i64mat3x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int4x2.hpp ================================================ /// @ref ext_matrix_int4x2 /// @file glm/ext/matrix_int4x2.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int4x2 GLM_EXT_matrix_int4x2 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x2.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int4x2 extension included") #endif namespace glm { /// @addtogroup ext_matrix_int4x2 /// @{ /// Signed integer 4x2 matrix. /// /// @see ext_matrix_int4x2 typedef mat<4, 2, int, defaultp> imat4x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int4x2_sized.hpp ================================================ /// @ref ext_matrix_int4x2_sized /// @file glm/ext/matrix_int4x2_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int4x2_sized GLM_EXT_matrix_int4x2_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x2.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int4x2_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_int4x2_sized /// @{ /// 8 bit signed integer 4x2 matrix. /// /// @see ext_matrix_int4x2_sized typedef mat<4, 2, int8, defaultp> i8mat4x2; /// 16 bit signed integer 4x2 matrix. /// /// @see ext_matrix_int4x2_sized typedef mat<4, 2, int16, defaultp> i16mat4x2; /// 32 bit signed integer 4x2 matrix. /// /// @see ext_matrix_int4x2_sized typedef mat<4, 2, int32, defaultp> i32mat4x2; /// 64 bit signed integer 4x2 matrix. /// /// @see ext_matrix_int4x2_sized typedef mat<4, 2, int64, defaultp> i64mat4x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int4x3.hpp ================================================ /// @ref ext_matrix_int4x3 /// @file glm/ext/matrix_int4x3.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int4x3 GLM_EXT_matrix_int4x3 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x3.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int4x3 extension included") #endif namespace glm { /// @addtogroup ext_matrix_int4x3 /// @{ /// Signed integer 4x3 matrix. /// /// @see ext_matrix_int4x3 typedef mat<4, 3, int, defaultp> imat4x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int4x3_sized.hpp ================================================ /// @ref ext_matrix_int4x3_sized /// @file glm/ext/matrix_int4x3_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int4x3_sized GLM_EXT_matrix_int4x3_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x3.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int4x3_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_int4x3_sized /// @{ /// 8 bit signed integer 4x3 matrix. /// /// @see ext_matrix_int4x3_sized typedef mat<4, 3, int8, defaultp> i8mat4x3; /// 16 bit signed integer 4x3 matrix. /// /// @see ext_matrix_int4x3_sized typedef mat<4, 3, int16, defaultp> i16mat4x3; /// 32 bit signed integer 4x3 matrix. /// /// @see ext_matrix_int4x3_sized typedef mat<4, 3, int32, defaultp> i32mat4x3; /// 64 bit signed integer 4x3 matrix. /// /// @see ext_matrix_int4x3_sized typedef mat<4, 3, int64, defaultp> i64mat4x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int4x4.hpp ================================================ /// @ref ext_matrix_int4x4 /// @file glm/ext/matrix_int4x4.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int4x4 GLM_EXT_matrix_int4x4 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int4x4 extension included") #endif namespace glm { /// @addtogroup ext_matrix_int4x4 /// @{ /// Signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4 typedef mat<4, 4, int, defaultp> imat4x4; /// Signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4 typedef mat<4, 4, int, defaultp> imat4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_int4x4_sized.hpp ================================================ /// @ref ext_matrix_int4x4_sized /// @file glm/ext/matrix_int4x4_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int4x4_sized GLM_EXT_matrix_int4x4_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x4.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_int4x4_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_int4x4_sized /// @{ /// 8 bit signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4_sized typedef mat<4, 4, int8, defaultp> i8mat4x4; /// 16 bit signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4_sized typedef mat<4, 4, int16, defaultp> i16mat4x4; /// 32 bit signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4_sized typedef mat<4, 4, int32, defaultp> i32mat4x4; /// 64 bit signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4_sized typedef mat<4, 4, int64, defaultp> i64mat4x4; /// 8 bit signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4_sized typedef mat<4, 4, int8, defaultp> i8mat4; /// 16 bit signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4_sized typedef mat<4, 4, int16, defaultp> i16mat4; /// 32 bit signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4_sized typedef mat<4, 4, int32, defaultp> i32mat4; /// 64 bit signed integer 4x4 matrix. /// /// @see ext_matrix_int4x4_sized typedef mat<4, 4, int64, defaultp> i64mat4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_projection.hpp ================================================ /// @ref ext_matrix_projection /// @file glm/ext/matrix_projection.hpp /// /// @defgroup ext_matrix_projection GLM_EXT_matrix_projection /// @ingroup ext /// /// Functions that generate common projection transformation matrices. /// /// The matrices generated by this extension use standard OpenGL fixed-function /// conventions. For example, the lookAt function generates a transform from world /// space into the specific eye space that the projective matrix functions /// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility /// specifications defines the particular layout of this eye space. /// /// Include to use the features of this extension. /// /// @see ext_matrix_transform /// @see ext_matrix_clip_space #pragma once // Dependencies #include "../gtc/constants.hpp" #include "../geometric.hpp" #include "../trigonometric.hpp" #include "../matrix.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_projection extension included") #endif namespace glm { /// @addtogroup ext_matrix_projection /// @{ /// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param obj Specify the object coordinates. /// @param model Specifies the current modelview matrix /// @param proj Specifies the current projection matrix /// @param viewport Specifies the current viewport /// @return Return the computed window coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// /// @see gluProject man page template GLM_FUNC_DECL vec<3, T, Q> projectZO( vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param obj Specify the object coordinates. /// @param model Specifies the current modelview matrix /// @param proj Specifies the current projection matrix /// @param viewport Specifies the current viewport /// @return Return the computed window coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// /// @see gluProject man page template GLM_FUNC_DECL vec<3, T, Q> projectNO( vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates using default near and far clip planes definition. /// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @param obj Specify the object coordinates. /// @param model Specifies the current modelview matrix /// @param proj Specifies the current projection matrix /// @param viewport Specifies the current viewport /// @return Return the computed window coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// /// @see gluProject man page template GLM_FUNC_DECL vec<3, T, Q> project( vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param win Specify the window coordinates to be mapped. /// @param model Specifies the modelview matrix /// @param proj Specifies the projection matrix /// @param viewport Specifies the viewport /// @return Returns the computed object coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// /// @see gluUnProject man page template GLM_FUNC_DECL vec<3, T, Q> unProjectZO( vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param win Specify the window coordinates to be mapped. /// @param model Specifies the modelview matrix /// @param proj Specifies the projection matrix /// @param viewport Specifies the viewport /// @return Returns the computed object coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// /// @see gluUnProject man page template GLM_FUNC_DECL vec<3, T, Q> unProjectNO( vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates using default near and far clip planes definition. /// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @param win Specify the window coordinates to be mapped. /// @param model Specifies the modelview matrix /// @param proj Specifies the projection matrix /// @param viewport Specifies the viewport /// @return Returns the computed object coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// /// @see gluUnProject man page template GLM_FUNC_DECL vec<3, T, Q> unProject( vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Define a picking region /// /// @param center Specify the center of a picking region in window coordinates. /// @param delta Specify the width and height, respectively, of the picking region in window coordinates. /// @param viewport Rendering viewport /// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// /// @see gluPickMatrix man page template GLM_FUNC_DECL mat<4, 4, T, Q> pickMatrix( vec<2, T, Q> const& center, vec<2, T, Q> const& delta, vec<4, U, Q> const& viewport); /// @} }//namespace glm #include "matrix_projection.inl" ================================================ FILE: android/src/glm/ext/matrix_projection.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> projectZO(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { vec<4, T, Q> tmp = vec<4, T, Q>(obj, static_cast(1)); tmp = model * tmp; tmp = proj * tmp; tmp /= tmp.w; tmp.x = tmp.x * static_cast(0.5) + static_cast(0.5); tmp.y = tmp.y * static_cast(0.5) + static_cast(0.5); tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]); tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]); return vec<3, T, Q>(tmp); } template GLM_FUNC_QUALIFIER vec<3, T, Q> projectNO(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { vec<4, T, Q> tmp = vec<4, T, Q>(obj, static_cast(1)); tmp = model * tmp; tmp = proj * tmp; tmp /= tmp.w; tmp = tmp * static_cast(0.5) + static_cast(0.5); tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]); tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]); return vec<3, T, Q>(tmp); } template GLM_FUNC_QUALIFIER vec<3, T, Q> project(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return projectZO(obj, model, proj, viewport); # else return projectNO(obj, model, proj, viewport); # endif } template GLM_FUNC_QUALIFIER vec<3, T, Q> unProjectZO(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { mat<4, 4, T, Q> Inverse = inverse(proj * model); vec<4, T, Q> tmp = vec<4, T, Q>(win, T(1)); tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]); tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]); tmp.x = tmp.x * static_cast(2) - static_cast(1); tmp.y = tmp.y * static_cast(2) - static_cast(1); vec<4, T, Q> obj = Inverse * tmp; obj /= obj.w; return vec<3, T, Q>(obj); } template GLM_FUNC_QUALIFIER vec<3, T, Q> unProjectNO(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { mat<4, 4, T, Q> Inverse = inverse(proj * model); vec<4, T, Q> tmp = vec<4, T, Q>(win, T(1)); tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]); tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]); tmp = tmp * static_cast(2) - static_cast(1); vec<4, T, Q> obj = Inverse * tmp; obj /= obj.w; return vec<3, T, Q>(obj); } template GLM_FUNC_QUALIFIER vec<3, T, Q> unProject(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT return unProjectZO(win, model, proj, viewport); # else return unProjectNO(win, model, proj, viewport); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> pickMatrix(vec<2, T, Q> const& center, vec<2, T, Q> const& delta, vec<4, U, Q> const& viewport) { assert(delta.x > static_cast(0) && delta.y > static_cast(0)); mat<4, 4, T, Q> Result(static_cast(1)); if(!(delta.x > static_cast(0) && delta.y > static_cast(0))) return Result; // Error vec<3, T, Q> Temp( (static_cast(viewport[2]) - static_cast(2) * (center.x - static_cast(viewport[0]))) / delta.x, (static_cast(viewport[3]) - static_cast(2) * (center.y - static_cast(viewport[1]))) / delta.y, static_cast(0)); // Translate and scale the picked region to the entire window Result = translate(Result, Temp); return scale(Result, vec<3, T, Q>(static_cast(viewport[2]) / delta.x, static_cast(viewport[3]) / delta.y, static_cast(1))); } }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_relational.hpp ================================================ /// @ref ext_matrix_relational /// @file glm/ext/matrix_relational.hpp /// /// @defgroup ext_matrix_relational GLM_EXT_matrix_relational /// @ingroup ext /// /// Exposes comparison functions for matrix types that take a user defined epsilon values. /// /// Include to use the features of this extension. /// /// @see ext_vector_relational /// @see ext_scalar_relational /// @see ext_quaternion_relational #pragma once // Dependencies #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_relational extension included") #endif namespace glm { /// @addtogroup ext_matrix_relational /// @{ /// Perform a component-wise equal-to comparison of two matrices. /// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(mat const& x, mat const& y); /// Perform a component-wise not-equal-to comparison of two matrices. /// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(mat const& x, mat const& y); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(mat const& x, mat const& y, T epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(mat const& x, mat const& y, vec const& epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is not satisfied. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(mat const& x, mat const& y, T epsilon); /// Returns the component-wise comparison of |x - y| >= epsilon. /// True if this expression is not satisfied. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(mat const& x, mat const& y, vec const& epsilon); /// Returns the component-wise comparison between two vectors in term of ULPs. /// True if this expression is satisfied. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(mat const& x, mat const& y, int ULPs); /// Returns the component-wise comparison between two vectors in term of ULPs. /// True if this expression is satisfied. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(mat const& x, mat const& y, vec const& ULPs); /// Returns the component-wise comparison between two vectors in term of ULPs. /// True if this expression is not satisfied. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(mat const& x, mat const& y, int ULPs); /// Returns the component-wise comparison between two vectors in term of ULPs. /// True if this expression is not satisfied. /// /// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix /// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix /// @tparam T Floating-point /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(mat const& x, mat const& y, vec const& ULPs); /// @} }//namespace glm #include "matrix_relational.inl" ================================================ FILE: android/src/glm/ext/matrix_relational.inl ================================================ /// @ref ext_vector_relational /// @file glm/ext/vector_relational.inl // Dependency: #include "../ext/vector_relational.hpp" #include "../common.hpp" namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(mat const& a, mat const& b) { return equal(a, b, static_cast(0)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(mat const& a, mat const& b, T Epsilon) { return equal(a, b, vec(Epsilon)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(mat const& a, mat const& b, vec const& Epsilon) { vec Result(true); for(length_t i = 0; i < C; ++i) Result[i] = all(equal(a[i], b[i], Epsilon[i])); return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(mat const& x, mat const& y) { return notEqual(x, y, static_cast(0)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(mat const& x, mat const& y, T Epsilon) { return notEqual(x, y, vec(Epsilon)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(mat const& a, mat const& b, vec const& Epsilon) { vec Result(true); for(length_t i = 0; i < C; ++i) Result[i] = any(notEqual(a[i], b[i], Epsilon[i])); return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(mat const& a, mat const& b, int MaxULPs) { return equal(a, b, vec(MaxULPs)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(mat const& a, mat const& b, vec const& MaxULPs) { vec Result(true); for(length_t i = 0; i < C; ++i) Result[i] = all(equal(a[i], b[i], MaxULPs[i])); return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(mat const& x, mat const& y, int MaxULPs) { return notEqual(x, y, vec(MaxULPs)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(mat const& a, mat const& b, vec const& MaxULPs) { vec Result(true); for(length_t i = 0; i < C; ++i) Result[i] = any(notEqual(a[i], b[i], MaxULPs[i])); return Result; } }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_transform.hpp ================================================ /// @ref ext_matrix_transform /// @file glm/ext/matrix_transform.hpp /// /// @defgroup ext_matrix_transform GLM_EXT_matrix_transform /// @ingroup ext /// /// Defines functions that generate common transformation matrices. /// /// The matrices generated by this extension use standard OpenGL fixed-function /// conventions. For example, the lookAt function generates a transform from world /// space into the specific eye space that the projective matrix functions /// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility /// specifications defines the particular layout of this eye space. /// /// Include to use the features of this extension. /// /// @see ext_matrix_projection /// @see ext_matrix_clip_space #pragma once // Dependencies #include "../gtc/constants.hpp" #include "../geometric.hpp" #include "../trigonometric.hpp" #include "../matrix.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_transform extension included") #endif namespace glm { /// @addtogroup ext_matrix_transform /// @{ /// Builds an identity matrix. template GLM_FUNC_DECL GLM_CONSTEXPR genType identity(); /// Builds a translation 4 * 4 matrix created from a vector of 3 components. /// /// @param m Input matrix multiplied by this translation matrix. /// @param v Coordinates of a translation vector. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum /// /// @code /// #include /// #include /// ... /// glm::mat4 m = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f)); /// // m[0][0] == 1.0f, m[0][1] == 0.0f, m[0][2] == 0.0f, m[0][3] == 0.0f /// // m[1][0] == 0.0f, m[1][1] == 1.0f, m[1][2] == 0.0f, m[1][3] == 0.0f /// // m[2][0] == 0.0f, m[2][1] == 0.0f, m[2][2] == 1.0f, m[2][3] == 0.0f /// // m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f /// @endcode /// /// @see - translate(mat<4, 4, T, Q> const& m, T x, T y, T z) /// @see - translate(vec<3, T, Q> const& v) /// @see glTranslate man page template GLM_FUNC_DECL mat<4, 4, T, Q> translate( mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v); /// Builds a rotation 4 * 4 matrix created from an axis vector and an angle. /// /// @param m Input matrix multiplied by this rotation matrix. /// @param angle Rotation angle expressed in radians. /// @param axis Rotation axis, recommended to be normalized. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum /// /// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z) /// @see - rotate(T angle, vec<3, T, Q> const& v) /// @see glRotate man page template GLM_FUNC_DECL mat<4, 4, T, Q> rotate( mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& axis); /// Builds a scale 4 * 4 matrix created from 3 scalars. /// /// @param m Input matrix multiplied by this scale matrix. /// @param v Ratio of scaling for each axis. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum /// /// @see - scale(mat<4, 4, T, Q> const& m, T x, T y, T z) /// @see - scale(vec<3, T, Q> const& v) /// @see glScale man page template GLM_FUNC_DECL mat<4, 4, T, Q> scale( mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v); /// Build a right handed look at view matrix. /// /// @param eye Position of the capture /// @param center Position where the capture is looking at /// @param up Normalized up vector, how the capture is oriented. Typically (0, 0, 1) /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum /// /// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) template GLM_FUNC_DECL mat<4, 4, T, Q> lookAtRH( vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up); /// Build a left handed look at view matrix. /// /// @param eye Position of the capture /// @param center Position where the capture is looking at /// @param up Normalized up vector, how the capture is oriented. Typically (0, 0, 1) /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum /// /// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) template GLM_FUNC_DECL mat<4, 4, T, Q> lookAtLH( vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up); /// Build a look at view matrix based on the default handedness. /// /// @param eye Position of the capture /// @param center Position where the capture is looking at /// @param up Normalized up vector, how the capture is oriented. Typically (0, 0, 1) /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum /// /// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) /// @see gluLookAt man page template GLM_FUNC_DECL mat<4, 4, T, Q> lookAt( vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up); /// @} }//namespace glm #include "matrix_transform.inl" ================================================ FILE: android/src/glm/ext/matrix_transform.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType identity() { return detail::init_gentype::GENTYPE>::identity(); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v) { mat<4, 4, T, Q> Result(m); Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& v) { T const a = angle; T const c = cos(a); T const s = sin(a); vec<3, T, Q> axis(normalize(v)); vec<3, T, Q> temp((T(1) - c) * axis); mat<4, 4, T, Q> Rotate; Rotate[0][0] = c + temp[0] * axis[0]; Rotate[0][1] = temp[0] * axis[1] + s * axis[2]; Rotate[0][2] = temp[0] * axis[2] - s * axis[1]; Rotate[1][0] = temp[1] * axis[0] - s * axis[2]; Rotate[1][1] = c + temp[1] * axis[1]; Rotate[1][2] = temp[1] * axis[2] + s * axis[0]; Rotate[2][0] = temp[2] * axis[0] + s * axis[1]; Rotate[2][1] = temp[2] * axis[1] - s * axis[0]; Rotate[2][2] = c + temp[2] * axis[2]; mat<4, 4, T, Q> Result; Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; Result[3] = m[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate_slow(mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& v) { T const a = angle; T const c = cos(a); T const s = sin(a); mat<4, 4, T, Q> Result; vec<3, T, Q> axis = normalize(v); Result[0][0] = c + (static_cast(1) - c) * axis.x * axis.x; Result[0][1] = (static_cast(1) - c) * axis.x * axis.y + s * axis.z; Result[0][2] = (static_cast(1) - c) * axis.x * axis.z - s * axis.y; Result[0][3] = static_cast(0); Result[1][0] = (static_cast(1) - c) * axis.y * axis.x - s * axis.z; Result[1][1] = c + (static_cast(1) - c) * axis.y * axis.y; Result[1][2] = (static_cast(1) - c) * axis.y * axis.z + s * axis.x; Result[1][3] = static_cast(0); Result[2][0] = (static_cast(1) - c) * axis.z * axis.x + s * axis.y; Result[2][1] = (static_cast(1) - c) * axis.z * axis.y - s * axis.x; Result[2][2] = c + (static_cast(1) - c) * axis.z * axis.z; Result[2][3] = static_cast(0); Result[3] = vec<4, T, Q>(0, 0, 0, 1); return m * Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v) { mat<4, 4, T, Q> Result; Result[0] = m[0] * v[0]; Result[1] = m[1] * v[1]; Result[2] = m[2] * v[2]; Result[3] = m[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale_slow(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v) { mat<4, 4, T, Q> Result(T(1)); Result[0][0] = v.x; Result[1][1] = v.y; Result[2][2] = v.z; return m * Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtRH(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up) { vec<3, T, Q> const f(normalize(center - eye)); vec<3, T, Q> const s(normalize(cross(f, up))); vec<3, T, Q> const u(cross(s, f)); mat<4, 4, T, Q> Result(1); Result[0][0] = s.x; Result[1][0] = s.y; Result[2][0] = s.z; Result[0][1] = u.x; Result[1][1] = u.y; Result[2][1] = u.z; Result[0][2] =-f.x; Result[1][2] =-f.y; Result[2][2] =-f.z; Result[3][0] =-dot(s, eye); Result[3][1] =-dot(u, eye); Result[3][2] = dot(f, eye); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtLH(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up) { vec<3, T, Q> const f(normalize(center - eye)); vec<3, T, Q> const s(normalize(cross(up, f))); vec<3, T, Q> const u(cross(f, s)); mat<4, 4, T, Q> Result(1); Result[0][0] = s.x; Result[1][0] = s.y; Result[2][0] = s.z; Result[0][1] = u.x; Result[1][1] = u.y; Result[2][1] = u.z; Result[0][2] = f.x; Result[1][2] = f.y; Result[2][2] = f.z; Result[3][0] = -dot(s, eye); Result[3][1] = -dot(u, eye); Result[3][2] = -dot(f, eye); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAt(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up) { GLM_IF_CONSTEXPR(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT) return lookAtLH(eye, center, up); else return lookAtRH(eye, center, up); } }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint2x2.hpp ================================================ /// @ref ext_matrix_uint2x2 /// @file glm/ext/matrix_uint2x2.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint2x2 GLM_EXT_matrix_uint2x2 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x2.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint2x2 extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint2x2 /// @{ /// Unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2 typedef mat<2, 2, uint, defaultp> umat2x2; /// Unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2 typedef mat<2, 2, uint, defaultp> umat2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint2x2_sized.hpp ================================================ /// @ref ext_matrix_uint2x2_sized /// @file glm/ext/matrix_uint2x2_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint2x2_sized GLM_EXT_matrix_uint2x2_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x2.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint2x2_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint2x2_sized /// @{ /// 8 bit unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2_sized typedef mat<2, 2, uint8, defaultp> u8mat2x2; /// 16 bit unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2_sized typedef mat<2, 2, uint16, defaultp> u16mat2x2; /// 32 bit unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2_sized typedef mat<2, 2, uint32, defaultp> u32mat2x2; /// 64 bit unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2_sized typedef mat<2, 2, uint64, defaultp> u64mat2x2; /// 8 bit unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2_sized typedef mat<2, 2, uint8, defaultp> u8mat2; /// 16 bit unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2_sized typedef mat<2, 2, uint16, defaultp> u16mat2; /// 32 bit unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2_sized typedef mat<2, 2, uint32, defaultp> u32mat2; /// 64 bit unsigned integer 2x2 matrix. /// /// @see ext_matrix_uint2x2_sized typedef mat<2, 2, uint64, defaultp> u64mat2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint2x3.hpp ================================================ /// @ref ext_matrix_uint2x3 /// @file glm/ext/matrix_uint2x3.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_uint2x3 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x3.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint2x3 extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint2x3 /// @{ /// Unsigned integer 2x3 matrix. /// /// @see ext_matrix_uint2x3 typedef mat<2, 3, uint, defaultp> umat2x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint2x3_sized.hpp ================================================ /// @ref ext_matrix_uint2x3_sized /// @file glm/ext/matrix_uint2x3_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint2x3_sized GLM_EXT_matrix_uint2x3_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x3.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint2x3_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint2x3_sized /// @{ /// 8 bit unsigned integer 2x3 matrix. /// /// @see ext_matrix_uint2x3_sized typedef mat<2, 3, uint8, defaultp> u8mat2x3; /// 16 bit unsigned integer 2x3 matrix. /// /// @see ext_matrix_uint2x3_sized typedef mat<2, 3, uint16, defaultp> u16mat2x3; /// 32 bit unsigned integer 2x3 matrix. /// /// @see ext_matrix_uint2x3_sized typedef mat<2, 3, uint32, defaultp> u32mat2x3; /// 64 bit unsigned integer 2x3 matrix. /// /// @see ext_matrix_uint2x3_sized typedef mat<2, 3, uint64, defaultp> u64mat2x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint2x4.hpp ================================================ /// @ref ext_matrix_uint2x4 /// @file glm/ext/matrix_uint2x4.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint2x4 GLM_EXT_matrix_int2x4 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint2x4 extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint2x4 /// @{ /// Unsigned integer 2x4 matrix. /// /// @see ext_matrix_uint2x4 typedef mat<2, 4, uint, defaultp> umat2x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint2x4_sized.hpp ================================================ /// @ref ext_matrix_uint2x4_sized /// @file glm/ext/matrixu_uint2x4_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint2x4_sized GLM_EXT_matrix_uint2x4_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x4.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint2x4_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint2x4_sized /// @{ /// 8 bit unsigned integer 2x4 matrix. /// /// @see ext_matrix_uint2x4_sized typedef mat<2, 4, uint8, defaultp> u8mat2x4; /// 16 bit unsigned integer 2x4 matrix. /// /// @see ext_matrix_uint2x4_sized typedef mat<2, 4, uint16, defaultp> u16mat2x4; /// 32 bit unsigned integer 2x4 matrix. /// /// @see ext_matrix_uint2x4_sized typedef mat<2, 4, uint32, defaultp> u32mat2x4; /// 64 bit unsigned integer 2x4 matrix. /// /// @see ext_matrix_uint2x4_sized typedef mat<2, 4, uint64, defaultp> u64mat2x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint3x2.hpp ================================================ /// @ref ext_matrix_uint3x2 /// @file glm/ext/matrix_uint3x2.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_uint3x2 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x2.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint3x2 extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint3x2 /// @{ /// Unsigned integer 3x2 matrix. /// /// @see ext_matrix_uint3x2 typedef mat<3, 2, uint, defaultp> umat3x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint3x2_sized.hpp ================================================ /// @ref ext_matrix_uint3x2_sized /// @file glm/ext/matrix_uint3x2_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint3x2_sized GLM_EXT_matrix_uint3x2_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x2.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint3x2_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint3x2_sized /// @{ /// 8 bit signed integer 3x2 matrix. /// /// @see ext_matrix_uint3x2_sized typedef mat<3, 2, uint8, defaultp> u8mat3x2; /// 16 bit signed integer 3x2 matrix. /// /// @see ext_matrix_uint3x2_sized typedef mat<3, 2, uint16, defaultp> u16mat3x2; /// 32 bit signed integer 3x2 matrix. /// /// @see ext_matrix_uint3x2_sized typedef mat<3, 2, uint32, defaultp> u32mat3x2; /// 64 bit signed integer 3x2 matrix. /// /// @see ext_matrix_uint3x2_sized typedef mat<3, 2, uint64, defaultp> u64mat3x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint3x3.hpp ================================================ /// @ref ext_matrix_uint3x3 /// @file glm/ext/matrix_uint3x3.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint3x3 GLM_EXT_matrix_uint3x3 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x3.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint3x3 extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint3x3 /// @{ /// Unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3 typedef mat<3, 3, uint, defaultp> umat3x3; /// Unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3 typedef mat<3, 3, uint, defaultp> umat3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint3x3_sized.hpp ================================================ /// @ref ext_matrix_uint3x3_sized /// @file glm/ext/matrix_uint3x3_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint3x3_sized GLM_EXT_matrix_uint3x3_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x3.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint3x3_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint3x3_sized /// @{ /// 8 bit unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3_sized typedef mat<3, 3, uint8, defaultp> u8mat3x3; /// 16 bit unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3_sized typedef mat<3, 3, uint16, defaultp> u16mat3x3; /// 32 bit unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3_sized typedef mat<3, 3, uint32, defaultp> u32mat3x3; /// 64 bit unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3_sized typedef mat<3, 3, uint64, defaultp> u64mat3x3; /// 8 bit unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3_sized typedef mat<3, 3, uint8, defaultp> u8mat3; /// 16 bit unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3_sized typedef mat<3, 3, uint16, defaultp> u16mat3; /// 32 bit unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3_sized typedef mat<3, 3, uint32, defaultp> u32mat3; /// 64 bit unsigned integer 3x3 matrix. /// /// @see ext_matrix_uint3x3_sized typedef mat<3, 3, uint64, defaultp> u64mat3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint3x4.hpp ================================================ /// @ref ext_matrix_uint3x4 /// @file glm/ext/matrix_uint3x4.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint3x4 GLM_EXT_matrix_uint3x4 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint3x4 extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint3x4 /// @{ /// Signed integer 3x4 matrix. /// /// @see ext_matrix_uint3x4 typedef mat<3, 4, uint, defaultp> umat3x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint3x4_sized.hpp ================================================ /// @ref ext_matrix_uint3x4_sized /// @file glm/ext/matrix_uint3x2_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint3x4_sized GLM_EXT_matrix_uint3x4_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat3x4.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint3x4_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint3x4_sized /// @{ /// 8 bit unsigned integer 3x4 matrix. /// /// @see ext_matrix_uint3x4_sized typedef mat<3, 4, uint8, defaultp> u8mat3x4; /// 16 bit unsigned integer 3x4 matrix. /// /// @see ext_matrix_uint3x4_sized typedef mat<3, 4, uint16, defaultp> u16mat3x4; /// 32 bit unsigned integer 3x4 matrix. /// /// @see ext_matrix_uint3x4_sized typedef mat<3, 4, uint32, defaultp> u32mat3x4; /// 64 bit unsigned integer 3x4 matrix. /// /// @see ext_matrix_uint3x4_sized typedef mat<3, 4, uint64, defaultp> u64mat3x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint4x2.hpp ================================================ /// @ref ext_matrix_uint4x2 /// @file glm/ext/matrix_uint4x2.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint4x2 GLM_EXT_matrix_uint4x2 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x2.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint4x2 extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint4x2 /// @{ /// Unsigned integer 4x2 matrix. /// /// @see ext_matrix_uint4x2 typedef mat<4, 2, uint, defaultp> umat4x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint4x2_sized.hpp ================================================ /// @ref ext_matrix_uint4x2_sized /// @file glm/ext/matrix_uint4x2_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint4x2_sized GLM_EXT_matrix_uint4x2_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x2.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint4x2_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint4x2_sized /// @{ /// 8 bit unsigned integer 4x2 matrix. /// /// @see ext_matrix_uint4x2_sized typedef mat<4, 2, uint8, defaultp> u8mat4x2; /// 16 bit unsigned integer 4x2 matrix. /// /// @see ext_matrix_uint4x2_sized typedef mat<4, 2, uint16, defaultp> u16mat4x2; /// 32 bit unsigned integer 4x2 matrix. /// /// @see ext_matrix_uint4x2_sized typedef mat<4, 2, uint32, defaultp> u32mat4x2; /// 64 bit unsigned integer 4x2 matrix. /// /// @see ext_matrix_uint4x2_sized typedef mat<4, 2, uint64, defaultp> u64mat4x2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint4x3.hpp ================================================ /// @ref ext_matrix_uint4x3 /// @file glm/ext/matrix_uint4x3.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint4x3 GLM_EXT_matrix_uint4x3 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x3.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint4x3 extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint4x3 /// @{ /// Unsigned integer 4x3 matrix. /// /// @see ext_matrix_uint4x3 typedef mat<4, 3, uint, defaultp> umat4x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint4x3_sized.hpp ================================================ /// @ref ext_matrix_uint4x3_sized /// @file glm/ext/matrix_uint4x3_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint4x3_sized GLM_EXT_matrix_uint4x3_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x3.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint4x3_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint4x3_sized /// @{ /// 8 bit unsigned integer 4x3 matrix. /// /// @see ext_matrix_uint4x3_sized typedef mat<4, 3, uint8, defaultp> u8mat4x3; /// 16 bit unsigned integer 4x3 matrix. /// /// @see ext_matrix_uint4x3_sized typedef mat<4, 3, uint16, defaultp> u16mat4x3; /// 32 bit unsigned integer 4x3 matrix. /// /// @see ext_matrix_uint4x3_sized typedef mat<4, 3, uint32, defaultp> u32mat4x3; /// 64 bit unsigned integer 4x3 matrix. /// /// @see ext_matrix_uint4x3_sized typedef mat<4, 3, uint64, defaultp> u64mat4x3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint4x4.hpp ================================================ /// @ref ext_matrix_uint4x4 /// @file glm/ext/matrix_uint4x4.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint4x4 GLM_EXT_matrix_uint4x4 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint4x4 extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint4x4 /// @{ /// Unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4 typedef mat<4, 4, uint, defaultp> umat4x4; /// Unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4 typedef mat<4, 4, uint, defaultp> umat4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/matrix_uint4x4_sized.hpp ================================================ /// @ref ext_matrix_uint4x4_sized /// @file glm/ext/matrix_uint4x4_sized.hpp /// /// @see core (dependence) /// /// @defgroup ext_matrix_uint4x4_sized GLM_EXT_matrix_uint4x4_sized /// @ingroup ext /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat4x4.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_matrix_uint4x4_sized extension included") #endif namespace glm { /// @addtogroup ext_matrix_uint4x4_sized /// @{ /// 8 bit unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4_sized typedef mat<4, 4, uint8, defaultp> u8mat4x4; /// 16 bit unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4_sized typedef mat<4, 4, uint16, defaultp> u16mat4x4; /// 32 bit unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4_sized typedef mat<4, 4, uint32, defaultp> u32mat4x4; /// 64 bit unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4_sized typedef mat<4, 4, uint64, defaultp> u64mat4x4; /// 8 bit unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4_sized typedef mat<4, 4, uint8, defaultp> u8mat4; /// 16 bit unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4_sized typedef mat<4, 4, uint16, defaultp> u16mat4; /// 32 bit unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4_sized typedef mat<4, 4, uint32, defaultp> u32mat4; /// 64 bit unsigned integer 4x4 matrix. /// /// @see ext_matrix_uint4x4_sized typedef mat<4, 4, uint64, defaultp> u64mat4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/quaternion_common.hpp ================================================ /// @ref ext_quaternion_common /// @file glm/ext/quaternion_common.hpp /// /// @defgroup ext_quaternion_common GLM_EXT_quaternion_common /// @ingroup ext /// /// Provides common functions for quaternion types /// /// Include to use the features of this extension. /// /// @see ext_scalar_common /// @see ext_vector_common /// @see ext_quaternion_float /// @see ext_quaternion_double /// @see ext_quaternion_exponential /// @see ext_quaternion_geometric /// @see ext_quaternion_relational /// @see ext_quaternion_trigonometric /// @see ext_quaternion_transform #pragma once // Dependency: #include "../ext/scalar_constants.hpp" #include "../ext/quaternion_geometric.hpp" #include "../common.hpp" #include "../trigonometric.hpp" #include "../exponential.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_common extension included") #endif namespace glm { /// @addtogroup ext_quaternion_common /// @{ /// Spherical linear interpolation of two quaternions. /// The interpolation is oriented and the rotation is performed at constant speed. /// For short path spherical linear interpolation, use the slerp function. /// /// @param x A quaternion /// @param y A quaternion /// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum /// /// @see - slerp(qua const& x, qua const& y, T const& a) template GLM_FUNC_DECL qua mix(qua const& x, qua const& y, T a); /// Linear interpolation of two quaternions. /// The interpolation is oriented. /// /// @param x A quaternion /// @param y A quaternion /// @param a Interpolation factor. The interpolation is defined in the range [0, 1]. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua lerp(qua const& x, qua const& y, T a); /// Spherical linear interpolation of two quaternions. /// The interpolation always take the short path and the rotation is performed at constant speed. /// /// @param x A quaternion /// @param y A quaternion /// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua slerp(qua const& x, qua const& y, T a); /// Spherical linear interpolation of two quaternions with multiple spins over rotation axis. /// The interpolation always take the short path when the spin count is positive and long path /// when count is negative. Rotation is performed at constant speed. /// /// @param x A quaternion /// @param y A quaternion /// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// @param k Additional spin count. If Value is negative interpolation will be on "long" path. /// /// @tparam T A floating-point scalar type /// @tparam S An integer scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua slerp(qua const& x, qua const& y, T a, S k); /// Returns the q conjugate. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua conjugate(qua const& q); /// Returns the q inverse. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua inverse(qua const& q); /// 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 T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL vec<4, bool, Q> isnan(qua 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 T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL vec<4, bool, Q> isinf(qua const& x); /// @} } //namespace glm #include "quaternion_common.inl" ================================================ FILE: android/src/glm/ext/quaternion_common.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER qua mix(qua const& x, qua const& y, T a) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'mix' only accept floating-point inputs"); T const cosTheta = dot(x, y); // Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator if(cosTheta > static_cast(1) - epsilon()) { // Linear interpolation return qua( mix(x.w, y.w, a), mix(x.x, y.x, a), mix(x.y, y.y, a), mix(x.z, y.z, a)); } else { // Essential Mathematics, page 467 T angle = acos(cosTheta); return (sin((static_cast(1) - a) * angle) * x + sin(a * angle) * y) / sin(angle); } } template GLM_FUNC_QUALIFIER qua lerp(qua const& x, qua const& y, T a) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'lerp' only accept floating-point inputs"); // Lerp is only defined in [0, 1] assert(a >= static_cast(0)); assert(a <= static_cast(1)); return x * (static_cast(1) - a) + (y * a); } template GLM_FUNC_QUALIFIER qua slerp(qua const& x, qua const& y, T a) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'slerp' only accept floating-point inputs"); qua z = y; T cosTheta = dot(x, y); // If cosTheta < 0, the interpolation will take the long way around the sphere. // To fix this, one quat must be negated. if(cosTheta < static_cast(0)) { z = -y; cosTheta = -cosTheta; } // Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator if(cosTheta > static_cast(1) - epsilon()) { // Linear interpolation return qua( mix(x.w, z.w, a), mix(x.x, z.x, a), mix(x.y, z.y, a), mix(x.z, z.z, a)); } else { // Essential Mathematics, page 467 T angle = acos(cosTheta); return (sin((static_cast(1) - a) * angle) * x + sin(a * angle) * z) / sin(angle); } } template GLM_FUNC_QUALIFIER qua slerp(qua const& x, qua const& y, T a, S k) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'slerp' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'slerp' only accept integer for spin count"); qua z = y; T cosTheta = dot(x, y); // If cosTheta < 0, the interpolation will take the long way around the sphere. // To fix this, one quat must be negated. if (cosTheta < static_cast(0)) { z = -y; cosTheta = -cosTheta; } // Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator if (cosTheta > static_cast(1) - epsilon()) { // Linear interpolation return qua( mix(x.w, z.w, a), mix(x.x, z.x, a), mix(x.y, z.y, a), mix(x.z, z.z, a)); } else { // Graphics Gems III, page 96 T angle = acos(cosTheta); T phi = angle + k * glm::pi(); return (sin(angle - a * phi)* x + sin(a * phi) * z) / sin(angle); } } template GLM_FUNC_QUALIFIER qua conjugate(qua const& q) { return qua(q.w, -q.x, -q.y, -q.z); } template GLM_FUNC_QUALIFIER qua inverse(qua const& q) { return conjugate(q) / dot(q, q); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> isnan(qua const& q) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isnan' only accept floating-point inputs"); return vec<4, bool, Q>(isnan(q.x), isnan(q.y), isnan(q.z), isnan(q.w)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> isinf(qua const& q) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isinf' only accept floating-point inputs"); return vec<4, bool, Q>(isinf(q.x), isinf(q.y), isinf(q.z), isinf(q.w)); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "quaternion_common_simd.inl" #endif ================================================ FILE: android/src/glm/ext/quaternion_common_simd.inl ================================================ #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { template struct compute_dot, float, true> { static GLM_FUNC_QUALIFIER float call(qua const& x, qua const& y) { return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); } }; }//namespace detail }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/ext/quaternion_double.hpp ================================================ /// @ref ext_quaternion_double /// @file glm/ext/quaternion_double.hpp /// /// @defgroup ext_quaternion_double GLM_EXT_quaternion_double /// @ingroup ext /// /// Exposes double-precision floating point quaternion type. /// /// Include to use the features of this extension. /// /// @see ext_quaternion_float /// @see ext_quaternion_double_precision /// @see ext_quaternion_common /// @see ext_quaternion_exponential /// @see ext_quaternion_geometric /// @see ext_quaternion_relational /// @see ext_quaternion_transform /// @see ext_quaternion_trigonometric #pragma once // Dependency: #include "../detail/type_quat.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_double extension included") #endif namespace glm { /// @addtogroup ext_quaternion_double /// @{ /// Quaternion of double-precision floating-point numbers. typedef qua dquat; /// @} } //namespace glm ================================================ FILE: android/src/glm/ext/quaternion_double_precision.hpp ================================================ /// @ref ext_quaternion_double_precision /// @file glm/ext/quaternion_double_precision.hpp /// /// @defgroup ext_quaternion_double_precision GLM_EXT_quaternion_double_precision /// @ingroup ext /// /// Exposes double-precision floating point quaternion type with various precision in term of ULPs. /// /// Include to use the features of this extension. #pragma once // Dependency: #include "../detail/type_quat.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_double_precision extension included") #endif namespace glm { /// @addtogroup ext_quaternion_double_precision /// @{ /// Quaternion of double-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see ext_quaternion_double_precision typedef qua lowp_dquat; /// Quaternion of medium double-qualifier floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see ext_quaternion_double_precision typedef qua mediump_dquat; /// Quaternion of high double-qualifier floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see ext_quaternion_double_precision typedef qua highp_dquat; /// @} } //namespace glm ================================================ FILE: android/src/glm/ext/quaternion_exponential.hpp ================================================ /// @ref ext_quaternion_exponential /// @file glm/ext/quaternion_exponential.hpp /// /// @defgroup ext_quaternion_exponential GLM_EXT_quaternion_exponential /// @ingroup ext /// /// Provides exponential functions for quaternion types /// /// Include to use the features of this extension. /// /// @see core_exponential /// @see ext_quaternion_float /// @see ext_quaternion_double #pragma once // Dependency: #include "../common.hpp" #include "../trigonometric.hpp" #include "../geometric.hpp" #include "../ext/scalar_constants.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_exponential extension included") #endif namespace glm { /// @addtogroup ext_quaternion_transform /// @{ /// Returns a exponential of a quaternion. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua exp(qua const& q); /// Returns a logarithm of a quaternion /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua log(qua const& q); /// Returns a quaternion raised to a power. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua pow(qua const& q, T y); /// Returns the square root of a quaternion /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua sqrt(qua const& q); /// @} } //namespace glm #include "quaternion_exponential.inl" ================================================ FILE: android/src/glm/ext/quaternion_exponential.inl ================================================ #include "scalar_constants.hpp" namespace glm { template GLM_FUNC_QUALIFIER qua exp(qua const& q) { vec<3, T, Q> u(q.x, q.y, q.z); T const Angle = glm::length(u); if (Angle < epsilon()) return qua(); vec<3, T, Q> const v(u / Angle); return qua(cos(Angle), sin(Angle) * v); } template GLM_FUNC_QUALIFIER qua log(qua const& q) { vec<3, T, Q> u(q.x, q.y, q.z); T Vec3Len = length(u); if (Vec3Len < epsilon()) { if(q.w > static_cast(0)) return qua(log(q.w), static_cast(0), static_cast(0), static_cast(0)); else if(q.w < static_cast(0)) return qua(log(-q.w), pi(), static_cast(0), static_cast(0)); else return qua(std::numeric_limits::infinity(), std::numeric_limits::infinity(), std::numeric_limits::infinity(), std::numeric_limits::infinity()); } else { T t = atan(Vec3Len, T(q.w)) / Vec3Len; T QuatLen2 = Vec3Len * Vec3Len + q.w * q.w; return qua(static_cast(0.5) * log(QuatLen2), t * q.x, t * q.y, t * q.z); } } template GLM_FUNC_QUALIFIER qua pow(qua const& x, T y) { //Raising to the power of 0 should yield 1 //Needed to prevent a division by 0 error later on if(y > -epsilon() && y < epsilon()) return qua(1,0,0,0); //To deal with non-unit quaternions T magnitude = sqrt(x.x * x.x + x.y * x.y + x.z * x.z + x.w *x.w); T Angle; if(abs(x.w / magnitude) > cos_one_over_two()) { //Scalar component is close to 1; using it to recover angle would lose precision //Instead, we use the non-scalar components since sin() is accurate around 0 //Prevent a division by 0 error later on T VectorMagnitude = x.x * x.x + x.y * x.y + x.z * x.z; if (glm::abs(VectorMagnitude - static_cast(0)) < glm::epsilon()) { //Equivalent to raising a real number to a power return qua(pow(x.w, y), 0, 0, 0); } Angle = asin(sqrt(VectorMagnitude) / magnitude); } else { //Scalar component is small, shouldn't cause loss of precision Angle = acos(x.w / magnitude); } T NewAngle = Angle * y; T Div = sin(NewAngle) / sin(Angle); T Mag = pow(magnitude, y - static_cast(1)); return qua(cos(NewAngle) * magnitude * Mag, x.x * Div * Mag, x.y * Div * Mag, x.z * Div * Mag); } template GLM_FUNC_QUALIFIER qua sqrt(qua const& x) { return pow(x, static_cast(0.5)); } }//namespace glm ================================================ FILE: android/src/glm/ext/quaternion_float.hpp ================================================ /// @ref ext_quaternion_float /// @file glm/ext/quaternion_float.hpp /// /// @defgroup ext_quaternion_float GLM_EXT_quaternion_float /// @ingroup ext /// /// Exposes single-precision floating point quaternion type. /// /// Include to use the features of this extension. /// /// @see ext_quaternion_double /// @see ext_quaternion_float_precision /// @see ext_quaternion_common /// @see ext_quaternion_exponential /// @see ext_quaternion_geometric /// @see ext_quaternion_relational /// @see ext_quaternion_transform /// @see ext_quaternion_trigonometric #pragma once // Dependency: #include "../detail/type_quat.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_float extension included") #endif namespace glm { /// @addtogroup ext_quaternion_float /// @{ /// Quaternion of single-precision floating-point numbers. typedef qua quat; /// @} } //namespace glm ================================================ FILE: android/src/glm/ext/quaternion_float_precision.hpp ================================================ /// @ref ext_quaternion_float_precision /// @file glm/ext/quaternion_float_precision.hpp /// /// @defgroup ext_quaternion_float_precision GLM_EXT_quaternion_float_precision /// @ingroup ext /// /// Exposes single-precision floating point quaternion type with various precision in term of ULPs. /// /// Include to use the features of this extension. #pragma once // Dependency: #include "../detail/type_quat.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_float_precision extension included") #endif namespace glm { /// @addtogroup ext_quaternion_float_precision /// @{ /// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef qua lowp_quat; /// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef qua mediump_quat; /// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef qua highp_quat; /// @} } //namespace glm ================================================ FILE: android/src/glm/ext/quaternion_geometric.hpp ================================================ /// @ref ext_quaternion_geometric /// @file glm/ext/quaternion_geometric.hpp /// /// @defgroup ext_quaternion_geometric GLM_EXT_quaternion_geometric /// @ingroup ext /// /// Provides geometric functions for quaternion types /// /// Include to use the features of this extension. /// /// @see core_geometric /// @see ext_quaternion_float /// @see ext_quaternion_double #pragma once // Dependency: #include "../geometric.hpp" #include "../exponential.hpp" #include "../ext/vector_relational.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_geometric extension included") #endif namespace glm { /// @addtogroup ext_quaternion_geometric /// @{ /// Returns the norm of a quaternions /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_quaternion_geometric template GLM_FUNC_DECL T length(qua const& q); /// Returns the normalized quaternion. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_quaternion_geometric template GLM_FUNC_DECL qua normalize(qua const& q); /// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... /// /// @tparam T Floating-point scalar types. /// @tparam Q Value from qualifier enum /// /// @see ext_quaternion_geometric template GLM_FUNC_DECL T dot(qua const& x, qua const& y); /// Compute a cross product. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_quaternion_geometric template GLM_FUNC_QUALIFIER qua cross(qua const& q1, qua const& q2); /// @} } //namespace glm #include "quaternion_geometric.inl" ================================================ FILE: android/src/glm/ext/quaternion_geometric.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER T dot(qua const& x, qua const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); } template GLM_FUNC_QUALIFIER T length(qua const& q) { return glm::sqrt(dot(q, q)); } template GLM_FUNC_QUALIFIER qua normalize(qua const& q) { T len = length(q); if(len <= static_cast(0)) // Problem return qua(static_cast(1), static_cast(0), static_cast(0), static_cast(0)); T oneOverLen = static_cast(1) / len; return qua(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen); } template GLM_FUNC_QUALIFIER qua cross(qua const& q1, qua const& q2) { return qua( q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z, q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y, q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z, q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x); } }//namespace glm ================================================ FILE: android/src/glm/ext/quaternion_relational.hpp ================================================ /// @ref ext_quaternion_relational /// @file glm/ext/quaternion_relational.hpp /// /// @defgroup ext_quaternion_relational GLM_EXT_quaternion_relational /// @ingroup ext /// /// Exposes comparison functions for quaternion types that take a user defined epsilon values. /// /// Include to use the features of this extension. /// /// @see core_vector_relational /// @see ext_vector_relational /// @see ext_matrix_relational /// @see ext_quaternion_float /// @see ext_quaternion_double #pragma once // Dependency: #include "../vector_relational.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_relational extension included") #endif namespace glm { /// @addtogroup ext_quaternion_relational /// @{ /// Returns the component-wise comparison of result x == y. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL vec<4, bool, Q> equal(qua const& x, qua const& y); /// Returns the component-wise comparison of |x - y| < epsilon. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL vec<4, bool, Q> equal(qua const& x, qua const& y, T epsilon); /// Returns the component-wise comparison of result x != y. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua const& x, qua const& y); /// Returns the component-wise comparison of |x - y| >= epsilon. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua const& x, qua const& y, T epsilon); /// @} } //namespace glm #include "quaternion_relational.inl" ================================================ FILE: android/src/glm/ext/quaternion_relational.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(qua const& x, qua const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] == y[i]; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(qua const& x, qua const& y, T epsilon) { vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); return lessThan(abs(v), vec<4, T, Q>(epsilon)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> notEqual(qua const& x, qua const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] != y[i]; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> notEqual(qua const& x, qua const& y, T epsilon) { vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); return greaterThanEqual(abs(v), vec<4, T, Q>(epsilon)); } }//namespace glm ================================================ FILE: android/src/glm/ext/quaternion_transform.hpp ================================================ /// @ref ext_quaternion_transform /// @file glm/ext/quaternion_transform.hpp /// /// @defgroup ext_quaternion_transform GLM_EXT_quaternion_transform /// @ingroup ext /// /// Provides transformation functions for quaternion types /// /// Include to use the features of this extension. /// /// @see ext_quaternion_float /// @see ext_quaternion_double /// @see ext_quaternion_exponential /// @see ext_quaternion_geometric /// @see ext_quaternion_relational /// @see ext_quaternion_trigonometric #pragma once // Dependency: #include "../common.hpp" #include "../trigonometric.hpp" #include "../geometric.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_transform extension included") #endif namespace glm { /// @addtogroup ext_quaternion_transform /// @{ /// Rotates a quaternion from a vector of 3 components axis and an angle. /// /// @param q Source orientation /// @param angle Angle expressed in radians. /// @param axis Axis of the rotation /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL qua rotate(qua const& q, T const& angle, vec<3, T, Q> const& axis); /// @} } //namespace glm #include "quaternion_transform.inl" ================================================ FILE: android/src/glm/ext/quaternion_transform.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER qua rotate(qua const& q, T const& angle, vec<3, T, Q> const& v) { vec<3, T, Q> Tmp = v; // Axis of rotation must be normalised T len = glm::length(Tmp); if(abs(len - static_cast(1)) > static_cast(0.001)) { T oneOverLen = static_cast(1) / len; Tmp.x *= oneOverLen; Tmp.y *= oneOverLen; Tmp.z *= oneOverLen; } T const AngleRad(angle); T const Sin = sin(AngleRad * static_cast(0.5)); return q * qua(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); } }//namespace glm ================================================ FILE: android/src/glm/ext/quaternion_trigonometric.hpp ================================================ /// @ref ext_quaternion_trigonometric /// @file glm/ext/quaternion_trigonometric.hpp /// /// @defgroup ext_quaternion_trigonometric GLM_EXT_quaternion_trigonometric /// @ingroup ext /// /// Provides trigonometric functions for quaternion types /// /// Include to use the features of this extension. /// /// @see ext_quaternion_float /// @see ext_quaternion_double /// @see ext_quaternion_exponential /// @see ext_quaternion_geometric /// @see ext_quaternion_relational /// @see ext_quaternion_transform #pragma once // Dependency: #include "../trigonometric.hpp" #include "../exponential.hpp" #include "scalar_constants.hpp" #include "vector_relational.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_quaternion_trigonometric extension included") #endif namespace glm { /// @addtogroup ext_quaternion_trigonometric /// @{ /// Returns the quaternion rotation angle. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL T angle(qua const& x); /// Returns the q rotation axis. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL vec<3, T, Q> axis(qua const& x); /// Build a quaternion from an angle and a normalized axis. /// /// @param angle Angle expressed in radians. /// @param axis Axis of the quaternion, must be normalized. /// /// @tparam T A floating-point scalar type /// @tparam Q A value from qualifier enum template GLM_FUNC_DECL qua angleAxis(T const& angle, vec<3, T, Q> const& axis); /// @} } //namespace glm #include "quaternion_trigonometric.inl" ================================================ FILE: android/src/glm/ext/quaternion_trigonometric.inl ================================================ #include "scalar_constants.hpp" namespace glm { template GLM_FUNC_QUALIFIER T angle(qua const& x) { if (abs(x.w) > cos_one_over_two()) { return asin(sqrt(x.x * x.x + x.y * x.y + x.z * x.z)) * static_cast(2); } return acos(x.w) * static_cast(2); } template GLM_FUNC_QUALIFIER vec<3, T, Q> axis(qua const& x) { T const tmp1 = static_cast(1) - x.w * x.w; if(tmp1 <= static_cast(0)) return vec<3, T, Q>(0, 0, 1); T const tmp2 = static_cast(1) / sqrt(tmp1); return vec<3, T, Q>(x.x * tmp2, x.y * tmp2, x.z * tmp2); } template GLM_FUNC_QUALIFIER qua angleAxis(T const& angle, vec<3, T, Q> const& v) { T const a(angle); T const s = glm::sin(a * static_cast(0.5)); return qua(glm::cos(a * static_cast(0.5)), v * s); } }//namespace glm ================================================ FILE: android/src/glm/ext/scalar_common.hpp ================================================ /// @ref ext_scalar_common /// @file glm/ext/scalar_common.hpp /// /// @defgroup ext_scalar_common GLM_EXT_scalar_common /// @ingroup ext /// /// Exposes min and max functions for 3 to 4 scalar parameters. /// /// Include to use the features of this extension. /// /// @see core_func_common /// @see ext_vector_common #pragma once // Dependency: #include "../common.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_scalar_common extension included") #endif namespace glm { /// @addtogroup ext_scalar_common /// @{ /// Returns the minimum component-wise values of 3 inputs /// /// @tparam T A floating-point scalar type. /// /// @see ext_scalar_common template GLM_FUNC_DECL T min(T a, T b, T c); /// Returns the minimum component-wise values of 4 inputs /// /// @tparam T A floating-point scalar type. /// /// @see ext_scalar_common template GLM_FUNC_DECL T min(T a, T b, T c, T d); /// Returns the maximum component-wise values of 3 inputs /// /// @tparam T A floating-point scalar type. /// /// @see ext_scalar_common template GLM_FUNC_DECL T max(T a, T b, T c); /// Returns the maximum component-wise values of 4 inputs /// /// @tparam T A floating-point scalar type. /// /// @see ext_scalar_common template GLM_FUNC_DECL T max(T a, T b, T c, T d); /// Returns the minimum component-wise values of 2 inputs. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam T A floating-point scalar type. /// /// @see std::fmin documentation /// @see ext_scalar_common template GLM_FUNC_DECL T fmin(T a, T b); /// Returns the minimum component-wise values of 3 inputs. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam T A floating-point scalar type. /// /// @see std::fmin documentation /// @see ext_scalar_common template GLM_FUNC_DECL T fmin(T a, T b, T c); /// Returns the minimum component-wise values of 4 inputs. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam T A floating-point scalar type. /// /// @see std::fmin documentation /// @see ext_scalar_common template GLM_FUNC_DECL T fmin(T a, T b, T c, T d); /// Returns the maximum component-wise values of 2 inputs. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam T A floating-point scalar type. /// /// @see std::fmax documentation /// @see ext_scalar_common template GLM_FUNC_DECL T fmax(T a, T b); /// Returns the maximum component-wise values of 3 inputs. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam T A floating-point scalar type. /// /// @see std::fmax documentation /// @see ext_scalar_common template GLM_FUNC_DECL T fmax(T a, T b, T C); /// Returns the maximum component-wise values of 4 inputs. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam T A floating-point scalar type. /// /// @see std::fmax documentation /// @see ext_scalar_common template GLM_FUNC_DECL T fmax(T a, T b, T C, T D); /// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam genType Floating-point scalar types. /// /// @see ext_scalar_common template GLM_FUNC_DECL genType fclamp(genType x, genType minVal, genType maxVal); /// Simulate GL_CLAMP OpenGL wrap mode /// /// @tparam genType Floating-point scalar types. /// /// @see ext_scalar_common extension. template GLM_FUNC_DECL genType clamp(genType const& Texcoord); /// Simulate GL_REPEAT OpenGL wrap mode /// /// @tparam genType Floating-point scalar types. /// /// @see ext_scalar_common extension. template GLM_FUNC_DECL genType repeat(genType const& Texcoord); /// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode /// /// @tparam genType Floating-point scalar types. /// /// @see ext_scalar_common extension. template GLM_FUNC_DECL genType mirrorClamp(genType const& Texcoord); /// Simulate GL_MIRROR_REPEAT OpenGL wrap mode /// /// @tparam genType Floating-point scalar types. /// /// @see ext_scalar_common extension. template GLM_FUNC_DECL genType mirrorRepeat(genType const& Texcoord); /// @} }//namespace glm #include "scalar_common.inl" ================================================ FILE: android/src/glm/ext/scalar_common.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER T min(T a, T b, T c) { return glm::min(glm::min(a, b), c); } template GLM_FUNC_QUALIFIER T min(T a, T b, T c, T d) { return glm::min(glm::min(a, b), glm::min(c, d)); } template GLM_FUNC_QUALIFIER T max(T a, T b, T c) { return glm::max(glm::max(a, b), c); } template GLM_FUNC_QUALIFIER T max(T a, T b, T c, T d) { return glm::max(glm::max(a, b), glm::max(c, d)); } # if GLM_HAS_CXX11_STL using std::fmin; # else template GLM_FUNC_QUALIFIER T fmin(T a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point input"); if (isnan(a)) return b; return min(a, b); } # endif template GLM_FUNC_QUALIFIER T fmin(T a, T b, T c) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point input"); if (isnan(a)) return fmin(b, c); if (isnan(b)) return fmin(a, c); if (isnan(c)) return min(a, b); return min(a, b, c); } template GLM_FUNC_QUALIFIER T fmin(T a, T b, T c, T d) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point input"); if (isnan(a)) return fmin(b, c, d); if (isnan(b)) return min(a, fmin(c, d)); if (isnan(c)) return fmin(min(a, b), d); if (isnan(d)) return min(a, b, c); return min(a, b, c, d); } # if GLM_HAS_CXX11_STL using std::fmax; # else template GLM_FUNC_QUALIFIER T fmax(T a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point input"); if (isnan(a)) return b; return max(a, b); } # endif template GLM_FUNC_QUALIFIER T fmax(T a, T b, T c) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point input"); if (isnan(a)) return fmax(b, c); if (isnan(b)) return fmax(a, c); if (isnan(c)) return max(a, b); return max(a, b, c); } template GLM_FUNC_QUALIFIER T fmax(T a, T b, T c, T d) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point input"); if (isnan(a)) return fmax(b, c, d); if (isnan(b)) return max(a, fmax(c, d)); if (isnan(c)) return fmax(max(a, b), d); if (isnan(d)) return max(a, b, c); return max(a, b, c, d); } // fclamp template GLM_FUNC_QUALIFIER genType fclamp(genType x, genType minVal, genType maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fclamp' only accept floating-point or integer inputs"); return fmin(fmax(x, minVal), maxVal); } template GLM_FUNC_QUALIFIER genType clamp(genType const& Texcoord) { return glm::clamp(Texcoord, static_cast(0), static_cast(1)); } template GLM_FUNC_QUALIFIER genType repeat(genType const& Texcoord) { return glm::fract(Texcoord); } template GLM_FUNC_QUALIFIER genType mirrorClamp(genType const& Texcoord) { return glm::fract(glm::abs(Texcoord)); } template GLM_FUNC_QUALIFIER genType mirrorRepeat(genType const& Texcoord) { genType const Abs = glm::abs(Texcoord); genType const Clamp = glm::mod(glm::floor(Abs), static_cast(2)); genType const Floor = glm::floor(Abs); genType const Rest = Abs - Floor; genType const Mirror = Clamp + Rest; return mix(Rest, static_cast(1) - Rest, Mirror >= static_cast(1)); } }//namespace glm ================================================ FILE: android/src/glm/ext/scalar_constants.hpp ================================================ /// @ref ext_scalar_constants /// @file glm/ext/scalar_constants.hpp /// /// @defgroup ext_scalar_constants GLM_EXT_scalar_constants /// @ingroup ext /// /// Provides a list of constants and precomputed useful values. /// /// Include to use the features of this extension. #pragma once // Dependencies #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_scalar_constants extension included") #endif namespace glm { /// @addtogroup ext_scalar_constants /// @{ /// Return the epsilon constant for floating point types. template GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon(); /// Return the pi constant for floating point types. template GLM_FUNC_DECL GLM_CONSTEXPR genType pi(); /// Return the value of cos(1 / 2) for floating point types. template GLM_FUNC_DECL GLM_CONSTEXPR genType cos_one_over_two(); /// @} } //namespace glm #include "scalar_constants.inl" ================================================ FILE: android/src/glm/ext/scalar_constants.inl ================================================ #include namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'epsilon' only accepts floating-point inputs"); return std::numeric_limits::epsilon(); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'pi' only accepts floating-point inputs"); return static_cast(3.14159265358979323846264338327950288); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType cos_one_over_two() { return genType(0.877582561890372716130286068203503191); } } //namespace glm ================================================ FILE: android/src/glm/ext/scalar_int_sized.hpp ================================================ /// @ref ext_scalar_int_sized /// @file glm/ext/scalar_int_sized.hpp /// /// @defgroup ext_scalar_int_sized GLM_EXT_scalar_int_sized /// @ingroup ext /// /// Exposes sized signed integer scalar types. /// /// Include to use the features of this extension. /// /// @see ext_scalar_uint_sized #pragma once #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_scalar_int_sized extension included") #endif namespace glm{ namespace detail { # if GLM_HAS_EXTENDED_INTEGER_TYPE typedef std::int8_t int8; typedef std::int16_t int16; typedef std::int32_t int32; # else typedef signed char int8; typedef signed short int16; typedef signed int int32; #endif// template<> struct is_int { enum test {value = ~0}; }; template<> struct is_int { enum test {value = ~0}; }; template<> struct is_int { enum test {value = ~0}; }; }//namespace detail /// @addtogroup ext_scalar_int_sized /// @{ /// 8 bit signed integer type. typedef detail::int8 int8; /// 16 bit signed integer type. typedef detail::int16 int16; /// 32 bit signed integer type. typedef detail::int32 int32; /// 64 bit signed integer type. typedef detail::int64 int64; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/scalar_integer.hpp ================================================ /// @ref ext_scalar_integer /// @file glm/ext/scalar_integer.hpp /// /// @see core (dependence) /// /// @defgroup ext_scalar_integer GLM_EXT_scalar_integer /// @ingroup ext /// /// Include to use the features of this extension. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/_vectorize.hpp" #include "../detail/type_float.hpp" #include "../vector_relational.hpp" #include "../common.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_scalar_integer extension included") #endif namespace glm { /// @addtogroup ext_scalar_integer /// @{ /// Return true if the value is a power of two number. /// /// @see ext_scalar_integer template GLM_FUNC_DECL bool isPowerOfTwo(genIUType v); /// Return the power of two number which value is just higher the input value, /// round up to a power of two. /// /// @see ext_scalar_integer template GLM_FUNC_DECL genIUType nextPowerOfTwo(genIUType v); /// Return the power of two number which value is just lower the input value, /// round down to a power of two. /// /// @see ext_scalar_integer template GLM_FUNC_DECL genIUType prevPowerOfTwo(genIUType v); /// Return true if the 'Value' is a multiple of 'Multiple'. /// /// @see ext_scalar_integer template GLM_FUNC_DECL bool isMultiple(genIUType v, genIUType Multiple); /// Higher multiple number of Source. /// /// @tparam genIUType Integer scalar or vector types. /// /// @param v Source value to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see ext_scalar_integer template GLM_FUNC_DECL genIUType nextMultiple(genIUType v, genIUType Multiple); /// Lower multiple number of Source. /// /// @tparam genIUType Integer scalar or vector types. /// /// @param v Source value to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see ext_scalar_integer template GLM_FUNC_DECL genIUType prevMultiple(genIUType v, genIUType Multiple); /// Returns the bit number of the Nth significant bit set to /// 1 in the binary representation of value. /// If value bitcount is less than the Nth significant bit, -1 will be returned. /// /// @tparam genIUType Signed or unsigned integer scalar types. /// /// @see ext_scalar_integer template GLM_FUNC_DECL int findNSB(genIUType x, int significantBitCount); /// @} } //namespace glm #include "scalar_integer.inl" ================================================ FILE: android/src/glm/ext/scalar_integer.inl ================================================ #include "../integer.hpp" namespace glm{ namespace detail { template struct compute_ceilShift { GLM_FUNC_QUALIFIER static vec call(vec const& v, T) { return v; } }; template struct compute_ceilShift { GLM_FUNC_QUALIFIER static vec call(vec const& v, T Shift) { return v | (v >> Shift); } }; template struct compute_ceilPowerOfTwo { GLM_FUNC_QUALIFIER static vec call(vec const& x) { GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); vec const Sign(sign(x)); vec v(abs(x)); v = v - static_cast(1); v = v | (v >> static_cast(1)); v = v | (v >> static_cast(2)); v = v | (v >> static_cast(4)); v = compute_ceilShift= 2>::call(v, 8); v = compute_ceilShift= 4>::call(v, 16); v = compute_ceilShift= 8>::call(v, 32); return (v + static_cast(1)) * Sign; } }; template struct compute_ceilPowerOfTwo { GLM_FUNC_QUALIFIER static vec call(vec const& x) { GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); vec v(x); v = v - static_cast(1); v = v | (v >> static_cast(1)); v = v | (v >> static_cast(2)); v = v | (v >> static_cast(4)); v = compute_ceilShift= 2>::call(v, 8); v = compute_ceilShift= 4>::call(v, 16); v = compute_ceilShift= 8>::call(v, 32); return v + static_cast(1); } }; template struct compute_ceilMultiple{}; template<> struct compute_ceilMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source > genType(0)) return Source + (Multiple - std::fmod(Source, Multiple)); else return Source + std::fmod(-Source, Multiple); } }; template<> struct compute_ceilMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { genType Tmp = Source - genType(1); return Tmp + (Multiple - (Tmp % Multiple)); } }; template<> struct compute_ceilMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { assert(Multiple > genType(0)); if(Source > genType(0)) { genType Tmp = Source - genType(1); return Tmp + (Multiple - (Tmp % Multiple)); } else return Source + (-Source % Multiple); } }; template struct compute_floorMultiple{}; template<> struct compute_floorMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source >= genType(0)) return Source - std::fmod(Source, Multiple); else return Source - std::fmod(Source, Multiple) - Multiple; } }; template<> struct compute_floorMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source >= genType(0)) return Source - Source % Multiple; else { genType Tmp = Source + genType(1); return Tmp - Tmp % Multiple - Multiple; } } }; template<> struct compute_floorMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source >= genType(0)) return Source - Source % Multiple; else { genType Tmp = Source + genType(1); return Tmp - Tmp % Multiple - Multiple; } } }; }//namespace detail template GLM_FUNC_QUALIFIER bool isPowerOfTwo(genIUType Value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isPowerOfTwo' only accept integer inputs"); genIUType const Result = glm::abs(Value); return !(Result & (Result - 1)); } template GLM_FUNC_QUALIFIER genIUType nextPowerOfTwo(genIUType value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextPowerOfTwo' only accept integer inputs"); return detail::compute_ceilPowerOfTwo<1, genIUType, defaultp, std::numeric_limits::is_signed>::call(vec<1, genIUType, defaultp>(value)).x; } template GLM_FUNC_QUALIFIER genIUType prevPowerOfTwo(genIUType value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevPowerOfTwo' only accept integer inputs"); return isPowerOfTwo(value) ? value : static_cast(static_cast(1) << static_cast(findMSB(value))); } template GLM_FUNC_QUALIFIER bool isMultiple(genIUType Value, genIUType Multiple) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isMultiple' only accept integer inputs"); return isMultiple(vec<1, genIUType>(Value), vec<1, genIUType>(Multiple)).x; } template GLM_FUNC_QUALIFIER genIUType nextMultiple(genIUType Source, genIUType Multiple) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextMultiple' only accept integer inputs"); return detail::compute_ceilMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template GLM_FUNC_QUALIFIER genIUType prevMultiple(genIUType Source, genIUType Multiple) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevMultiple' only accept integer inputs"); return detail::compute_floorMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template GLM_FUNC_QUALIFIER int findNSB(genIUType x, int significantBitCount) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findNSB' only accept integer inputs"); if(bitCount(x) < significantBitCount) return -1; genIUType const One = static_cast(1); int bitPos = 0; genIUType key = x; int nBitCount = significantBitCount; int Step = sizeof(x) * 8 / 2; while (key > One) { genIUType Mask = static_cast((One << Step) - One); genIUType currentKey = key & Mask; int currentBitCount = bitCount(currentKey); if (nBitCount > currentBitCount) { nBitCount -= currentBitCount; bitPos += Step; key >>= static_cast(Step); } else { key = key & Mask; } Step >>= 1; } return static_cast(bitPos); } }//namespace glm ================================================ FILE: android/src/glm/ext/scalar_packing.hpp ================================================ /// @ref ext_scalar_packing /// @file glm/ext/scalar_packing.hpp /// /// @see core (dependence) /// /// @defgroup ext_scalar_packing GLM_EXT_scalar_packing /// @ingroup ext /// /// Include to use the features of this extension. /// /// This extension provides a set of function to convert scalar values to packed /// formats. #pragma once // Dependency: #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_scalar_packing extension included") #endif namespace glm { /// @addtogroup ext_scalar_packing /// @{ /// @} }// namespace glm #include "scalar_packing.inl" ================================================ FILE: android/src/glm/ext/scalar_packing.inl ================================================ ================================================ FILE: android/src/glm/ext/scalar_relational.hpp ================================================ /// @ref ext_scalar_relational /// @file glm/ext/scalar_relational.hpp /// /// @defgroup ext_scalar_relational GLM_EXT_scalar_relational /// @ingroup ext /// /// Exposes comparison functions for scalar types that take a user defined epsilon values. /// /// Include to use the features of this extension. /// /// @see core_vector_relational /// @see ext_vector_relational /// @see ext_matrix_relational #pragma once // Dependencies #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_scalar_relational extension included") #endif namespace glm { /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @tparam genType Floating-point or integer scalar types template GLM_FUNC_DECL GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon); /// Returns the component-wise comparison of |x - y| >= epsilon. /// True if this expression is not satisfied. /// /// @tparam genType Floating-point or integer scalar types template GLM_FUNC_DECL GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon); /// Returns the component-wise comparison between two scalars in term of ULPs. /// True if this expression is satisfied. /// /// @param x First operand. /// @param y Second operand. /// @param ULPs Maximum difference in ULPs between the two operators to consider them equal. /// /// @tparam genType Floating-point or integer scalar types template GLM_FUNC_DECL GLM_CONSTEXPR bool equal(genType const& x, genType const& y, int ULPs); /// Returns the component-wise comparison between two scalars in term of ULPs. /// True if this expression is not satisfied. /// /// @param x First operand. /// @param y Second operand. /// @param ULPs Maximum difference in ULPs between the two operators to consider them not equal. /// /// @tparam genType Floating-point or integer scalar types template GLM_FUNC_DECL GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, int ULPs); /// @} }//namespace glm #include "scalar_relational.inl" ================================================ FILE: android/src/glm/ext/scalar_relational.inl ================================================ #include "../common.hpp" #include "../ext/scalar_int_sized.hpp" #include "../ext/scalar_uint_sized.hpp" #include "../detail/type_float.hpp" namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon) { return abs(x - y) <= epsilon; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon) { return abs(x - y) > epsilon; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, int MaxULPs) { detail::float_t const a(x); detail::float_t const b(y); // Different signs means they do not match. if(a.negative() != b.negative()) return false; // Find the difference in ULPs. typename detail::float_t::int_type const DiffULPs = abs(a.i - b.i); return DiffULPs <= MaxULPs; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, int ULPs) { return !equal(x, y, ULPs); } }//namespace glm ================================================ FILE: android/src/glm/ext/scalar_uint_sized.hpp ================================================ /// @ref ext_scalar_uint_sized /// @file glm/ext/scalar_uint_sized.hpp /// /// @defgroup ext_scalar_uint_sized GLM_EXT_scalar_uint_sized /// @ingroup ext /// /// Exposes sized unsigned integer scalar types. /// /// Include to use the features of this extension. /// /// @see ext_scalar_int_sized #pragma once #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_scalar_uint_sized extension included") #endif namespace glm{ namespace detail { # if GLM_HAS_EXTENDED_INTEGER_TYPE typedef std::uint8_t uint8; typedef std::uint16_t uint16; typedef std::uint32_t uint32; # else typedef unsigned char uint8; typedef unsigned short uint16; typedef unsigned int uint32; #endif template<> struct is_int { enum test {value = ~0}; }; template<> struct is_int { enum test {value = ~0}; }; template<> struct is_int { enum test {value = ~0}; }; }//namespace detail /// @addtogroup ext_scalar_uint_sized /// @{ /// 8 bit unsigned integer type. typedef detail::uint8 uint8; /// 16 bit unsigned integer type. typedef detail::uint16 uint16; /// 32 bit unsigned integer type. typedef detail::uint32 uint32; /// 64 bit unsigned integer type. typedef detail::uint64 uint64; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/scalar_ulp.hpp ================================================ /// @ref ext_scalar_ulp /// @file glm/ext/scalar_ulp.hpp /// /// @defgroup ext_scalar_ulp GLM_EXT_scalar_ulp /// @ingroup ext /// /// Allow the measurement of the accuracy of a function against a reference /// implementation. This extension works on floating-point data and provide results /// in ULP. /// /// Include to use the features of this extension. /// /// @see ext_vector_ulp /// @see ext_scalar_relational #pragma once // Dependencies #include "../ext/scalar_int_sized.hpp" #include "../common.hpp" #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_scalar_ulp extension included") #endif namespace glm { /// Return the next ULP value(s) after the input value(s). /// /// @tparam genType A floating-point scalar type. /// /// @see ext_scalar_ulp template GLM_FUNC_DECL genType nextFloat(genType x); /// Return the previous ULP value(s) before the input value(s). /// /// @tparam genType A floating-point scalar type. /// /// @see ext_scalar_ulp template GLM_FUNC_DECL genType prevFloat(genType x); /// Return the value(s) ULP distance after the input value(s). /// /// @tparam genType A floating-point scalar type. /// /// @see ext_scalar_ulp template GLM_FUNC_DECL genType nextFloat(genType x, int ULPs); /// Return the value(s) ULP distance before the input value(s). /// /// @tparam genType A floating-point scalar type. /// /// @see ext_scalar_ulp template GLM_FUNC_DECL genType prevFloat(genType x, int ULPs); /// Return the distance in the number of ULP between 2 single-precision floating-point scalars. /// /// @see ext_scalar_ulp GLM_FUNC_DECL int floatDistance(float x, float y); /// Return the distance in the number of ULP between 2 double-precision floating-point scalars. /// /// @see ext_scalar_ulp GLM_FUNC_DECL int64 floatDistance(double x, double y); /// @} }//namespace glm #include "scalar_ulp.inl" ================================================ FILE: android/src/glm/ext/scalar_ulp.inl ================================================ /// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. /// /// Developed at SunPro, a Sun Microsystems, Inc. business. /// Permission to use, copy, modify, and distribute this /// software is freely granted, provided that this notice /// is preserved. #include "../detail/type_float.hpp" #include "../ext/scalar_constants.hpp" #include #include #if(GLM_COMPILER & GLM_COMPILER_VC) # pragma warning(push) # pragma warning(disable : 4127) #endif typedef union { float value; /* FIXME: Assumes 32 bit int. */ unsigned int word; } ieee_float_shape_type; typedef union { double value; struct { int lsw; int msw; } parts; } ieee_double_shape_type; #define GLM_EXTRACT_WORDS(ix0,ix1,d) \ do { \ ieee_double_shape_type ew_u; \ ew_u.value = (d); \ (ix0) = ew_u.parts.msw; \ (ix1) = ew_u.parts.lsw; \ } while (0) #define GLM_GET_FLOAT_WORD(i,d) \ do { \ ieee_float_shape_type gf_u; \ gf_u.value = (d); \ (i) = gf_u.word; \ } while (0) #define GLM_SET_FLOAT_WORD(d,i) \ do { \ ieee_float_shape_type sf_u; \ sf_u.word = (i); \ (d) = sf_u.value; \ } while (0) #define GLM_INSERT_WORDS(d,ix0,ix1) \ do { \ ieee_double_shape_type iw_u; \ iw_u.parts.msw = (ix0); \ iw_u.parts.lsw = (ix1); \ (d) = iw_u.value; \ } while (0) namespace glm{ namespace detail { GLM_FUNC_QUALIFIER float nextafterf(float x, float y) { volatile float t; int hx, hy, ix, iy; GLM_GET_FLOAT_WORD(hx, x); GLM_GET_FLOAT_WORD(hy, y); ix = hx & 0x7fffffff; // |x| iy = hy & 0x7fffffff; // |y| if((ix > 0x7f800000) || // x is nan (iy > 0x7f800000)) // y is nan return x + y; if(abs(y - x) <= epsilon()) return y; // x=y, return y if(ix == 0) { // x == 0 GLM_SET_FLOAT_WORD(x, (hy & 0x80000000) | 1);// return +-minsubnormal t = x * x; if(abs(t - x) <= epsilon()) return t; else return x; // raise underflow flag } if(hx >= 0) { // x > 0 if(hx > hy) // x > y, x -= ulp hx -= 1; else // x < y, x += ulp hx += 1; } else { // x < 0 if(hy >= 0 || hx > hy) // x < y, x -= ulp hx -= 1; else // x > y, x += ulp hx += 1; } hy = hx & 0x7f800000; if(hy >= 0x7f800000) return x + x; // overflow if(hy < 0x00800000) // underflow { t = x * x; if(abs(t - x) > epsilon()) { // raise underflow flag GLM_SET_FLOAT_WORD(y, hx); return y; } } GLM_SET_FLOAT_WORD(x, hx); return x; } GLM_FUNC_QUALIFIER double nextafter(double x, double y) { volatile double t; int hx, hy, ix, iy; unsigned int lx, ly; GLM_EXTRACT_WORDS(hx, lx, x); GLM_EXTRACT_WORDS(hy, ly, y); ix = hx & 0x7fffffff; // |x| iy = hy & 0x7fffffff; // |y| if(((ix >= 0x7ff00000) && ((ix - 0x7ff00000) | lx) != 0) || // x is nan ((iy >= 0x7ff00000) && ((iy - 0x7ff00000) | ly) != 0)) // y is nan return x + y; if(abs(y - x) <= epsilon()) return y; // x=y, return y if((ix | lx) == 0) { // x == 0 GLM_INSERT_WORDS(x, hy & 0x80000000, 1); // return +-minsubnormal t = x * x; if(abs(t - x) <= epsilon()) return t; else return x; // raise underflow flag } if(hx >= 0) { // x > 0 if(hx > hy || ((hx == hy) && (lx > ly))) { // x > y, x -= ulp if(lx == 0) hx -= 1; lx -= 1; } else { // x < y, x += ulp lx += 1; if(lx == 0) hx += 1; } } else { // x < 0 if(hy >= 0 || hx > hy || ((hx == hy) && (lx > ly))){// x < y, x -= ulp if(lx == 0) hx -= 1; lx -= 1; } else { // x > y, x += ulp lx += 1; if(lx == 0) hx += 1; } } hy = hx & 0x7ff00000; if(hy >= 0x7ff00000) return x + x; // overflow if(hy < 0x00100000) { // underflow t = x * x; if(abs(t - x) > epsilon()) { // raise underflow flag GLM_INSERT_WORDS(y, hx, lx); return y; } } GLM_INSERT_WORDS(x, hx, lx); return x; } }//namespace detail }//namespace glm #if(GLM_COMPILER & GLM_COMPILER_VC) # pragma warning(pop) #endif namespace glm { template<> GLM_FUNC_QUALIFIER float nextFloat(float x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::max()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return detail::nextafterf(x, FLT_MAX); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafterf(x, FLT_MAX); # else return nextafterf(x, FLT_MAX); # endif } template<> GLM_FUNC_QUALIFIER double nextFloat(double x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::max()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return detail::nextafter(x, std::numeric_limits::max()); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafter(x, DBL_MAX); # else return nextafter(x, DBL_MAX); # endif } template GLM_FUNC_QUALIFIER T nextFloat(T x, int ULPs) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'next_float' only accept floating-point input"); assert(ULPs >= 0); T temp = x; for(int i = 0; i < ULPs; ++i) temp = nextFloat(temp); return temp; } GLM_FUNC_QUALIFIER float prevFloat(float x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::min()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return detail::nextafterf(x, FLT_MIN); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafterf(x, FLT_MIN); # else return nextafterf(x, FLT_MIN); # endif } GLM_FUNC_QUALIFIER double prevFloat(double x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::min()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return _nextafter(x, DBL_MIN); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafter(x, DBL_MIN); # else return nextafter(x, DBL_MIN); # endif } template GLM_FUNC_QUALIFIER T prevFloat(T x, int ULPs) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'prev_float' only accept floating-point input"); assert(ULPs >= 0); T temp = x; for(int i = 0; i < ULPs; ++i) temp = prevFloat(temp); return temp; } GLM_FUNC_QUALIFIER int floatDistance(float x, float y) { detail::float_t const a(x); detail::float_t const b(y); return abs(a.i - b.i); } GLM_FUNC_QUALIFIER int64 floatDistance(double x, double y) { detail::float_t const a(x); detail::float_t const b(y); return abs(a.i - b.i); } }//namespace glm ================================================ FILE: android/src/glm/ext/vector_bool1.hpp ================================================ /// @ref ext_vector_bool1 /// @file glm/ext/vector_bool1.hpp /// /// @defgroup ext_vector_bool1 GLM_EXT_vector_bool1 /// @ingroup ext /// /// Exposes bvec1 vector type. /// /// Include to use the features of this extension. /// /// @see ext_vector_bool1_precision extension. #pragma once #include "../detail/type_vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_bool1 extension included") #endif namespace glm { /// @addtogroup ext_vector_bool1 /// @{ /// 1 components vector of boolean. typedef vec<1, bool, defaultp> bvec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_bool1_precision.hpp ================================================ /// @ref ext_vector_bool1_precision /// @file glm/ext/vector_bool1_precision.hpp /// /// @defgroup ext_vector_bool1_precision GLM_EXT_vector_bool1_precision /// @ingroup ext /// /// Exposes highp_bvec1, mediump_bvec1 and lowp_bvec1 types. /// /// Include to use the features of this extension. #pragma once #include "../detail/type_vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_bool1_precision extension included") #endif namespace glm { /// @addtogroup ext_vector_bool1_precision /// @{ /// 1 component vector of bool values. typedef vec<1, bool, highp> highp_bvec1; /// 1 component vector of bool values. typedef vec<1, bool, mediump> mediump_bvec1; /// 1 component vector of bool values. typedef vec<1, bool, lowp> lowp_bvec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_bool2.hpp ================================================ /// @ref core /// @file glm/ext/vector_bool2.hpp #pragma once #include "../detail/type_vec2.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 2 components vector of boolean. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<2, bool, defaultp> bvec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_bool2_precision.hpp ================================================ /// @ref core /// @file glm/ext/vector_bool2_precision.hpp #pragma once #include "../detail/type_vec2.hpp" namespace glm { /// @addtogroup core_vector_precision /// @{ /// 2 components vector of high qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, bool, highp> highp_bvec2; /// 2 components vector of medium qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, bool, mediump> mediump_bvec2; /// 2 components vector of low qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, bool, lowp> lowp_bvec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_bool3.hpp ================================================ /// @ref core /// @file glm/ext/vector_bool3.hpp #pragma once #include "../detail/type_vec3.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 3 components vector of boolean. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<3, bool, defaultp> bvec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_bool3_precision.hpp ================================================ /// @ref core /// @file glm/ext/vector_bool3_precision.hpp #pragma once #include "../detail/type_vec3.hpp" namespace glm { /// @addtogroup core_vector_precision /// @{ /// 3 components vector of high qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, bool, highp> highp_bvec3; /// 3 components vector of medium qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, bool, mediump> mediump_bvec3; /// 3 components vector of low qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, bool, lowp> lowp_bvec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_bool4.hpp ================================================ /// @ref core /// @file glm/ext/vector_bool4.hpp #pragma once #include "../detail/type_vec4.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 4 components vector of boolean. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<4, bool, defaultp> bvec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_bool4_precision.hpp ================================================ /// @ref core /// @file glm/ext/vector_bool4_precision.hpp #pragma once #include "../detail/type_vec4.hpp" namespace glm { /// @addtogroup core_vector_precision /// @{ /// 4 components vector of high qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, bool, highp> highp_bvec4; /// 4 components vector of medium qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, bool, mediump> mediump_bvec4; /// 4 components vector of low qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, bool, lowp> lowp_bvec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_common.hpp ================================================ /// @ref ext_vector_common /// @file glm/ext/vector_common.hpp /// /// @defgroup ext_vector_common GLM_EXT_vector_common /// @ingroup ext /// /// Exposes min and max functions for 3 to 4 vector parameters. /// /// Include to use the features of this extension. /// /// @see core_common /// @see ext_scalar_common #pragma once // Dependency: #include "../ext/scalar_common.hpp" #include "../common.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_common extension included") #endif namespace glm { /// @addtogroup ext_vector_common /// @{ /// Return the minimum component-wise values of 3 inputs /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec min(vec const& a, vec const& b, vec const& c); /// Return the minimum component-wise values of 4 inputs /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec min(vec const& a, vec const& b, vec const& c, vec const& d); /// Return the maximum component-wise values of 3 inputs /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec max(vec const& x, vec const& y, vec const& z); /// Return the maximum component-wise values of 4 inputs /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec max( vec const& x, vec const& y, vec const& z, vec const& w); /// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see std::fmin documentation template GLM_FUNC_DECL vec fmin(vec const& x, T y); /// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see std::fmin documentation template GLM_FUNC_DECL vec fmin(vec const& x, vec const& y); /// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see std::fmin documentation template GLM_FUNC_DECL vec fmin(vec const& a, vec const& b, vec const& c); /// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see std::fmin documentation template GLM_FUNC_DECL vec fmin(vec const& a, vec const& b, vec const& c, vec const& d); /// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see std::fmax documentation template GLM_FUNC_DECL vec fmax(vec const& a, T b); /// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see std::fmax documentation template GLM_FUNC_DECL vec fmax(vec const& a, vec const& b); /// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see std::fmax documentation template GLM_FUNC_DECL vec fmax(vec const& a, vec const& b, vec const& c); /// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see std::fmax documentation template GLM_FUNC_DECL vec fmax(vec const& a, vec const& b, vec const& c, vec const& d); /// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_common template GLM_FUNC_DECL vec fclamp(vec const& x, T minVal, T maxVal); /// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_common template GLM_FUNC_DECL vec fclamp(vec const& x, vec const& minVal, vec const& maxVal); /// Simulate GL_CLAMP OpenGL wrap mode /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_common extension. template GLM_FUNC_DECL vec clamp(vec const& Texcoord); /// Simulate GL_REPEAT OpenGL wrap mode /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_common extension. template GLM_FUNC_DECL vec repeat(vec const& Texcoord); /// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_common extension. template GLM_FUNC_DECL vec mirrorClamp(vec const& Texcoord); /// Simulate GL_MIRROR_REPEAT OpenGL wrap mode /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_common extension. template GLM_FUNC_DECL vec mirrorRepeat(vec const& Texcoord); /// @} }//namespace glm #include "vector_common.inl" ================================================ FILE: android/src/glm/ext/vector_common.inl ================================================ #include "../detail/_vectorize.hpp" namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec min(vec const& x, vec const& y, vec const& z) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'min' only accept floating-point or integer inputs"); return glm::min(glm::min(x, y), z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec min(vec const& x, vec const& y, vec const& z, vec const& w) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'min' only accept floating-point or integer inputs"); return glm::min(glm::min(x, y), glm::min(z, w)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec max(vec const& x, vec const& y, vec const& z) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'max' only accept floating-point or integer inputs"); return glm::max(glm::max(x, y), z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec max(vec const& x, vec const& y, vec const& z, vec const& w) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'max' only accept floating-point or integer inputs"); return glm::max(glm::max(x, y), glm::max(z, w)); } template GLM_FUNC_QUALIFIER vec fmin(vec const& a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); return detail::functor2::call(fmin, a, vec(b)); } template GLM_FUNC_QUALIFIER vec fmin(vec const& a, vec const& b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); return detail::functor2::call(fmin, a, b); } template GLM_FUNC_QUALIFIER vec fmin(vec const& a, vec const& b, vec const& c) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); return fmin(fmin(a, b), c); } template GLM_FUNC_QUALIFIER vec fmin(vec const& a, vec const& b, vec const& c, vec const& d) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); return fmin(fmin(a, b), fmin(c, d)); } template GLM_FUNC_QUALIFIER vec fmax(vec const& a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); return detail::functor2::call(fmax, a, vec(b)); } template GLM_FUNC_QUALIFIER vec fmax(vec const& a, vec const& b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); return detail::functor2::call(fmax, a, b); } template GLM_FUNC_QUALIFIER vec fmax(vec const& a, vec const& b, vec const& c) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); return fmax(fmax(a, b), c); } template GLM_FUNC_QUALIFIER vec fmax(vec const& a, vec const& b, vec const& c, vec const& d) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); return fmax(fmax(a, b), fmax(c, d)); } template GLM_FUNC_QUALIFIER vec fclamp(vec const& x, T minVal, T maxVal) { return fmin(fmax(x, vec(minVal)), vec(maxVal)); } template GLM_FUNC_QUALIFIER vec fclamp(vec const& x, vec const& minVal, vec const& maxVal) { return fmin(fmax(x, minVal), maxVal); } template GLM_FUNC_QUALIFIER vec clamp(vec const& Texcoord) { return glm::clamp(Texcoord, vec(0), vec(1)); } template GLM_FUNC_QUALIFIER vec repeat(vec const& Texcoord) { return glm::fract(Texcoord); } template GLM_FUNC_QUALIFIER vec mirrorClamp(vec const& Texcoord) { return glm::fract(glm::abs(Texcoord)); } template GLM_FUNC_QUALIFIER vec mirrorRepeat(vec const& Texcoord) { vec const Abs = glm::abs(Texcoord); vec const Clamp = glm::mod(glm::floor(Abs), vec(2)); vec const Floor = glm::floor(Abs); vec const Rest = Abs - Floor; vec const Mirror = Clamp + Rest; return mix(Rest, vec(1) - Rest, glm::greaterThanEqual(Mirror, vec(1))); } }//namespace glm ================================================ FILE: android/src/glm/ext/vector_double1.hpp ================================================ /// @ref ext_vector_double1 /// @file glm/ext/vector_double1.hpp /// /// @defgroup ext_vector_double1 GLM_EXT_vector_double1 /// @ingroup ext /// /// Exposes double-precision floating point vector type with one component. /// /// Include to use the features of this extension. /// /// @see ext_vector_double1_precision extension. /// @see ext_vector_float1 extension. #pragma once #include "../detail/type_vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_double1 extension included") #endif namespace glm { /// @addtogroup ext_vector_double1 /// @{ /// 1 components vector of double-precision floating-point numbers. typedef vec<1, double, defaultp> dvec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_double1_precision.hpp ================================================ /// @ref ext_vector_double1_precision /// @file glm/ext/vector_double1_precision.hpp /// /// @defgroup ext_vector_double1_precision GLM_EXT_vector_double1_precision /// @ingroup ext /// /// Exposes highp_dvec1, mediump_dvec1 and lowp_dvec1 types. /// /// Include to use the features of this extension. /// /// @see ext_vector_double1 #pragma once #include "../detail/type_vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_double1_precision extension included") #endif namespace glm { /// @addtogroup ext_vector_double1_precision /// @{ /// 1 component vector of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, double, highp> highp_dvec1; /// 1 component vector of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, double, mediump> mediump_dvec1; /// 1 component vector of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, double, lowp> lowp_dvec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_double2.hpp ================================================ /// @ref core /// @file glm/ext/vector_double2.hpp #pragma once #include "../detail/type_vec2.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 2 components vector of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<2, double, defaultp> dvec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_double2_precision.hpp ================================================ /// @ref core /// @file glm/ext/vector_double2_precision.hpp #pragma once #include "../detail/type_vec2.hpp" namespace glm { /// @addtogroup core_vector_precision /// @{ /// 2 components vector of high double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, double, highp> highp_dvec2; /// 2 components vector of medium double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, double, mediump> mediump_dvec2; /// 2 components vector of low double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, double, lowp> lowp_dvec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_double3.hpp ================================================ /// @ref core /// @file glm/ext/vector_double3.hpp #pragma once #include "../detail/type_vec3.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 3 components vector of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<3, double, defaultp> dvec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_double3_precision.hpp ================================================ /// @ref core /// @file glm/ext/vector_double3_precision.hpp #pragma once #include "../detail/type_vec3.hpp" namespace glm { /// @addtogroup core_vector_precision /// @{ /// 3 components vector of high double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, double, highp> highp_dvec3; /// 3 components vector of medium double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, double, mediump> mediump_dvec3; /// 3 components vector of low double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, double, lowp> lowp_dvec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_double4.hpp ================================================ /// @ref core /// @file glm/ext/vector_double4.hpp #pragma once #include "../detail/type_vec4.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 4 components vector of double-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<4, double, defaultp> dvec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_double4_precision.hpp ================================================ /// @ref core /// @file glm/ext/vector_double4_precision.hpp #pragma once #include "../detail/setup.hpp" #include "../detail/type_vec4.hpp" namespace glm { /// @addtogroup core_vector_precision /// @{ /// 4 components vector of high double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, double, highp> highp_dvec4; /// 4 components vector of medium double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, double, mediump> mediump_dvec4; /// 4 components vector of low double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, double, lowp> lowp_dvec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_float1.hpp ================================================ /// @ref ext_vector_float1 /// @file glm/ext/vector_float1.hpp /// /// @defgroup ext_vector_float1 GLM_EXT_vector_float1 /// @ingroup ext /// /// Exposes single-precision floating point vector type with one component. /// /// Include to use the features of this extension. /// /// @see ext_vector_float1_precision extension. /// @see ext_vector_double1 extension. #pragma once #include "../detail/type_vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_float1 extension included") #endif namespace glm { /// @addtogroup ext_vector_float1 /// @{ /// 1 components vector of single-precision floating-point numbers. typedef vec<1, float, defaultp> vec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_float1_precision.hpp ================================================ /// @ref ext_vector_float1_precision /// @file glm/ext/vector_float1_precision.hpp /// /// @defgroup ext_vector_float1_precision GLM_EXT_vector_float1_precision /// @ingroup ext /// /// Exposes highp_vec1, mediump_vec1 and lowp_vec1 types. /// /// Include to use the features of this extension. /// /// @see ext_vector_float1 extension. #pragma once #include "../detail/type_vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_float1_precision extension included") #endif namespace glm { /// @addtogroup ext_vector_float1_precision /// @{ /// 1 component vector of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, float, highp> highp_vec1; /// 1 component vector of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, float, mediump> mediump_vec1; /// 1 component vector of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, float, lowp> lowp_vec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_float2.hpp ================================================ /// @ref core /// @file glm/ext/vector_float2.hpp #pragma once #include "../detail/type_vec2.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 2 components vector of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<2, float, defaultp> vec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_float2_precision.hpp ================================================ /// @ref core /// @file glm/ext/vector_float2_precision.hpp #pragma once #include "../detail/type_vec2.hpp" namespace glm { /// @addtogroup core_vector_precision /// @{ /// 2 components vector of high single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, float, highp> highp_vec2; /// 2 components vector of medium single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, float, mediump> mediump_vec2; /// 2 components vector of low single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, float, lowp> lowp_vec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_float3.hpp ================================================ /// @ref core /// @file glm/ext/vector_float3.hpp #pragma once #include "../detail/type_vec3.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 3 components vector of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<3, float, defaultp> vec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_float3_precision.hpp ================================================ /// @ref core /// @file glm/ext/vector_float3_precision.hpp #pragma once #include "../detail/type_vec3.hpp" namespace glm { /// @addtogroup core_vector_precision /// @{ /// 3 components vector of high single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, float, highp> highp_vec3; /// 3 components vector of medium single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, float, mediump> mediump_vec3; /// 3 components vector of low single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, float, lowp> lowp_vec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_float4.hpp ================================================ /// @ref core /// @file glm/ext/vector_float4.hpp #pragma once #include "../detail/type_vec4.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 4 components vector of single-precision floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<4, float, defaultp> vec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_float4_precision.hpp ================================================ /// @ref core /// @file glm/ext/vector_float4_precision.hpp #pragma once #include "../detail/type_vec4.hpp" namespace glm { /// @addtogroup core_vector_precision /// @{ /// 4 components vector of high single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, float, highp> highp_vec4; /// 4 components vector of medium single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, float, mediump> mediump_vec4; /// 4 components vector of low single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, float, lowp> lowp_vec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_int1.hpp ================================================ /// @ref ext_vector_int1 /// @file glm/ext/vector_int1.hpp /// /// @defgroup ext_vector_int1 GLM_EXT_vector_int1 /// @ingroup ext /// /// Exposes ivec1 vector type. /// /// Include to use the features of this extension. /// /// @see ext_vector_uint1 extension. /// @see ext_vector_int1_precision extension. #pragma once #include "../detail/type_vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_int1 extension included") #endif namespace glm { /// @addtogroup ext_vector_int1 /// @{ /// 1 component vector of signed integer numbers. typedef vec<1, int, defaultp> ivec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_int1_sized.hpp ================================================ /// @ref ext_vector_int1_sized /// @file glm/ext/vector_int1_sized.hpp /// /// @defgroup ext_vector_int1_sized GLM_EXT_vector_int1_sized /// @ingroup ext /// /// Exposes sized signed integer vector types. /// /// Include to use the features of this extension. /// /// @see ext_scalar_int_sized /// @see ext_vector_uint1_sized #pragma once #include "../ext/vector_int1.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_int1_sized extension included") #endif namespace glm { /// @addtogroup ext_vector_int1_sized /// @{ /// 8 bit signed integer vector of 1 component type. /// /// @see ext_vector_int1_sized typedef vec<1, int8, defaultp> i8vec1; /// 16 bit signed integer vector of 1 component type. /// /// @see ext_vector_int1_sized typedef vec<1, int16, defaultp> i16vec1; /// 32 bit signed integer vector of 1 component type. /// /// @see ext_vector_int1_sized typedef vec<1, int32, defaultp> i32vec1; /// 64 bit signed integer vector of 1 component type. /// /// @see ext_vector_int1_sized typedef vec<1, int64, defaultp> i64vec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_int2.hpp ================================================ /// @ref core /// @file glm/ext/vector_int2.hpp #pragma once #include "../detail/type_vec2.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 2 components vector of signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<2, int, defaultp> ivec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_int2_sized.hpp ================================================ /// @ref ext_vector_int2_sized /// @file glm/ext/vector_int2_sized.hpp /// /// @defgroup ext_vector_int2_sized GLM_EXT_vector_int2_sized /// @ingroup ext /// /// Exposes sized signed integer vector of 2 components type. /// /// Include to use the features of this extension. /// /// @see ext_scalar_int_sized /// @see ext_vector_uint2_sized #pragma once #include "../ext/vector_int2.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_int2_sized extension included") #endif namespace glm { /// @addtogroup ext_vector_int2_sized /// @{ /// 8 bit signed integer vector of 2 components type. /// /// @see ext_vector_int2_sized typedef vec<2, int8, defaultp> i8vec2; /// 16 bit signed integer vector of 2 components type. /// /// @see ext_vector_int2_sized typedef vec<2, int16, defaultp> i16vec2; /// 32 bit signed integer vector of 2 components type. /// /// @see ext_vector_int2_sized typedef vec<2, int32, defaultp> i32vec2; /// 64 bit signed integer vector of 2 components type. /// /// @see ext_vector_int2_sized typedef vec<2, int64, defaultp> i64vec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_int3.hpp ================================================ /// @ref core /// @file glm/ext/vector_int3.hpp #pragma once #include "../detail/type_vec3.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 3 components vector of signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<3, int, defaultp> ivec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_int3_sized.hpp ================================================ /// @ref ext_vector_int3_sized /// @file glm/ext/vector_int3_sized.hpp /// /// @defgroup ext_vector_int3_sized GLM_EXT_vector_int3_sized /// @ingroup ext /// /// Exposes sized signed integer vector of 3 components type. /// /// Include to use the features of this extension. /// /// @see ext_scalar_int_sized /// @see ext_vector_uint3_sized #pragma once #include "../ext/vector_int3.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_int3_sized extension included") #endif namespace glm { /// @addtogroup ext_vector_int3_sized /// @{ /// 8 bit signed integer vector of 3 components type. /// /// @see ext_vector_int3_sized typedef vec<3, int8, defaultp> i8vec3; /// 16 bit signed integer vector of 3 components type. /// /// @see ext_vector_int3_sized typedef vec<3, int16, defaultp> i16vec3; /// 32 bit signed integer vector of 3 components type. /// /// @see ext_vector_int3_sized typedef vec<3, int32, defaultp> i32vec3; /// 64 bit signed integer vector of 3 components type. /// /// @see ext_vector_int3_sized typedef vec<3, int64, defaultp> i64vec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_int4.hpp ================================================ /// @ref core /// @file glm/ext/vector_int4.hpp #pragma once #include "../detail/type_vec4.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 4 components vector of signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<4, int, defaultp> ivec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_int4_sized.hpp ================================================ /// @ref ext_vector_int4_sized /// @file glm/ext/vector_int4_sized.hpp /// /// @defgroup ext_vector_int4_sized GLM_EXT_vector_int4_sized /// @ingroup ext /// /// Exposes sized signed integer vector of 4 components type. /// /// Include to use the features of this extension. /// /// @see ext_scalar_int_sized /// @see ext_vector_uint4_sized #pragma once #include "../ext/vector_int4.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_int4_sized extension included") #endif namespace glm { /// @addtogroup ext_vector_int4_sized /// @{ /// 8 bit signed integer vector of 4 components type. /// /// @see ext_vector_int4_sized typedef vec<4, int8, defaultp> i8vec4; /// 16 bit signed integer vector of 4 components type. /// /// @see ext_vector_int4_sized typedef vec<4, int16, defaultp> i16vec4; /// 32 bit signed integer vector of 4 components type. /// /// @see ext_vector_int4_sized typedef vec<4, int32, defaultp> i32vec4; /// 64 bit signed integer vector of 4 components type. /// /// @see ext_vector_int4_sized typedef vec<4, int64, defaultp> i64vec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_integer.hpp ================================================ /// @ref ext_vector_integer /// @file glm/ext/vector_integer.hpp /// /// @see core (dependence) /// @see ext_vector_integer (dependence) /// /// @defgroup ext_vector_integer GLM_EXT_vector_integer /// @ingroup ext /// /// Include to use the features of this extension. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/_vectorize.hpp" #include "../vector_relational.hpp" #include "../common.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_integer extension included") #endif namespace glm { /// @addtogroup ext_vector_integer /// @{ /// Return true if the value is a power of two number. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed or unsigned integer scalar types. /// @tparam Q Value from qualifier enum /// /// @see ext_vector_integer template GLM_FUNC_DECL vec isPowerOfTwo(vec const& v); /// Return the power of two number which value is just higher the input value, /// round up to a power of two. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed or unsigned integer scalar types. /// @tparam Q Value from qualifier enum /// /// @see ext_vector_integer template GLM_FUNC_DECL vec nextPowerOfTwo(vec const& v); /// Return the power of two number which value is just lower the input value, /// round down to a power of two. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed or unsigned integer scalar types. /// @tparam Q Value from qualifier enum /// /// @see ext_vector_integer template GLM_FUNC_DECL vec prevPowerOfTwo(vec const& v); /// Return true if the 'Value' is a multiple of 'Multiple'. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed or unsigned integer scalar types. /// @tparam Q Value from qualifier enum /// /// @see ext_vector_integer template GLM_FUNC_DECL vec isMultiple(vec const& v, T Multiple); /// Return true if the 'Value' is a multiple of 'Multiple'. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed or unsigned integer scalar types. /// @tparam Q Value from qualifier enum /// /// @see ext_vector_integer template GLM_FUNC_DECL vec isMultiple(vec const& v, vec const& Multiple); /// Higher multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed or unsigned integer scalar types. /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see ext_vector_integer template GLM_FUNC_DECL vec nextMultiple(vec const& v, T Multiple); /// Higher multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed or unsigned integer scalar types. /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see ext_vector_integer template GLM_FUNC_DECL vec nextMultiple(vec const& v, vec const& Multiple); /// Lower multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed or unsigned integer scalar types. /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see ext_vector_integer template GLM_FUNC_DECL vec prevMultiple(vec const& v, T Multiple); /// Lower multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed or unsigned integer scalar types. /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see ext_vector_integer template GLM_FUNC_DECL vec prevMultiple(vec const& v, vec const& Multiple); /// Returns the bit number of the Nth significant bit set to /// 1 in the binary representation of value. /// If value bitcount is less than the Nth significant bit, -1 will be returned. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar types. /// /// @see ext_vector_integer template GLM_FUNC_DECL vec findNSB(vec const& Source, vec SignificantBitCount); /// @} } //namespace glm #include "vector_integer.inl" ================================================ FILE: android/src/glm/ext/vector_integer.inl ================================================ #include "scalar_integer.hpp" namespace glm { template GLM_FUNC_QUALIFIER vec isPowerOfTwo(vec const& Value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isPowerOfTwo' only accept integer inputs"); vec const Result(abs(Value)); return equal(Result & (Result - vec(1)), vec(0)); } template GLM_FUNC_QUALIFIER vec nextPowerOfTwo(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextPowerOfTwo' only accept integer inputs"); return detail::compute_ceilPowerOfTwo::is_signed>::call(v); } template GLM_FUNC_QUALIFIER vec prevPowerOfTwo(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevPowerOfTwo' only accept integer inputs"); return detail::functor1::call(prevPowerOfTwo, v); } template GLM_FUNC_QUALIFIER vec isMultiple(vec const& Value, T Multiple) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isMultiple' only accept integer inputs"); return (Value % Multiple) == vec(0); } template GLM_FUNC_QUALIFIER vec isMultiple(vec const& Value, vec const& Multiple) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isMultiple' only accept integer inputs"); return (Value % Multiple) == vec(0); } template GLM_FUNC_QUALIFIER vec nextMultiple(vec const& Source, T Multiple) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextMultiple' only accept integer inputs"); return detail::functor2::call(nextMultiple, Source, vec(Multiple)); } template GLM_FUNC_QUALIFIER vec nextMultiple(vec const& Source, vec const& Multiple) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextMultiple' only accept integer inputs"); return detail::functor2::call(nextMultiple, Source, Multiple); } template GLM_FUNC_QUALIFIER vec prevMultiple(vec const& Source, T Multiple) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevMultiple' only accept integer inputs"); return detail::functor2::call(prevMultiple, Source, vec(Multiple)); } template GLM_FUNC_QUALIFIER vec prevMultiple(vec const& Source, vec const& Multiple) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevMultiple' only accept integer inputs"); return detail::functor2::call(prevMultiple, Source, Multiple); } template GLM_FUNC_QUALIFIER vec findNSB(vec const& Source, vec SignificantBitCount) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findNSB' only accept integer inputs"); return detail::functor2_vec_int::call(findNSB, Source, SignificantBitCount); } }//namespace glm ================================================ FILE: android/src/glm/ext/vector_packing.hpp ================================================ /// @ref ext_vector_packing /// @file glm/ext/vector_packing.hpp /// /// @see core (dependence) /// /// @defgroup ext_vector_packing GLM_EXT_vector_packing /// @ingroup ext /// /// Include to use the features of this extension. /// /// This extension provides a set of function to convert vectors to packed /// formats. #pragma once // Dependency: #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_packing extension included") #endif namespace glm { /// @addtogroup ext_vector_packing /// @{ /// @} }// namespace glm #include "vector_packing.inl" ================================================ FILE: android/src/glm/ext/vector_packing.inl ================================================ ================================================ FILE: android/src/glm/ext/vector_relational.hpp ================================================ /// @ref ext_vector_relational /// @file glm/ext/vector_relational.hpp /// /// @see core (dependence) /// @see ext_scalar_integer (dependence) /// /// @defgroup ext_vector_relational GLM_EXT_vector_relational /// @ingroup ext /// /// Exposes comparison functions for vector types that take a user defined epsilon values. /// /// Include to use the features of this extension. /// /// @see core_vector_relational /// @see ext_scalar_relational /// @see ext_matrix_relational #pragma once // Dependencies #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_relational extension included") #endif namespace glm { /// @addtogroup ext_vector_relational /// @{ /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(vec const& x, vec const& y, T epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(vec const& x, vec const& y, vec const& epsilon); /// Returns the component-wise comparison of |x - y| >= epsilon. /// True if this expression is not satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, T epsilon); /// Returns the component-wise comparison of |x - y| >= epsilon. /// True if this expression is not satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, vec const& epsilon); /// Returns the component-wise comparison between two vectors in term of ULPs. /// True if this expression is satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(vec const& x, vec const& y, int ULPs); /// Returns the component-wise comparison between two vectors in term of ULPs. /// True if this expression is satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(vec const& x, vec const& y, vec const& ULPs); /// Returns the component-wise comparison between two vectors in term of ULPs. /// True if this expression is not satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, int ULPs); /// Returns the component-wise comparison between two vectors in term of ULPs. /// True if this expression is not satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, vec const& ULPs); /// @} }//namespace glm #include "vector_relational.inl" ================================================ FILE: android/src/glm/ext/vector_relational.inl ================================================ #include "../vector_relational.hpp" #include "../common.hpp" #include "../detail/qualifier.hpp" #include "../detail/type_float.hpp" namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(vec const& x, vec const& y, T Epsilon) { return equal(x, y, vec(Epsilon)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(vec const& x, vec const& y, vec const& Epsilon) { return lessThanEqual(abs(x - y), Epsilon); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, T Epsilon) { return notEqual(x, y, vec(Epsilon)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, vec const& Epsilon) { return greaterThan(abs(x - y), Epsilon); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(vec const& x, vec const& y, int MaxULPs) { return equal(x, y, vec(MaxULPs)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec equal(vec const& x, vec const& y, vec const& MaxULPs) { vec Result(false); for(length_t i = 0; i < L; ++i) { detail::float_t const a(x[i]); detail::float_t const b(y[i]); // Different signs means they do not match. if(a.negative() != b.negative()) { // Check for equality to make sure +0==-0 Result[i] = a.mantissa() == b.mantissa() && a.exponent() == b.exponent(); } else { // Find the difference in ULPs. typename detail::float_t::int_type const DiffULPs = abs(a.i - b.i); Result[i] = DiffULPs <= MaxULPs[i]; } } return Result; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, int MaxULPs) { return notEqual(x, y, vec(MaxULPs)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y, vec const& MaxULPs) { return not_(equal(x, y, MaxULPs)); } }//namespace glm ================================================ FILE: android/src/glm/ext/vector_uint1.hpp ================================================ /// @ref ext_vector_uint1 /// @file glm/ext/vector_uint1.hpp /// /// @defgroup ext_vector_uint1 GLM_EXT_vector_uint1 /// @ingroup ext /// /// Exposes uvec1 vector type. /// /// Include to use the features of this extension. /// /// @see ext_vector_int1 extension. /// @see ext_vector_uint1_precision extension. #pragma once #include "../detail/type_vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_uint1 extension included") #endif namespace glm { /// @addtogroup ext_vector_uint1 /// @{ /// 1 component vector of unsigned integer numbers. typedef vec<1, unsigned int, defaultp> uvec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_uint1_sized.hpp ================================================ /// @ref ext_vector_uint1_sized /// @file glm/ext/vector_uint1_sized.hpp /// /// @defgroup ext_vector_uint1_sized GLM_EXT_vector_uint1_sized /// @ingroup ext /// /// Exposes sized unsigned integer vector types. /// /// Include to use the features of this extension. /// /// @see ext_scalar_uint_sized /// @see ext_vector_int1_sized #pragma once #include "../ext/vector_uint1.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_uint1_sized extension included") #endif namespace glm { /// @addtogroup ext_vector_uint1_sized /// @{ /// 8 bit unsigned integer vector of 1 component type. /// /// @see ext_vector_uint1_sized typedef vec<1, uint8, defaultp> u8vec1; /// 16 bit unsigned integer vector of 1 component type. /// /// @see ext_vector_uint1_sized typedef vec<1, uint16, defaultp> u16vec1; /// 32 bit unsigned integer vector of 1 component type. /// /// @see ext_vector_uint1_sized typedef vec<1, uint32, defaultp> u32vec1; /// 64 bit unsigned integer vector of 1 component type. /// /// @see ext_vector_uint1_sized typedef vec<1, uint64, defaultp> u64vec1; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_uint2.hpp ================================================ /// @ref core /// @file glm/ext/vector_uint2.hpp #pragma once #include "../detail/type_vec2.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 2 components vector of unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<2, unsigned int, defaultp> uvec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_uint2_sized.hpp ================================================ /// @ref ext_vector_uint2_sized /// @file glm/ext/vector_uint2_sized.hpp /// /// @defgroup ext_vector_uint2_sized GLM_EXT_vector_uint2_sized /// @ingroup ext /// /// Exposes sized unsigned integer vector of 2 components type. /// /// Include to use the features of this extension. /// /// @see ext_scalar_uint_sized /// @see ext_vector_int2_sized #pragma once #include "../ext/vector_uint2.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_uint2_sized extension included") #endif namespace glm { /// @addtogroup ext_vector_uint2_sized /// @{ /// 8 bit unsigned integer vector of 2 components type. /// /// @see ext_vector_uint2_sized typedef vec<2, uint8, defaultp> u8vec2; /// 16 bit unsigned integer vector of 2 components type. /// /// @see ext_vector_uint2_sized typedef vec<2, uint16, defaultp> u16vec2; /// 32 bit unsigned integer vector of 2 components type. /// /// @see ext_vector_uint2_sized typedef vec<2, uint32, defaultp> u32vec2; /// 64 bit unsigned integer vector of 2 components type. /// /// @see ext_vector_uint2_sized typedef vec<2, uint64, defaultp> u64vec2; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_uint3.hpp ================================================ /// @ref core /// @file glm/ext/vector_uint3.hpp #pragma once #include "../detail/type_vec3.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 3 components vector of unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<3, unsigned int, defaultp> uvec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_uint3_sized.hpp ================================================ /// @ref ext_vector_uint3_sized /// @file glm/ext/vector_uint3_sized.hpp /// /// @defgroup ext_vector_uint3_sized GLM_EXT_vector_uint3_sized /// @ingroup ext /// /// Exposes sized unsigned integer vector of 3 components type. /// /// Include to use the features of this extension. /// /// @see ext_scalar_uint_sized /// @see ext_vector_int3_sized #pragma once #include "../ext/vector_uint3.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_uint3_sized extension included") #endif namespace glm { /// @addtogroup ext_vector_uint3_sized /// @{ /// 8 bit unsigned integer vector of 3 components type. /// /// @see ext_vector_uint3_sized typedef vec<3, uint8, defaultp> u8vec3; /// 16 bit unsigned integer vector of 3 components type. /// /// @see ext_vector_uint3_sized typedef vec<3, uint16, defaultp> u16vec3; /// 32 bit unsigned integer vector of 3 components type. /// /// @see ext_vector_uint3_sized typedef vec<3, uint32, defaultp> u32vec3; /// 64 bit unsigned integer vector of 3 components type. /// /// @see ext_vector_uint3_sized typedef vec<3, uint64, defaultp> u64vec3; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_uint4.hpp ================================================ /// @ref core /// @file glm/ext/vector_uint4.hpp #pragma once #include "../detail/type_vec4.hpp" namespace glm { /// @addtogroup core_vector /// @{ /// 4 components vector of unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef vec<4, unsigned int, defaultp> uvec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_uint4_sized.hpp ================================================ /// @ref ext_vector_uint4_sized /// @file glm/ext/vector_uint4_sized.hpp /// /// @defgroup ext_vector_uint4_sized GLM_EXT_vector_uint4_sized /// @ingroup ext /// /// Exposes sized unsigned integer vector of 4 components type. /// /// Include to use the features of this extension. /// /// @see ext_scalar_uint_sized /// @see ext_vector_int4_sized #pragma once #include "../ext/vector_uint4.hpp" #include "../ext/scalar_uint_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_uint4_sized extension included") #endif namespace glm { /// @addtogroup ext_vector_uint4_sized /// @{ /// 8 bit unsigned integer vector of 4 components type. /// /// @see ext_vector_uint4_sized typedef vec<4, uint8, defaultp> u8vec4; /// 16 bit unsigned integer vector of 4 components type. /// /// @see ext_vector_uint4_sized typedef vec<4, uint16, defaultp> u16vec4; /// 32 bit unsigned integer vector of 4 components type. /// /// @see ext_vector_uint4_sized typedef vec<4, uint32, defaultp> u32vec4; /// 64 bit unsigned integer vector of 4 components type. /// /// @see ext_vector_uint4_sized typedef vec<4, uint64, defaultp> u64vec4; /// @} }//namespace glm ================================================ FILE: android/src/glm/ext/vector_ulp.hpp ================================================ /// @ref ext_vector_ulp /// @file glm/ext/vector_ulp.hpp /// /// @defgroup ext_vector_ulp GLM_EXT_vector_ulp /// @ingroup ext /// /// Allow the measurement of the accuracy of a function against a reference /// implementation. This extension works on floating-point data and provide results /// in ULP. /// /// Include to use the features of this extension. /// /// @see ext_scalar_ulp /// @see ext_scalar_relational /// @see ext_vector_relational #pragma once // Dependencies #include "../ext/scalar_ulp.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_ulp extension included") #endif namespace glm { /// Return the next ULP value(s) after the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see ext_scalar_ulp template GLM_FUNC_DECL vec nextFloat(vec const& x); /// Return the value(s) ULP distance after the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see ext_scalar_ulp template GLM_FUNC_DECL vec nextFloat(vec const& x, int ULPs); /// Return the value(s) ULP distance after the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see ext_scalar_ulp template GLM_FUNC_DECL vec nextFloat(vec const& x, vec const& ULPs); /// Return the previous ULP value(s) before the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see ext_scalar_ulp template GLM_FUNC_DECL vec prevFloat(vec const& x); /// Return the value(s) ULP distance before the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see ext_scalar_ulp template GLM_FUNC_DECL vec prevFloat(vec const& x, int ULPs); /// Return the value(s) ULP distance before the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see ext_scalar_ulp template GLM_FUNC_DECL vec prevFloat(vec const& x, vec const& ULPs); /// Return the distance in the number of ULP between 2 single-precision floating-point scalars. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see ext_scalar_ulp template GLM_FUNC_DECL vec floatDistance(vec const& x, vec const& y); /// Return the distance in the number of ULP between 2 double-precision floating-point scalars. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see ext_scalar_ulp template GLM_FUNC_DECL vec floatDistance(vec const& x, vec const& y); /// @} }//namespace glm #include "vector_ulp.inl" ================================================ FILE: android/src/glm/ext/vector_ulp.inl ================================================ namespace glm { template GLM_FUNC_QUALIFIER vec nextFloat(vec const& x) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = nextFloat(x[i]); return Result; } template GLM_FUNC_QUALIFIER vec nextFloat(vec const& x, int ULPs) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = nextFloat(x[i], ULPs); return Result; } template GLM_FUNC_QUALIFIER vec nextFloat(vec const& x, vec const& ULPs) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = nextFloat(x[i], ULPs[i]); return Result; } template GLM_FUNC_QUALIFIER vec prevFloat(vec const& x) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prevFloat(x[i]); return Result; } template GLM_FUNC_QUALIFIER vec prevFloat(vec const& x, int ULPs) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prevFloat(x[i], ULPs); return Result; } template GLM_FUNC_QUALIFIER vec prevFloat(vec const& x, vec const& ULPs) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prevFloat(x[i], ULPs[i]); return Result; } template GLM_FUNC_QUALIFIER vec floatDistance(vec const& x, vec const& y) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = floatDistance(x[i], y[i]); return Result; } template GLM_FUNC_QUALIFIER vec floatDistance(vec const& x, vec const& y) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = floatDistance(x[i], y[i]); return Result; } }//namespace glm ================================================ FILE: android/src/glm/ext.hpp ================================================ /// @file glm/ext.hpp /// /// @ref core (Dependence) #include "detail/setup.hpp" #pragma once #include "glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED) # define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED # pragma message("GLM: All extensions included (not recommended)") #endif//GLM_MESSAGES #include "./ext/matrix_clip_space.hpp" #include "./ext/matrix_common.hpp" #include "./ext/matrix_double2x2.hpp" #include "./ext/matrix_double2x2_precision.hpp" #include "./ext/matrix_double2x3.hpp" #include "./ext/matrix_double2x3_precision.hpp" #include "./ext/matrix_double2x4.hpp" #include "./ext/matrix_double2x4_precision.hpp" #include "./ext/matrix_double3x2.hpp" #include "./ext/matrix_double3x2_precision.hpp" #include "./ext/matrix_double3x3.hpp" #include "./ext/matrix_double3x3_precision.hpp" #include "./ext/matrix_double3x4.hpp" #include "./ext/matrix_double3x4_precision.hpp" #include "./ext/matrix_double4x2.hpp" #include "./ext/matrix_double4x2_precision.hpp" #include "./ext/matrix_double4x3.hpp" #include "./ext/matrix_double4x3_precision.hpp" #include "./ext/matrix_double4x4.hpp" #include "./ext/matrix_double4x4_precision.hpp" #include "./ext/matrix_float2x2.hpp" #include "./ext/matrix_float2x2_precision.hpp" #include "./ext/matrix_float2x3.hpp" #include "./ext/matrix_float2x3_precision.hpp" #include "./ext/matrix_float2x4.hpp" #include "./ext/matrix_float2x4_precision.hpp" #include "./ext/matrix_float3x2.hpp" #include "./ext/matrix_float3x2_precision.hpp" #include "./ext/matrix_float3x3.hpp" #include "./ext/matrix_float3x3_precision.hpp" #include "./ext/matrix_float3x4.hpp" #include "./ext/matrix_float3x4_precision.hpp" #include "./ext/matrix_float4x2.hpp" #include "./ext/matrix_float4x2_precision.hpp" #include "./ext/matrix_float4x3.hpp" #include "./ext/matrix_float4x3_precision.hpp" #include "./ext/matrix_float4x4.hpp" #include "./ext/matrix_float4x4_precision.hpp" #include "./ext/matrix_int2x2.hpp" #include "./ext/matrix_int2x2_sized.hpp" #include "./ext/matrix_int2x3.hpp" #include "./ext/matrix_int2x3_sized.hpp" #include "./ext/matrix_int2x4.hpp" #include "./ext/matrix_int2x4_sized.hpp" #include "./ext/matrix_int3x2.hpp" #include "./ext/matrix_int3x2_sized.hpp" #include "./ext/matrix_int3x3.hpp" #include "./ext/matrix_int3x3_sized.hpp" #include "./ext/matrix_int3x4.hpp" #include "./ext/matrix_int3x4_sized.hpp" #include "./ext/matrix_int4x2.hpp" #include "./ext/matrix_int4x2_sized.hpp" #include "./ext/matrix_int4x3.hpp" #include "./ext/matrix_int4x3_sized.hpp" #include "./ext/matrix_int4x4.hpp" #include "./ext/matrix_int4x4_sized.hpp" #include "./ext/matrix_uint2x2.hpp" #include "./ext/matrix_uint2x2_sized.hpp" #include "./ext/matrix_uint2x3.hpp" #include "./ext/matrix_uint2x3_sized.hpp" #include "./ext/matrix_uint2x4.hpp" #include "./ext/matrix_uint2x4_sized.hpp" #include "./ext/matrix_uint3x2.hpp" #include "./ext/matrix_uint3x2_sized.hpp" #include "./ext/matrix_uint3x3.hpp" #include "./ext/matrix_uint3x3_sized.hpp" #include "./ext/matrix_uint3x4.hpp" #include "./ext/matrix_uint3x4_sized.hpp" #include "./ext/matrix_uint4x2.hpp" #include "./ext/matrix_uint4x2_sized.hpp" #include "./ext/matrix_uint4x3.hpp" #include "./ext/matrix_uint4x3_sized.hpp" #include "./ext/matrix_uint4x4.hpp" #include "./ext/matrix_uint4x4_sized.hpp" #include "./ext/matrix_projection.hpp" #include "./ext/matrix_relational.hpp" #include "./ext/matrix_transform.hpp" #include "./ext/quaternion_common.hpp" #include "./ext/quaternion_double.hpp" #include "./ext/quaternion_double_precision.hpp" #include "./ext/quaternion_float.hpp" #include "./ext/quaternion_float_precision.hpp" #include "./ext/quaternion_exponential.hpp" #include "./ext/quaternion_geometric.hpp" #include "./ext/quaternion_relational.hpp" #include "./ext/quaternion_transform.hpp" #include "./ext/quaternion_trigonometric.hpp" #include "./ext/scalar_common.hpp" #include "./ext/scalar_constants.hpp" #include "./ext/scalar_integer.hpp" #include "./ext/scalar_packing.hpp" #include "./ext/scalar_relational.hpp" #include "./ext/scalar_ulp.hpp" #include "./ext/scalar_int_sized.hpp" #include "./ext/scalar_uint_sized.hpp" #include "./ext/vector_common.hpp" #include "./ext/vector_integer.hpp" #include "./ext/vector_packing.hpp" #include "./ext/vector_relational.hpp" #include "./ext/vector_ulp.hpp" #include "./ext/vector_bool1.hpp" #include "./ext/vector_bool1_precision.hpp" #include "./ext/vector_bool2.hpp" #include "./ext/vector_bool2_precision.hpp" #include "./ext/vector_bool3.hpp" #include "./ext/vector_bool3_precision.hpp" #include "./ext/vector_bool4.hpp" #include "./ext/vector_bool4_precision.hpp" #include "./ext/vector_double1.hpp" #include "./ext/vector_double1_precision.hpp" #include "./ext/vector_double2.hpp" #include "./ext/vector_double2_precision.hpp" #include "./ext/vector_double3.hpp" #include "./ext/vector_double3_precision.hpp" #include "./ext/vector_double4.hpp" #include "./ext/vector_double4_precision.hpp" #include "./ext/vector_float1.hpp" #include "./ext/vector_float1_precision.hpp" #include "./ext/vector_float2.hpp" #include "./ext/vector_float2_precision.hpp" #include "./ext/vector_float3.hpp" #include "./ext/vector_float3_precision.hpp" #include "./ext/vector_float4.hpp" #include "./ext/vector_float4_precision.hpp" #include "./ext/vector_int1.hpp" #include "./ext/vector_int1_sized.hpp" #include "./ext/vector_int2.hpp" #include "./ext/vector_int2_sized.hpp" #include "./ext/vector_int3.hpp" #include "./ext/vector_int3_sized.hpp" #include "./ext/vector_int4.hpp" #include "./ext/vector_int4_sized.hpp" #include "./ext/vector_uint1.hpp" #include "./ext/vector_uint1_sized.hpp" #include "./ext/vector_uint2.hpp" #include "./ext/vector_uint2_sized.hpp" #include "./ext/vector_uint3.hpp" #include "./ext/vector_uint3_sized.hpp" #include "./ext/vector_uint4.hpp" #include "./ext/vector_uint4_sized.hpp" #include "./gtc/bitfield.hpp" #include "./gtc/color_space.hpp" #include "./gtc/constants.hpp" #include "./gtc/epsilon.hpp" #include "./gtc/integer.hpp" #include "./gtc/matrix_access.hpp" #include "./gtc/matrix_integer.hpp" #include "./gtc/matrix_inverse.hpp" #include "./gtc/matrix_transform.hpp" #include "./gtc/noise.hpp" #include "./gtc/packing.hpp" #include "./gtc/quaternion.hpp" #include "./gtc/random.hpp" #include "./gtc/reciprocal.hpp" #include "./gtc/round.hpp" #include "./gtc/type_precision.hpp" #include "./gtc/type_ptr.hpp" #include "./gtc/ulp.hpp" #include "./gtc/vec1.hpp" #if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE # include "./gtc/type_aligned.hpp" #endif #ifdef GLM_ENABLE_EXPERIMENTAL #include "./gtx/associated_min_max.hpp" #include "./gtx/bit.hpp" #include "./gtx/closest_point.hpp" #include "./gtx/color_encoding.hpp" #include "./gtx/color_space.hpp" #include "./gtx/color_space_YCoCg.hpp" #include "./gtx/compatibility.hpp" #include "./gtx/component_wise.hpp" #include "./gtx/dual_quaternion.hpp" #include "./gtx/euler_angles.hpp" #include "./gtx/extend.hpp" #include "./gtx/extended_min_max.hpp" #include "./gtx/fast_exponential.hpp" #include "./gtx/fast_square_root.hpp" #include "./gtx/fast_trigonometry.hpp" #include "./gtx/functions.hpp" #include "./gtx/gradient_paint.hpp" #include "./gtx/handed_coordinate_space.hpp" #include "./gtx/integer.hpp" #include "./gtx/intersect.hpp" #include "./gtx/log_base.hpp" #include "./gtx/matrix_cross_product.hpp" #include "./gtx/matrix_interpolation.hpp" #include "./gtx/matrix_major_storage.hpp" #include "./gtx/matrix_operation.hpp" #include "./gtx/matrix_query.hpp" #include "./gtx/mixed_product.hpp" #include "./gtx/norm.hpp" #include "./gtx/normal.hpp" #include "./gtx/normalize_dot.hpp" #include "./gtx/number_precision.hpp" #include "./gtx/optimum_pow.hpp" #include "./gtx/orthonormalize.hpp" #include "./gtx/perpendicular.hpp" #include "./gtx/polar_coordinates.hpp" #include "./gtx/projection.hpp" #include "./gtx/quaternion.hpp" #include "./gtx/raw_data.hpp" #include "./gtx/rotate_vector.hpp" #include "./gtx/spline.hpp" #include "./gtx/std_based_type.hpp" #if !(GLM_COMPILER & GLM_COMPILER_CUDA) # include "./gtx/string_cast.hpp" #endif #include "./gtx/transform.hpp" #include "./gtx/transform2.hpp" #include "./gtx/vec_swizzle.hpp" #include "./gtx/vector_angle.hpp" #include "./gtx/vector_query.hpp" #include "./gtx/wrap.hpp" #if GLM_HAS_TEMPLATE_ALIASES # include "./gtx/scalar_multiplication.hpp" #endif #if GLM_HAS_RANGE_FOR # include "./gtx/range.hpp" #endif #endif//GLM_ENABLE_EXPERIMENTAL ================================================ FILE: android/src/glm/fwd.hpp ================================================ #pragma once #include "detail/qualifier.hpp" namespace glm { #if GLM_HAS_EXTENDED_INTEGER_TYPE typedef std::int8_t int8; typedef std::int16_t int16; typedef std::int32_t int32; typedef std::int64_t int64; typedef std::uint8_t uint8; typedef std::uint16_t uint16; typedef std::uint32_t uint32; typedef std::uint64_t uint64; #else typedef signed char int8; typedef signed short int16; typedef signed int int32; typedef detail::int64 int64; typedef unsigned char uint8; typedef unsigned short uint16; typedef unsigned int uint32; typedef detail::uint64 uint64; #endif // Scalar int typedef int8 lowp_i8; typedef int8 mediump_i8; typedef int8 highp_i8; typedef int8 i8; typedef int8 lowp_int8; typedef int8 mediump_int8; typedef int8 highp_int8; typedef int8 lowp_int8_t; typedef int8 mediump_int8_t; typedef int8 highp_int8_t; typedef int8 int8_t; typedef int16 lowp_i16; typedef int16 mediump_i16; typedef int16 highp_i16; typedef int16 i16; typedef int16 lowp_int16; typedef int16 mediump_int16; typedef int16 highp_int16; typedef int16 lowp_int16_t; typedef int16 mediump_int16_t; typedef int16 highp_int16_t; typedef int16 int16_t; typedef int32 lowp_i32; typedef int32 mediump_i32; typedef int32 highp_i32; typedef int32 i32; typedef int32 lowp_int32; typedef int32 mediump_int32; typedef int32 highp_int32; typedef int32 lowp_int32_t; typedef int32 mediump_int32_t; typedef int32 highp_int32_t; typedef int32 int32_t; typedef int64 lowp_i64; typedef int64 mediump_i64; typedef int64 highp_i64; typedef int64 i64; typedef int64 lowp_int64; typedef int64 mediump_int64; typedef int64 highp_int64; typedef int64 lowp_int64_t; typedef int64 mediump_int64_t; typedef int64 highp_int64_t; typedef int64 int64_t; // Scalar uint typedef unsigned int uint; typedef uint8 lowp_u8; typedef uint8 mediump_u8; typedef uint8 highp_u8; typedef uint8 u8; typedef uint8 lowp_uint8; typedef uint8 mediump_uint8; typedef uint8 highp_uint8; typedef uint8 lowp_uint8_t; typedef uint8 mediump_uint8_t; typedef uint8 highp_uint8_t; typedef uint8 uint8_t; typedef uint16 lowp_u16; typedef uint16 mediump_u16; typedef uint16 highp_u16; typedef uint16 u16; typedef uint16 lowp_uint16; typedef uint16 mediump_uint16; typedef uint16 highp_uint16; typedef uint16 lowp_uint16_t; typedef uint16 mediump_uint16_t; typedef uint16 highp_uint16_t; typedef uint16 uint16_t; typedef uint32 lowp_u32; typedef uint32 mediump_u32; typedef uint32 highp_u32; typedef uint32 u32; typedef uint32 lowp_uint32; typedef uint32 mediump_uint32; typedef uint32 highp_uint32; typedef uint32 lowp_uint32_t; typedef uint32 mediump_uint32_t; typedef uint32 highp_uint32_t; typedef uint32 uint32_t; typedef uint64 lowp_u64; typedef uint64 mediump_u64; typedef uint64 highp_u64; typedef uint64 u64; typedef uint64 lowp_uint64; typedef uint64 mediump_uint64; typedef uint64 highp_uint64; typedef uint64 lowp_uint64_t; typedef uint64 mediump_uint64_t; typedef uint64 highp_uint64_t; typedef uint64 uint64_t; // Scalar float typedef float lowp_f32; typedef float mediump_f32; typedef float highp_f32; typedef float f32; typedef float lowp_float32; typedef float mediump_float32; typedef float highp_float32; typedef float float32; typedef float lowp_float32_t; typedef float mediump_float32_t; typedef float highp_float32_t; typedef float float32_t; typedef double lowp_f64; typedef double mediump_f64; typedef double highp_f64; typedef double f64; typedef double lowp_float64; typedef double mediump_float64; typedef double highp_float64; typedef double float64; typedef double lowp_float64_t; typedef double mediump_float64_t; typedef double highp_float64_t; typedef double float64_t; // Vector bool typedef vec<1, bool, lowp> lowp_bvec1; typedef vec<2, bool, lowp> lowp_bvec2; typedef vec<3, bool, lowp> lowp_bvec3; typedef vec<4, bool, lowp> lowp_bvec4; typedef vec<1, bool, mediump> mediump_bvec1; typedef vec<2, bool, mediump> mediump_bvec2; typedef vec<3, bool, mediump> mediump_bvec3; typedef vec<4, bool, mediump> mediump_bvec4; typedef vec<1, bool, highp> highp_bvec1; typedef vec<2, bool, highp> highp_bvec2; typedef vec<3, bool, highp> highp_bvec3; typedef vec<4, bool, highp> highp_bvec4; typedef vec<1, bool, defaultp> bvec1; typedef vec<2, bool, defaultp> bvec2; typedef vec<3, bool, defaultp> bvec3; typedef vec<4, bool, defaultp> bvec4; // Vector int typedef vec<1, int, lowp> lowp_ivec1; typedef vec<2, int, lowp> lowp_ivec2; typedef vec<3, int, lowp> lowp_ivec3; typedef vec<4, int, lowp> lowp_ivec4; typedef vec<1, int, mediump> mediump_ivec1; typedef vec<2, int, mediump> mediump_ivec2; typedef vec<3, int, mediump> mediump_ivec3; typedef vec<4, int, mediump> mediump_ivec4; typedef vec<1, int, highp> highp_ivec1; typedef vec<2, int, highp> highp_ivec2; typedef vec<3, int, highp> highp_ivec3; typedef vec<4, int, highp> highp_ivec4; typedef vec<1, int, defaultp> ivec1; typedef vec<2, int, defaultp> ivec2; typedef vec<3, int, defaultp> ivec3; typedef vec<4, int, defaultp> ivec4; typedef vec<1, i8, lowp> lowp_i8vec1; typedef vec<2, i8, lowp> lowp_i8vec2; typedef vec<3, i8, lowp> lowp_i8vec3; typedef vec<4, i8, lowp> lowp_i8vec4; typedef vec<1, i8, mediump> mediump_i8vec1; typedef vec<2, i8, mediump> mediump_i8vec2; typedef vec<3, i8, mediump> mediump_i8vec3; typedef vec<4, i8, mediump> mediump_i8vec4; typedef vec<1, i8, highp> highp_i8vec1; typedef vec<2, i8, highp> highp_i8vec2; typedef vec<3, i8, highp> highp_i8vec3; typedef vec<4, i8, highp> highp_i8vec4; typedef vec<1, i8, defaultp> i8vec1; typedef vec<2, i8, defaultp> i8vec2; typedef vec<3, i8, defaultp> i8vec3; typedef vec<4, i8, defaultp> i8vec4; typedef vec<1, i16, lowp> lowp_i16vec1; typedef vec<2, i16, lowp> lowp_i16vec2; typedef vec<3, i16, lowp> lowp_i16vec3; typedef vec<4, i16, lowp> lowp_i16vec4; typedef vec<1, i16, mediump> mediump_i16vec1; typedef vec<2, i16, mediump> mediump_i16vec2; typedef vec<3, i16, mediump> mediump_i16vec3; typedef vec<4, i16, mediump> mediump_i16vec4; typedef vec<1, i16, highp> highp_i16vec1; typedef vec<2, i16, highp> highp_i16vec2; typedef vec<3, i16, highp> highp_i16vec3; typedef vec<4, i16, highp> highp_i16vec4; typedef vec<1, i16, defaultp> i16vec1; typedef vec<2, i16, defaultp> i16vec2; typedef vec<3, i16, defaultp> i16vec3; typedef vec<4, i16, defaultp> i16vec4; typedef vec<1, i32, lowp> lowp_i32vec1; typedef vec<2, i32, lowp> lowp_i32vec2; typedef vec<3, i32, lowp> lowp_i32vec3; typedef vec<4, i32, lowp> lowp_i32vec4; typedef vec<1, i32, mediump> mediump_i32vec1; typedef vec<2, i32, mediump> mediump_i32vec2; typedef vec<3, i32, mediump> mediump_i32vec3; typedef vec<4, i32, mediump> mediump_i32vec4; typedef vec<1, i32, highp> highp_i32vec1; typedef vec<2, i32, highp> highp_i32vec2; typedef vec<3, i32, highp> highp_i32vec3; typedef vec<4, i32, highp> highp_i32vec4; typedef vec<1, i32, defaultp> i32vec1; typedef vec<2, i32, defaultp> i32vec2; typedef vec<3, i32, defaultp> i32vec3; typedef vec<4, i32, defaultp> i32vec4; typedef vec<1, i64, lowp> lowp_i64vec1; typedef vec<2, i64, lowp> lowp_i64vec2; typedef vec<3, i64, lowp> lowp_i64vec3; typedef vec<4, i64, lowp> lowp_i64vec4; typedef vec<1, i64, mediump> mediump_i64vec1; typedef vec<2, i64, mediump> mediump_i64vec2; typedef vec<3, i64, mediump> mediump_i64vec3; typedef vec<4, i64, mediump> mediump_i64vec4; typedef vec<1, i64, highp> highp_i64vec1; typedef vec<2, i64, highp> highp_i64vec2; typedef vec<3, i64, highp> highp_i64vec3; typedef vec<4, i64, highp> highp_i64vec4; typedef vec<1, i64, defaultp> i64vec1; typedef vec<2, i64, defaultp> i64vec2; typedef vec<3, i64, defaultp> i64vec3; typedef vec<4, i64, defaultp> i64vec4; // Vector uint typedef vec<1, uint, lowp> lowp_uvec1; typedef vec<2, uint, lowp> lowp_uvec2; typedef vec<3, uint, lowp> lowp_uvec3; typedef vec<4, uint, lowp> lowp_uvec4; typedef vec<1, uint, mediump> mediump_uvec1; typedef vec<2, uint, mediump> mediump_uvec2; typedef vec<3, uint, mediump> mediump_uvec3; typedef vec<4, uint, mediump> mediump_uvec4; typedef vec<1, uint, highp> highp_uvec1; typedef vec<2, uint, highp> highp_uvec2; typedef vec<3, uint, highp> highp_uvec3; typedef vec<4, uint, highp> highp_uvec4; typedef vec<1, uint, defaultp> uvec1; typedef vec<2, uint, defaultp> uvec2; typedef vec<3, uint, defaultp> uvec3; typedef vec<4, uint, defaultp> uvec4; typedef vec<1, u8, lowp> lowp_u8vec1; typedef vec<2, u8, lowp> lowp_u8vec2; typedef vec<3, u8, lowp> lowp_u8vec3; typedef vec<4, u8, lowp> lowp_u8vec4; typedef vec<1, u8, mediump> mediump_u8vec1; typedef vec<2, u8, mediump> mediump_u8vec2; typedef vec<3, u8, mediump> mediump_u8vec3; typedef vec<4, u8, mediump> mediump_u8vec4; typedef vec<1, u8, highp> highp_u8vec1; typedef vec<2, u8, highp> highp_u8vec2; typedef vec<3, u8, highp> highp_u8vec3; typedef vec<4, u8, highp> highp_u8vec4; typedef vec<1, u8, defaultp> u8vec1; typedef vec<2, u8, defaultp> u8vec2; typedef vec<3, u8, defaultp> u8vec3; typedef vec<4, u8, defaultp> u8vec4; typedef vec<1, u16, lowp> lowp_u16vec1; typedef vec<2, u16, lowp> lowp_u16vec2; typedef vec<3, u16, lowp> lowp_u16vec3; typedef vec<4, u16, lowp> lowp_u16vec4; typedef vec<1, u16, mediump> mediump_u16vec1; typedef vec<2, u16, mediump> mediump_u16vec2; typedef vec<3, u16, mediump> mediump_u16vec3; typedef vec<4, u16, mediump> mediump_u16vec4; typedef vec<1, u16, highp> highp_u16vec1; typedef vec<2, u16, highp> highp_u16vec2; typedef vec<3, u16, highp> highp_u16vec3; typedef vec<4, u16, highp> highp_u16vec4; typedef vec<1, u16, defaultp> u16vec1; typedef vec<2, u16, defaultp> u16vec2; typedef vec<3, u16, defaultp> u16vec3; typedef vec<4, u16, defaultp> u16vec4; typedef vec<1, u32, lowp> lowp_u32vec1; typedef vec<2, u32, lowp> lowp_u32vec2; typedef vec<3, u32, lowp> lowp_u32vec3; typedef vec<4, u32, lowp> lowp_u32vec4; typedef vec<1, u32, mediump> mediump_u32vec1; typedef vec<2, u32, mediump> mediump_u32vec2; typedef vec<3, u32, mediump> mediump_u32vec3; typedef vec<4, u32, mediump> mediump_u32vec4; typedef vec<1, u32, highp> highp_u32vec1; typedef vec<2, u32, highp> highp_u32vec2; typedef vec<3, u32, highp> highp_u32vec3; typedef vec<4, u32, highp> highp_u32vec4; typedef vec<1, u32, defaultp> u32vec1; typedef vec<2, u32, defaultp> u32vec2; typedef vec<3, u32, defaultp> u32vec3; typedef vec<4, u32, defaultp> u32vec4; typedef vec<1, u64, lowp> lowp_u64vec1; typedef vec<2, u64, lowp> lowp_u64vec2; typedef vec<3, u64, lowp> lowp_u64vec3; typedef vec<4, u64, lowp> lowp_u64vec4; typedef vec<1, u64, mediump> mediump_u64vec1; typedef vec<2, u64, mediump> mediump_u64vec2; typedef vec<3, u64, mediump> mediump_u64vec3; typedef vec<4, u64, mediump> mediump_u64vec4; typedef vec<1, u64, highp> highp_u64vec1; typedef vec<2, u64, highp> highp_u64vec2; typedef vec<3, u64, highp> highp_u64vec3; typedef vec<4, u64, highp> highp_u64vec4; typedef vec<1, u64, defaultp> u64vec1; typedef vec<2, u64, defaultp> u64vec2; typedef vec<3, u64, defaultp> u64vec3; typedef vec<4, u64, defaultp> u64vec4; // Vector float typedef vec<1, float, lowp> lowp_vec1; typedef vec<2, float, lowp> lowp_vec2; typedef vec<3, float, lowp> lowp_vec3; typedef vec<4, float, lowp> lowp_vec4; typedef vec<1, float, mediump> mediump_vec1; typedef vec<2, float, mediump> mediump_vec2; typedef vec<3, float, mediump> mediump_vec3; typedef vec<4, float, mediump> mediump_vec4; typedef vec<1, float, highp> highp_vec1; typedef vec<2, float, highp> highp_vec2; typedef vec<3, float, highp> highp_vec3; typedef vec<4, float, highp> highp_vec4; typedef vec<1, float, defaultp> vec1; typedef vec<2, float, defaultp> vec2; typedef vec<3, float, defaultp> vec3; typedef vec<4, float, defaultp> vec4; typedef vec<1, float, lowp> lowp_fvec1; typedef vec<2, float, lowp> lowp_fvec2; typedef vec<3, float, lowp> lowp_fvec3; typedef vec<4, float, lowp> lowp_fvec4; typedef vec<1, float, mediump> mediump_fvec1; typedef vec<2, float, mediump> mediump_fvec2; typedef vec<3, float, mediump> mediump_fvec3; typedef vec<4, float, mediump> mediump_fvec4; typedef vec<1, float, highp> highp_fvec1; typedef vec<2, float, highp> highp_fvec2; typedef vec<3, float, highp> highp_fvec3; typedef vec<4, float, highp> highp_fvec4; typedef vec<1, f32, defaultp> fvec1; typedef vec<2, f32, defaultp> fvec2; typedef vec<3, f32, defaultp> fvec3; typedef vec<4, f32, defaultp> fvec4; typedef vec<1, f32, lowp> lowp_f32vec1; typedef vec<2, f32, lowp> lowp_f32vec2; typedef vec<3, f32, lowp> lowp_f32vec3; typedef vec<4, f32, lowp> lowp_f32vec4; typedef vec<1, f32, mediump> mediump_f32vec1; typedef vec<2, f32, mediump> mediump_f32vec2; typedef vec<3, f32, mediump> mediump_f32vec3; typedef vec<4, f32, mediump> mediump_f32vec4; typedef vec<1, f32, highp> highp_f32vec1; typedef vec<2, f32, highp> highp_f32vec2; typedef vec<3, f32, highp> highp_f32vec3; typedef vec<4, f32, highp> highp_f32vec4; typedef vec<1, f32, defaultp> f32vec1; typedef vec<2, f32, defaultp> f32vec2; typedef vec<3, f32, defaultp> f32vec3; typedef vec<4, f32, defaultp> f32vec4; typedef vec<1, f64, lowp> lowp_dvec1; typedef vec<2, f64, lowp> lowp_dvec2; typedef vec<3, f64, lowp> lowp_dvec3; typedef vec<4, f64, lowp> lowp_dvec4; typedef vec<1, f64, mediump> mediump_dvec1; typedef vec<2, f64, mediump> mediump_dvec2; typedef vec<3, f64, mediump> mediump_dvec3; typedef vec<4, f64, mediump> mediump_dvec4; typedef vec<1, f64, highp> highp_dvec1; typedef vec<2, f64, highp> highp_dvec2; typedef vec<3, f64, highp> highp_dvec3; typedef vec<4, f64, highp> highp_dvec4; typedef vec<1, f64, defaultp> dvec1; typedef vec<2, f64, defaultp> dvec2; typedef vec<3, f64, defaultp> dvec3; typedef vec<4, f64, defaultp> dvec4; typedef vec<1, f64, lowp> lowp_f64vec1; typedef vec<2, f64, lowp> lowp_f64vec2; typedef vec<3, f64, lowp> lowp_f64vec3; typedef vec<4, f64, lowp> lowp_f64vec4; typedef vec<1, f64, mediump> mediump_f64vec1; typedef vec<2, f64, mediump> mediump_f64vec2; typedef vec<3, f64, mediump> mediump_f64vec3; typedef vec<4, f64, mediump> mediump_f64vec4; typedef vec<1, f64, highp> highp_f64vec1; typedef vec<2, f64, highp> highp_f64vec2; typedef vec<3, f64, highp> highp_f64vec3; typedef vec<4, f64, highp> highp_f64vec4; typedef vec<1, f64, defaultp> f64vec1; typedef vec<2, f64, defaultp> f64vec2; typedef vec<3, f64, defaultp> f64vec3; typedef vec<4, f64, defaultp> f64vec4; // Matrix NxN typedef mat<2, 2, f32, lowp> lowp_mat2; typedef mat<3, 3, f32, lowp> lowp_mat3; typedef mat<4, 4, f32, lowp> lowp_mat4; typedef mat<2, 2, f32, mediump> mediump_mat2; typedef mat<3, 3, f32, mediump> mediump_mat3; typedef mat<4, 4, f32, mediump> mediump_mat4; typedef mat<2, 2, f32, highp> highp_mat2; typedef mat<3, 3, f32, highp> highp_mat3; typedef mat<4, 4, f32, highp> highp_mat4; typedef mat<2, 2, f32, defaultp> mat2; typedef mat<3, 3, f32, defaultp> mat3; typedef mat<4, 4, f32, defaultp> mat4; typedef mat<2, 2, f32, lowp> lowp_fmat2; typedef mat<3, 3, f32, lowp> lowp_fmat3; typedef mat<4, 4, f32, lowp> lowp_fmat4; typedef mat<2, 2, f32, mediump> mediump_fmat2; typedef mat<3, 3, f32, mediump> mediump_fmat3; typedef mat<4, 4, f32, mediump> mediump_fmat4; typedef mat<2, 2, f32, highp> highp_fmat2; typedef mat<3, 3, f32, highp> highp_fmat3; typedef mat<4, 4, f32, highp> highp_fmat4; typedef mat<2, 2, f32, defaultp> fmat2; typedef mat<3, 3, f32, defaultp> fmat3; typedef mat<4, 4, f32, defaultp> fmat4; typedef mat<2, 2, f32, lowp> lowp_f32mat2; typedef mat<3, 3, f32, lowp> lowp_f32mat3; typedef mat<4, 4, f32, lowp> lowp_f32mat4; typedef mat<2, 2, f32, mediump> mediump_f32mat2; typedef mat<3, 3, f32, mediump> mediump_f32mat3; typedef mat<4, 4, f32, mediump> mediump_f32mat4; typedef mat<2, 2, f32, highp> highp_f32mat2; typedef mat<3, 3, f32, highp> highp_f32mat3; typedef mat<4, 4, f32, highp> highp_f32mat4; typedef mat<2, 2, f32, defaultp> f32mat2; typedef mat<3, 3, f32, defaultp> f32mat3; typedef mat<4, 4, f32, defaultp> f32mat4; typedef mat<2, 2, f64, lowp> lowp_dmat2; typedef mat<3, 3, f64, lowp> lowp_dmat3; typedef mat<4, 4, f64, lowp> lowp_dmat4; typedef mat<2, 2, f64, mediump> mediump_dmat2; typedef mat<3, 3, f64, mediump> mediump_dmat3; typedef mat<4, 4, f64, mediump> mediump_dmat4; typedef mat<2, 2, f64, highp> highp_dmat2; typedef mat<3, 3, f64, highp> highp_dmat3; typedef mat<4, 4, f64, highp> highp_dmat4; typedef mat<2, 2, f64, defaultp> dmat2; typedef mat<3, 3, f64, defaultp> dmat3; typedef mat<4, 4, f64, defaultp> dmat4; typedef mat<2, 2, f64, lowp> lowp_f64mat2; typedef mat<3, 3, f64, lowp> lowp_f64mat3; typedef mat<4, 4, f64, lowp> lowp_f64mat4; typedef mat<2, 2, f64, mediump> mediump_f64mat2; typedef mat<3, 3, f64, mediump> mediump_f64mat3; typedef mat<4, 4, f64, mediump> mediump_f64mat4; typedef mat<2, 2, f64, highp> highp_f64mat2; typedef mat<3, 3, f64, highp> highp_f64mat3; typedef mat<4, 4, f64, highp> highp_f64mat4; typedef mat<2, 2, f64, defaultp> f64mat2; typedef mat<3, 3, f64, defaultp> f64mat3; typedef mat<4, 4, f64, defaultp> f64mat4; // Matrix MxN typedef mat<2, 2, f32, lowp> lowp_mat2x2; typedef mat<2, 3, f32, lowp> lowp_mat2x3; typedef mat<2, 4, f32, lowp> lowp_mat2x4; typedef mat<3, 2, f32, lowp> lowp_mat3x2; typedef mat<3, 3, f32, lowp> lowp_mat3x3; typedef mat<3, 4, f32, lowp> lowp_mat3x4; typedef mat<4, 2, f32, lowp> lowp_mat4x2; typedef mat<4, 3, f32, lowp> lowp_mat4x3; typedef mat<4, 4, f32, lowp> lowp_mat4x4; typedef mat<2, 2, f32, mediump> mediump_mat2x2; typedef mat<2, 3, f32, mediump> mediump_mat2x3; typedef mat<2, 4, f32, mediump> mediump_mat2x4; typedef mat<3, 2, f32, mediump> mediump_mat3x2; typedef mat<3, 3, f32, mediump> mediump_mat3x3; typedef mat<3, 4, f32, mediump> mediump_mat3x4; typedef mat<4, 2, f32, mediump> mediump_mat4x2; typedef mat<4, 3, f32, mediump> mediump_mat4x3; typedef mat<4, 4, f32, mediump> mediump_mat4x4; typedef mat<2, 2, f32, highp> highp_mat2x2; typedef mat<2, 3, f32, highp> highp_mat2x3; typedef mat<2, 4, f32, highp> highp_mat2x4; typedef mat<3, 2, f32, highp> highp_mat3x2; typedef mat<3, 3, f32, highp> highp_mat3x3; typedef mat<3, 4, f32, highp> highp_mat3x4; typedef mat<4, 2, f32, highp> highp_mat4x2; typedef mat<4, 3, f32, highp> highp_mat4x3; typedef mat<4, 4, f32, highp> highp_mat4x4; typedef mat<2, 2, f32, defaultp> mat2x2; typedef mat<3, 2, f32, defaultp> mat3x2; typedef mat<4, 2, f32, defaultp> mat4x2; typedef mat<2, 3, f32, defaultp> mat2x3; typedef mat<3, 3, f32, defaultp> mat3x3; typedef mat<4, 3, f32, defaultp> mat4x3; typedef mat<2, 4, f32, defaultp> mat2x4; typedef mat<3, 4, f32, defaultp> mat3x4; typedef mat<4, 4, f32, defaultp> mat4x4; typedef mat<2, 2, f32, lowp> lowp_fmat2x2; typedef mat<2, 3, f32, lowp> lowp_fmat2x3; typedef mat<2, 4, f32, lowp> lowp_fmat2x4; typedef mat<3, 2, f32, lowp> lowp_fmat3x2; typedef mat<3, 3, f32, lowp> lowp_fmat3x3; typedef mat<3, 4, f32, lowp> lowp_fmat3x4; typedef mat<4, 2, f32, lowp> lowp_fmat4x2; typedef mat<4, 3, f32, lowp> lowp_fmat4x3; typedef mat<4, 4, f32, lowp> lowp_fmat4x4; typedef mat<2, 2, f32, mediump> mediump_fmat2x2; typedef mat<2, 3, f32, mediump> mediump_fmat2x3; typedef mat<2, 4, f32, mediump> mediump_fmat2x4; typedef mat<3, 2, f32, mediump> mediump_fmat3x2; typedef mat<3, 3, f32, mediump> mediump_fmat3x3; typedef mat<3, 4, f32, mediump> mediump_fmat3x4; typedef mat<4, 2, f32, mediump> mediump_fmat4x2; typedef mat<4, 3, f32, mediump> mediump_fmat4x3; typedef mat<4, 4, f32, mediump> mediump_fmat4x4; typedef mat<2, 2, f32, highp> highp_fmat2x2; typedef mat<2, 3, f32, highp> highp_fmat2x3; typedef mat<2, 4, f32, highp> highp_fmat2x4; typedef mat<3, 2, f32, highp> highp_fmat3x2; typedef mat<3, 3, f32, highp> highp_fmat3x3; typedef mat<3, 4, f32, highp> highp_fmat3x4; typedef mat<4, 2, f32, highp> highp_fmat4x2; typedef mat<4, 3, f32, highp> highp_fmat4x3; typedef mat<4, 4, f32, highp> highp_fmat4x4; typedef mat<2, 2, f32, defaultp> fmat2x2; typedef mat<3, 2, f32, defaultp> fmat3x2; typedef mat<4, 2, f32, defaultp> fmat4x2; typedef mat<2, 3, f32, defaultp> fmat2x3; typedef mat<3, 3, f32, defaultp> fmat3x3; typedef mat<4, 3, f32, defaultp> fmat4x3; typedef mat<2, 4, f32, defaultp> fmat2x4; typedef mat<3, 4, f32, defaultp> fmat3x4; typedef mat<4, 4, f32, defaultp> fmat4x4; typedef mat<2, 2, f32, lowp> lowp_f32mat2x2; typedef mat<2, 3, f32, lowp> lowp_f32mat2x3; typedef mat<2, 4, f32, lowp> lowp_f32mat2x4; typedef mat<3, 2, f32, lowp> lowp_f32mat3x2; typedef mat<3, 3, f32, lowp> lowp_f32mat3x3; typedef mat<3, 4, f32, lowp> lowp_f32mat3x4; typedef mat<4, 2, f32, lowp> lowp_f32mat4x2; typedef mat<4, 3, f32, lowp> lowp_f32mat4x3; typedef mat<4, 4, f32, lowp> lowp_f32mat4x4; typedef mat<2, 2, f32, mediump> mediump_f32mat2x2; typedef mat<2, 3, f32, mediump> mediump_f32mat2x3; typedef mat<2, 4, f32, mediump> mediump_f32mat2x4; typedef mat<3, 2, f32, mediump> mediump_f32mat3x2; typedef mat<3, 3, f32, mediump> mediump_f32mat3x3; typedef mat<3, 4, f32, mediump> mediump_f32mat3x4; typedef mat<4, 2, f32, mediump> mediump_f32mat4x2; typedef mat<4, 3, f32, mediump> mediump_f32mat4x3; typedef mat<4, 4, f32, mediump> mediump_f32mat4x4; typedef mat<2, 2, f32, highp> highp_f32mat2x2; typedef mat<2, 3, f32, highp> highp_f32mat2x3; typedef mat<2, 4, f32, highp> highp_f32mat2x4; typedef mat<3, 2, f32, highp> highp_f32mat3x2; typedef mat<3, 3, f32, highp> highp_f32mat3x3; typedef mat<3, 4, f32, highp> highp_f32mat3x4; typedef mat<4, 2, f32, highp> highp_f32mat4x2; typedef mat<4, 3, f32, highp> highp_f32mat4x3; typedef mat<4, 4, f32, highp> highp_f32mat4x4; typedef mat<2, 2, f32, defaultp> f32mat2x2; typedef mat<3, 2, f32, defaultp> f32mat3x2; typedef mat<4, 2, f32, defaultp> f32mat4x2; typedef mat<2, 3, f32, defaultp> f32mat2x3; typedef mat<3, 3, f32, defaultp> f32mat3x3; typedef mat<4, 3, f32, defaultp> f32mat4x3; typedef mat<2, 4, f32, defaultp> f32mat2x4; typedef mat<3, 4, f32, defaultp> f32mat3x4; typedef mat<4, 4, f32, defaultp> f32mat4x4; typedef mat<2, 2, double, lowp> lowp_dmat2x2; typedef mat<2, 3, double, lowp> lowp_dmat2x3; typedef mat<2, 4, double, lowp> lowp_dmat2x4; typedef mat<3, 2, double, lowp> lowp_dmat3x2; typedef mat<3, 3, double, lowp> lowp_dmat3x3; typedef mat<3, 4, double, lowp> lowp_dmat3x4; typedef mat<4, 2, double, lowp> lowp_dmat4x2; typedef mat<4, 3, double, lowp> lowp_dmat4x3; typedef mat<4, 4, double, lowp> lowp_dmat4x4; typedef mat<2, 2, double, mediump> mediump_dmat2x2; typedef mat<2, 3, double, mediump> mediump_dmat2x3; typedef mat<2, 4, double, mediump> mediump_dmat2x4; typedef mat<3, 2, double, mediump> mediump_dmat3x2; typedef mat<3, 3, double, mediump> mediump_dmat3x3; typedef mat<3, 4, double, mediump> mediump_dmat3x4; typedef mat<4, 2, double, mediump> mediump_dmat4x2; typedef mat<4, 3, double, mediump> mediump_dmat4x3; typedef mat<4, 4, double, mediump> mediump_dmat4x4; typedef mat<2, 2, double, highp> highp_dmat2x2; typedef mat<2, 3, double, highp> highp_dmat2x3; typedef mat<2, 4, double, highp> highp_dmat2x4; typedef mat<3, 2, double, highp> highp_dmat3x2; typedef mat<3, 3, double, highp> highp_dmat3x3; typedef mat<3, 4, double, highp> highp_dmat3x4; typedef mat<4, 2, double, highp> highp_dmat4x2; typedef mat<4, 3, double, highp> highp_dmat4x3; typedef mat<4, 4, double, highp> highp_dmat4x4; typedef mat<2, 2, double, defaultp> dmat2x2; typedef mat<3, 2, double, defaultp> dmat3x2; typedef mat<4, 2, double, defaultp> dmat4x2; typedef mat<2, 3, double, defaultp> dmat2x3; typedef mat<3, 3, double, defaultp> dmat3x3; typedef mat<4, 3, double, defaultp> dmat4x3; typedef mat<2, 4, double, defaultp> dmat2x4; typedef mat<3, 4, double, defaultp> dmat3x4; typedef mat<4, 4, double, defaultp> dmat4x4; typedef mat<2, 2, f64, lowp> lowp_f64mat2x2; typedef mat<2, 3, f64, lowp> lowp_f64mat2x3; typedef mat<2, 4, f64, lowp> lowp_f64mat2x4; typedef mat<3, 2, f64, lowp> lowp_f64mat3x2; typedef mat<3, 3, f64, lowp> lowp_f64mat3x3; typedef mat<3, 4, f64, lowp> lowp_f64mat3x4; typedef mat<4, 2, f64, lowp> lowp_f64mat4x2; typedef mat<4, 3, f64, lowp> lowp_f64mat4x3; typedef mat<4, 4, f64, lowp> lowp_f64mat4x4; typedef mat<2, 2, f64, mediump> mediump_f64mat2x2; typedef mat<2, 3, f64, mediump> mediump_f64mat2x3; typedef mat<2, 4, f64, mediump> mediump_f64mat2x4; typedef mat<3, 2, f64, mediump> mediump_f64mat3x2; typedef mat<3, 3, f64, mediump> mediump_f64mat3x3; typedef mat<3, 4, f64, mediump> mediump_f64mat3x4; typedef mat<4, 2, f64, mediump> mediump_f64mat4x2; typedef mat<4, 3, f64, mediump> mediump_f64mat4x3; typedef mat<4, 4, f64, mediump> mediump_f64mat4x4; typedef mat<2, 2, f64, highp> highp_f64mat2x2; typedef mat<2, 3, f64, highp> highp_f64mat2x3; typedef mat<2, 4, f64, highp> highp_f64mat2x4; typedef mat<3, 2, f64, highp> highp_f64mat3x2; typedef mat<3, 3, f64, highp> highp_f64mat3x3; typedef mat<3, 4, f64, highp> highp_f64mat3x4; typedef mat<4, 2, f64, highp> highp_f64mat4x2; typedef mat<4, 3, f64, highp> highp_f64mat4x3; typedef mat<4, 4, f64, highp> highp_f64mat4x4; typedef mat<2, 2, f64, defaultp> f64mat2x2; typedef mat<3, 2, f64, defaultp> f64mat3x2; typedef mat<4, 2, f64, defaultp> f64mat4x2; typedef mat<2, 3, f64, defaultp> f64mat2x3; typedef mat<3, 3, f64, defaultp> f64mat3x3; typedef mat<4, 3, f64, defaultp> f64mat4x3; typedef mat<2, 4, f64, defaultp> f64mat2x4; typedef mat<3, 4, f64, defaultp> f64mat3x4; typedef mat<4, 4, f64, defaultp> f64mat4x4; // Signed integer matrix MxN typedef mat<2, 2, int, lowp> lowp_imat2x2; typedef mat<2, 3, int, lowp> lowp_imat2x3; typedef mat<2, 4, int, lowp> lowp_imat2x4; typedef mat<3, 2, int, lowp> lowp_imat3x2; typedef mat<3, 3, int, lowp> lowp_imat3x3; typedef mat<3, 4, int, lowp> lowp_imat3x4; typedef mat<4, 2, int, lowp> lowp_imat4x2; typedef mat<4, 3, int, lowp> lowp_imat4x3; typedef mat<4, 4, int, lowp> lowp_imat4x4; typedef mat<2, 2, int, mediump> mediump_imat2x2; typedef mat<2, 3, int, mediump> mediump_imat2x3; typedef mat<2, 4, int, mediump> mediump_imat2x4; typedef mat<3, 2, int, mediump> mediump_imat3x2; typedef mat<3, 3, int, mediump> mediump_imat3x3; typedef mat<3, 4, int, mediump> mediump_imat3x4; typedef mat<4, 2, int, mediump> mediump_imat4x2; typedef mat<4, 3, int, mediump> mediump_imat4x3; typedef mat<4, 4, int, mediump> mediump_imat4x4; typedef mat<2, 2, int, highp> highp_imat2x2; typedef mat<2, 3, int, highp> highp_imat2x3; typedef mat<2, 4, int, highp> highp_imat2x4; typedef mat<3, 2, int, highp> highp_imat3x2; typedef mat<3, 3, int, highp> highp_imat3x3; typedef mat<3, 4, int, highp> highp_imat3x4; typedef mat<4, 2, int, highp> highp_imat4x2; typedef mat<4, 3, int, highp> highp_imat4x3; typedef mat<4, 4, int, highp> highp_imat4x4; typedef mat<2, 2, int, defaultp> imat2x2; typedef mat<3, 2, int, defaultp> imat3x2; typedef mat<4, 2, int, defaultp> imat4x2; typedef mat<2, 3, int, defaultp> imat2x3; typedef mat<3, 3, int, defaultp> imat3x3; typedef mat<4, 3, int, defaultp> imat4x3; typedef mat<2, 4, int, defaultp> imat2x4; typedef mat<3, 4, int, defaultp> imat3x4; typedef mat<4, 4, int, defaultp> imat4x4; typedef mat<2, 2, int8, lowp> lowp_i8mat2x2; typedef mat<2, 3, int8, lowp> lowp_i8mat2x3; typedef mat<2, 4, int8, lowp> lowp_i8mat2x4; typedef mat<3, 2, int8, lowp> lowp_i8mat3x2; typedef mat<3, 3, int8, lowp> lowp_i8mat3x3; typedef mat<3, 4, int8, lowp> lowp_i8mat3x4; typedef mat<4, 2, int8, lowp> lowp_i8mat4x2; typedef mat<4, 3, int8, lowp> lowp_i8mat4x3; typedef mat<4, 4, int8, lowp> lowp_i8mat4x4; typedef mat<2, 2, int8, mediump> mediump_i8mat2x2; typedef mat<2, 3, int8, mediump> mediump_i8mat2x3; typedef mat<2, 4, int8, mediump> mediump_i8mat2x4; typedef mat<3, 2, int8, mediump> mediump_i8mat3x2; typedef mat<3, 3, int8, mediump> mediump_i8mat3x3; typedef mat<3, 4, int8, mediump> mediump_i8mat3x4; typedef mat<4, 2, int8, mediump> mediump_i8mat4x2; typedef mat<4, 3, int8, mediump> mediump_i8mat4x3; typedef mat<4, 4, int8, mediump> mediump_i8mat4x4; typedef mat<2, 2, int8, highp> highp_i8mat2x2; typedef mat<2, 3, int8, highp> highp_i8mat2x3; typedef mat<2, 4, int8, highp> highp_i8mat2x4; typedef mat<3, 2, int8, highp> highp_i8mat3x2; typedef mat<3, 3, int8, highp> highp_i8mat3x3; typedef mat<3, 4, int8, highp> highp_i8mat3x4; typedef mat<4, 2, int8, highp> highp_i8mat4x2; typedef mat<4, 3, int8, highp> highp_i8mat4x3; typedef mat<4, 4, int8, highp> highp_i8mat4x4; typedef mat<2, 2, int8, defaultp> i8mat2x2; typedef mat<3, 2, int8, defaultp> i8mat3x2; typedef mat<4, 2, int8, defaultp> i8mat4x2; typedef mat<2, 3, int8, defaultp> i8mat2x3; typedef mat<3, 3, int8, defaultp> i8mat3x3; typedef mat<4, 3, int8, defaultp> i8mat4x3; typedef mat<2, 4, int8, defaultp> i8mat2x4; typedef mat<3, 4, int8, defaultp> i8mat3x4; typedef mat<4, 4, int8, defaultp> i8mat4x4; typedef mat<2, 2, int16, lowp> lowp_i16mat2x2; typedef mat<2, 3, int16, lowp> lowp_i16mat2x3; typedef mat<2, 4, int16, lowp> lowp_i16mat2x4; typedef mat<3, 2, int16, lowp> lowp_i16mat3x2; typedef mat<3, 3, int16, lowp> lowp_i16mat3x3; typedef mat<3, 4, int16, lowp> lowp_i16mat3x4; typedef mat<4, 2, int16, lowp> lowp_i16mat4x2; typedef mat<4, 3, int16, lowp> lowp_i16mat4x3; typedef mat<4, 4, int16, lowp> lowp_i16mat4x4; typedef mat<2, 2, int16, mediump> mediump_i16mat2x2; typedef mat<2, 3, int16, mediump> mediump_i16mat2x3; typedef mat<2, 4, int16, mediump> mediump_i16mat2x4; typedef mat<3, 2, int16, mediump> mediump_i16mat3x2; typedef mat<3, 3, int16, mediump> mediump_i16mat3x3; typedef mat<3, 4, int16, mediump> mediump_i16mat3x4; typedef mat<4, 2, int16, mediump> mediump_i16mat4x2; typedef mat<4, 3, int16, mediump> mediump_i16mat4x3; typedef mat<4, 4, int16, mediump> mediump_i16mat4x4; typedef mat<2, 2, int16, highp> highp_i16mat2x2; typedef mat<2, 3, int16, highp> highp_i16mat2x3; typedef mat<2, 4, int16, highp> highp_i16mat2x4; typedef mat<3, 2, int16, highp> highp_i16mat3x2; typedef mat<3, 3, int16, highp> highp_i16mat3x3; typedef mat<3, 4, int16, highp> highp_i16mat3x4; typedef mat<4, 2, int16, highp> highp_i16mat4x2; typedef mat<4, 3, int16, highp> highp_i16mat4x3; typedef mat<4, 4, int16, highp> highp_i16mat4x4; typedef mat<2, 2, int16, defaultp> i16mat2x2; typedef mat<3, 2, int16, defaultp> i16mat3x2; typedef mat<4, 2, int16, defaultp> i16mat4x2; typedef mat<2, 3, int16, defaultp> i16mat2x3; typedef mat<3, 3, int16, defaultp> i16mat3x3; typedef mat<4, 3, int16, defaultp> i16mat4x3; typedef mat<2, 4, int16, defaultp> i16mat2x4; typedef mat<3, 4, int16, defaultp> i16mat3x4; typedef mat<4, 4, int16, defaultp> i16mat4x4; typedef mat<2, 2, int32, lowp> lowp_i32mat2x2; typedef mat<2, 3, int32, lowp> lowp_i32mat2x3; typedef mat<2, 4, int32, lowp> lowp_i32mat2x4; typedef mat<3, 2, int32, lowp> lowp_i32mat3x2; typedef mat<3, 3, int32, lowp> lowp_i32mat3x3; typedef mat<3, 4, int32, lowp> lowp_i32mat3x4; typedef mat<4, 2, int32, lowp> lowp_i32mat4x2; typedef mat<4, 3, int32, lowp> lowp_i32mat4x3; typedef mat<4, 4, int32, lowp> lowp_i32mat4x4; typedef mat<2, 2, int32, mediump> mediump_i32mat2x2; typedef mat<2, 3, int32, mediump> mediump_i32mat2x3; typedef mat<2, 4, int32, mediump> mediump_i32mat2x4; typedef mat<3, 2, int32, mediump> mediump_i32mat3x2; typedef mat<3, 3, int32, mediump> mediump_i32mat3x3; typedef mat<3, 4, int32, mediump> mediump_i32mat3x4; typedef mat<4, 2, int32, mediump> mediump_i32mat4x2; typedef mat<4, 3, int32, mediump> mediump_i32mat4x3; typedef mat<4, 4, int32, mediump> mediump_i32mat4x4; typedef mat<2, 2, int32, highp> highp_i32mat2x2; typedef mat<2, 3, int32, highp> highp_i32mat2x3; typedef mat<2, 4, int32, highp> highp_i32mat2x4; typedef mat<3, 2, int32, highp> highp_i32mat3x2; typedef mat<3, 3, int32, highp> highp_i32mat3x3; typedef mat<3, 4, int32, highp> highp_i32mat3x4; typedef mat<4, 2, int32, highp> highp_i32mat4x2; typedef mat<4, 3, int32, highp> highp_i32mat4x3; typedef mat<4, 4, int32, highp> highp_i32mat4x4; typedef mat<2, 2, int32, defaultp> i32mat2x2; typedef mat<3, 2, int32, defaultp> i32mat3x2; typedef mat<4, 2, int32, defaultp> i32mat4x2; typedef mat<2, 3, int32, defaultp> i32mat2x3; typedef mat<3, 3, int32, defaultp> i32mat3x3; typedef mat<4, 3, int32, defaultp> i32mat4x3; typedef mat<2, 4, int32, defaultp> i32mat2x4; typedef mat<3, 4, int32, defaultp> i32mat3x4; typedef mat<4, 4, int32, defaultp> i32mat4x4; typedef mat<2, 2, int64, lowp> lowp_i64mat2x2; typedef mat<2, 3, int64, lowp> lowp_i64mat2x3; typedef mat<2, 4, int64, lowp> lowp_i64mat2x4; typedef mat<3, 2, int64, lowp> lowp_i64mat3x2; typedef mat<3, 3, int64, lowp> lowp_i64mat3x3; typedef mat<3, 4, int64, lowp> lowp_i64mat3x4; typedef mat<4, 2, int64, lowp> lowp_i64mat4x2; typedef mat<4, 3, int64, lowp> lowp_i64mat4x3; typedef mat<4, 4, int64, lowp> lowp_i64mat4x4; typedef mat<2, 2, int64, mediump> mediump_i64mat2x2; typedef mat<2, 3, int64, mediump> mediump_i64mat2x3; typedef mat<2, 4, int64, mediump> mediump_i64mat2x4; typedef mat<3, 2, int64, mediump> mediump_i64mat3x2; typedef mat<3, 3, int64, mediump> mediump_i64mat3x3; typedef mat<3, 4, int64, mediump> mediump_i64mat3x4; typedef mat<4, 2, int64, mediump> mediump_i64mat4x2; typedef mat<4, 3, int64, mediump> mediump_i64mat4x3; typedef mat<4, 4, int64, mediump> mediump_i64mat4x4; typedef mat<2, 2, int64, highp> highp_i64mat2x2; typedef mat<2, 3, int64, highp> highp_i64mat2x3; typedef mat<2, 4, int64, highp> highp_i64mat2x4; typedef mat<3, 2, int64, highp> highp_i64mat3x2; typedef mat<3, 3, int64, highp> highp_i64mat3x3; typedef mat<3, 4, int64, highp> highp_i64mat3x4; typedef mat<4, 2, int64, highp> highp_i64mat4x2; typedef mat<4, 3, int64, highp> highp_i64mat4x3; typedef mat<4, 4, int64, highp> highp_i64mat4x4; typedef mat<2, 2, int64, defaultp> i64mat2x2; typedef mat<3, 2, int64, defaultp> i64mat3x2; typedef mat<4, 2, int64, defaultp> i64mat4x2; typedef mat<2, 3, int64, defaultp> i64mat2x3; typedef mat<3, 3, int64, defaultp> i64mat3x3; typedef mat<4, 3, int64, defaultp> i64mat4x3; typedef mat<2, 4, int64, defaultp> i64mat2x4; typedef mat<3, 4, int64, defaultp> i64mat3x4; typedef mat<4, 4, int64, defaultp> i64mat4x4; // Unsigned integer matrix MxN typedef mat<2, 2, uint, lowp> lowp_umat2x2; typedef mat<2, 3, uint, lowp> lowp_umat2x3; typedef mat<2, 4, uint, lowp> lowp_umat2x4; typedef mat<3, 2, uint, lowp> lowp_umat3x2; typedef mat<3, 3, uint, lowp> lowp_umat3x3; typedef mat<3, 4, uint, lowp> lowp_umat3x4; typedef mat<4, 2, uint, lowp> lowp_umat4x2; typedef mat<4, 3, uint, lowp> lowp_umat4x3; typedef mat<4, 4, uint, lowp> lowp_umat4x4; typedef mat<2, 2, uint, mediump> mediump_umat2x2; typedef mat<2, 3, uint, mediump> mediump_umat2x3; typedef mat<2, 4, uint, mediump> mediump_umat2x4; typedef mat<3, 2, uint, mediump> mediump_umat3x2; typedef mat<3, 3, uint, mediump> mediump_umat3x3; typedef mat<3, 4, uint, mediump> mediump_umat3x4; typedef mat<4, 2, uint, mediump> mediump_umat4x2; typedef mat<4, 3, uint, mediump> mediump_umat4x3; typedef mat<4, 4, uint, mediump> mediump_umat4x4; typedef mat<2, 2, uint, highp> highp_umat2x2; typedef mat<2, 3, uint, highp> highp_umat2x3; typedef mat<2, 4, uint, highp> highp_umat2x4; typedef mat<3, 2, uint, highp> highp_umat3x2; typedef mat<3, 3, uint, highp> highp_umat3x3; typedef mat<3, 4, uint, highp> highp_umat3x4; typedef mat<4, 2, uint, highp> highp_umat4x2; typedef mat<4, 3, uint, highp> highp_umat4x3; typedef mat<4, 4, uint, highp> highp_umat4x4; typedef mat<2, 2, uint, defaultp> umat2x2; typedef mat<3, 2, uint, defaultp> umat3x2; typedef mat<4, 2, uint, defaultp> umat4x2; typedef mat<2, 3, uint, defaultp> umat2x3; typedef mat<3, 3, uint, defaultp> umat3x3; typedef mat<4, 3, uint, defaultp> umat4x3; typedef mat<2, 4, uint, defaultp> umat2x4; typedef mat<3, 4, uint, defaultp> umat3x4; typedef mat<4, 4, uint, defaultp> umat4x4; typedef mat<2, 2, uint8, lowp> lowp_u8mat2x2; typedef mat<2, 3, uint8, lowp> lowp_u8mat2x3; typedef mat<2, 4, uint8, lowp> lowp_u8mat2x4; typedef mat<3, 2, uint8, lowp> lowp_u8mat3x2; typedef mat<3, 3, uint8, lowp> lowp_u8mat3x3; typedef mat<3, 4, uint8, lowp> lowp_u8mat3x4; typedef mat<4, 2, uint8, lowp> lowp_u8mat4x2; typedef mat<4, 3, uint8, lowp> lowp_u8mat4x3; typedef mat<4, 4, uint8, lowp> lowp_u8mat4x4; typedef mat<2, 2, uint8, mediump> mediump_u8mat2x2; typedef mat<2, 3, uint8, mediump> mediump_u8mat2x3; typedef mat<2, 4, uint8, mediump> mediump_u8mat2x4; typedef mat<3, 2, uint8, mediump> mediump_u8mat3x2; typedef mat<3, 3, uint8, mediump> mediump_u8mat3x3; typedef mat<3, 4, uint8, mediump> mediump_u8mat3x4; typedef mat<4, 2, uint8, mediump> mediump_u8mat4x2; typedef mat<4, 3, uint8, mediump> mediump_u8mat4x3; typedef mat<4, 4, uint8, mediump> mediump_u8mat4x4; typedef mat<2, 2, uint8, highp> highp_u8mat2x2; typedef mat<2, 3, uint8, highp> highp_u8mat2x3; typedef mat<2, 4, uint8, highp> highp_u8mat2x4; typedef mat<3, 2, uint8, highp> highp_u8mat3x2; typedef mat<3, 3, uint8, highp> highp_u8mat3x3; typedef mat<3, 4, uint8, highp> highp_u8mat3x4; typedef mat<4, 2, uint8, highp> highp_u8mat4x2; typedef mat<4, 3, uint8, highp> highp_u8mat4x3; typedef mat<4, 4, uint8, highp> highp_u8mat4x4; typedef mat<2, 2, uint8, defaultp> u8mat2x2; typedef mat<3, 2, uint8, defaultp> u8mat3x2; typedef mat<4, 2, uint8, defaultp> u8mat4x2; typedef mat<2, 3, uint8, defaultp> u8mat2x3; typedef mat<3, 3, uint8, defaultp> u8mat3x3; typedef mat<4, 3, uint8, defaultp> u8mat4x3; typedef mat<2, 4, uint8, defaultp> u8mat2x4; typedef mat<3, 4, uint8, defaultp> u8mat3x4; typedef mat<4, 4, uint8, defaultp> u8mat4x4; typedef mat<2, 2, uint16, lowp> lowp_u16mat2x2; typedef mat<2, 3, uint16, lowp> lowp_u16mat2x3; typedef mat<2, 4, uint16, lowp> lowp_u16mat2x4; typedef mat<3, 2, uint16, lowp> lowp_u16mat3x2; typedef mat<3, 3, uint16, lowp> lowp_u16mat3x3; typedef mat<3, 4, uint16, lowp> lowp_u16mat3x4; typedef mat<4, 2, uint16, lowp> lowp_u16mat4x2; typedef mat<4, 3, uint16, lowp> lowp_u16mat4x3; typedef mat<4, 4, uint16, lowp> lowp_u16mat4x4; typedef mat<2, 2, uint16, mediump> mediump_u16mat2x2; typedef mat<2, 3, uint16, mediump> mediump_u16mat2x3; typedef mat<2, 4, uint16, mediump> mediump_u16mat2x4; typedef mat<3, 2, uint16, mediump> mediump_u16mat3x2; typedef mat<3, 3, uint16, mediump> mediump_u16mat3x3; typedef mat<3, 4, uint16, mediump> mediump_u16mat3x4; typedef mat<4, 2, uint16, mediump> mediump_u16mat4x2; typedef mat<4, 3, uint16, mediump> mediump_u16mat4x3; typedef mat<4, 4, uint16, mediump> mediump_u16mat4x4; typedef mat<2, 2, uint16, highp> highp_u16mat2x2; typedef mat<2, 3, uint16, highp> highp_u16mat2x3; typedef mat<2, 4, uint16, highp> highp_u16mat2x4; typedef mat<3, 2, uint16, highp> highp_u16mat3x2; typedef mat<3, 3, uint16, highp> highp_u16mat3x3; typedef mat<3, 4, uint16, highp> highp_u16mat3x4; typedef mat<4, 2, uint16, highp> highp_u16mat4x2; typedef mat<4, 3, uint16, highp> highp_u16mat4x3; typedef mat<4, 4, uint16, highp> highp_u16mat4x4; typedef mat<2, 2, uint16, defaultp> u16mat2x2; typedef mat<3, 2, uint16, defaultp> u16mat3x2; typedef mat<4, 2, uint16, defaultp> u16mat4x2; typedef mat<2, 3, uint16, defaultp> u16mat2x3; typedef mat<3, 3, uint16, defaultp> u16mat3x3; typedef mat<4, 3, uint16, defaultp> u16mat4x3; typedef mat<2, 4, uint16, defaultp> u16mat2x4; typedef mat<3, 4, uint16, defaultp> u16mat3x4; typedef mat<4, 4, uint16, defaultp> u16mat4x4; typedef mat<2, 2, uint32, lowp> lowp_u32mat2x2; typedef mat<2, 3, uint32, lowp> lowp_u32mat2x3; typedef mat<2, 4, uint32, lowp> lowp_u32mat2x4; typedef mat<3, 2, uint32, lowp> lowp_u32mat3x2; typedef mat<3, 3, uint32, lowp> lowp_u32mat3x3; typedef mat<3, 4, uint32, lowp> lowp_u32mat3x4; typedef mat<4, 2, uint32, lowp> lowp_u32mat4x2; typedef mat<4, 3, uint32, lowp> lowp_u32mat4x3; typedef mat<4, 4, uint32, lowp> lowp_u32mat4x4; typedef mat<2, 2, uint32, mediump> mediump_u32mat2x2; typedef mat<2, 3, uint32, mediump> mediump_u32mat2x3; typedef mat<2, 4, uint32, mediump> mediump_u32mat2x4; typedef mat<3, 2, uint32, mediump> mediump_u32mat3x2; typedef mat<3, 3, uint32, mediump> mediump_u32mat3x3; typedef mat<3, 4, uint32, mediump> mediump_u32mat3x4; typedef mat<4, 2, uint32, mediump> mediump_u32mat4x2; typedef mat<4, 3, uint32, mediump> mediump_u32mat4x3; typedef mat<4, 4, uint32, mediump> mediump_u32mat4x4; typedef mat<2, 2, uint32, highp> highp_u32mat2x2; typedef mat<2, 3, uint32, highp> highp_u32mat2x3; typedef mat<2, 4, uint32, highp> highp_u32mat2x4; typedef mat<3, 2, uint32, highp> highp_u32mat3x2; typedef mat<3, 3, uint32, highp> highp_u32mat3x3; typedef mat<3, 4, uint32, highp> highp_u32mat3x4; typedef mat<4, 2, uint32, highp> highp_u32mat4x2; typedef mat<4, 3, uint32, highp> highp_u32mat4x3; typedef mat<4, 4, uint32, highp> highp_u32mat4x4; typedef mat<2, 2, uint32, defaultp> u32mat2x2; typedef mat<3, 2, uint32, defaultp> u32mat3x2; typedef mat<4, 2, uint32, defaultp> u32mat4x2; typedef mat<2, 3, uint32, defaultp> u32mat2x3; typedef mat<3, 3, uint32, defaultp> u32mat3x3; typedef mat<4, 3, uint32, defaultp> u32mat4x3; typedef mat<2, 4, uint32, defaultp> u32mat2x4; typedef mat<3, 4, uint32, defaultp> u32mat3x4; typedef mat<4, 4, uint32, defaultp> u32mat4x4; typedef mat<2, 2, uint64, lowp> lowp_u64mat2x2; typedef mat<2, 3, uint64, lowp> lowp_u64mat2x3; typedef mat<2, 4, uint64, lowp> lowp_u64mat2x4; typedef mat<3, 2, uint64, lowp> lowp_u64mat3x2; typedef mat<3, 3, uint64, lowp> lowp_u64mat3x3; typedef mat<3, 4, uint64, lowp> lowp_u64mat3x4; typedef mat<4, 2, uint64, lowp> lowp_u64mat4x2; typedef mat<4, 3, uint64, lowp> lowp_u64mat4x3; typedef mat<4, 4, uint64, lowp> lowp_u64mat4x4; typedef mat<2, 2, uint64, mediump> mediump_u64mat2x2; typedef mat<2, 3, uint64, mediump> mediump_u64mat2x3; typedef mat<2, 4, uint64, mediump> mediump_u64mat2x4; typedef mat<3, 2, uint64, mediump> mediump_u64mat3x2; typedef mat<3, 3, uint64, mediump> mediump_u64mat3x3; typedef mat<3, 4, uint64, mediump> mediump_u64mat3x4; typedef mat<4, 2, uint64, mediump> mediump_u64mat4x2; typedef mat<4, 3, uint64, mediump> mediump_u64mat4x3; typedef mat<4, 4, uint64, mediump> mediump_u64mat4x4; typedef mat<2, 2, uint64, highp> highp_u64mat2x2; typedef mat<2, 3, uint64, highp> highp_u64mat2x3; typedef mat<2, 4, uint64, highp> highp_u64mat2x4; typedef mat<3, 2, uint64, highp> highp_u64mat3x2; typedef mat<3, 3, uint64, highp> highp_u64mat3x3; typedef mat<3, 4, uint64, highp> highp_u64mat3x4; typedef mat<4, 2, uint64, highp> highp_u64mat4x2; typedef mat<4, 3, uint64, highp> highp_u64mat4x3; typedef mat<4, 4, uint64, highp> highp_u64mat4x4; typedef mat<2, 2, uint64, defaultp> u64mat2x2; typedef mat<3, 2, uint64, defaultp> u64mat3x2; typedef mat<4, 2, uint64, defaultp> u64mat4x2; typedef mat<2, 3, uint64, defaultp> u64mat2x3; typedef mat<3, 3, uint64, defaultp> u64mat3x3; typedef mat<4, 3, uint64, defaultp> u64mat4x3; typedef mat<2, 4, uint64, defaultp> u64mat2x4; typedef mat<3, 4, uint64, defaultp> u64mat3x4; typedef mat<4, 4, uint64, defaultp> u64mat4x4; // Quaternion typedef qua lowp_quat; typedef qua mediump_quat; typedef qua highp_quat; typedef qua quat; typedef qua lowp_fquat; typedef qua mediump_fquat; typedef qua highp_fquat; typedef qua fquat; typedef qua lowp_f32quat; typedef qua mediump_f32quat; typedef qua highp_f32quat; typedef qua f32quat; typedef qua lowp_dquat; typedef qua mediump_dquat; typedef qua highp_dquat; typedef qua dquat; typedef qua lowp_f64quat; typedef qua mediump_f64quat; typedef qua highp_f64quat; typedef qua f64quat; }//namespace glm ================================================ FILE: android/src/glm/geometric.hpp ================================================ /// @ref core /// @file glm/geometric.hpp /// /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions /// /// @defgroup core_func_geometric Geometric functions /// @ingroup core /// /// These operate on vectors as vectors, not component-wise. /// /// Include to use these core features. #pragma once #include "detail/type_vec3.hpp" namespace glm { /// @addtogroup core_func_geometric /// @{ /// Returns the length of x, i.e., sqrt(x * x). /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL length man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL T length(vec const& x); /// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1). /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL distance man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL T distance(vec const& p0, vec const& p1); /// Returns the dot product of x and y, i.e., result = x * y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL dot man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL T dot(vec const& x, vec const& y); /// Returns the cross product of x and y. /// /// @tparam T Floating-point scalar types. /// /// @see GLSL cross man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y); /// Returns a vector in the same direction as x but with length of 1. /// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL normalize man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec normalize(vec const& x); /// If dot(Nref, I) < 0.0, return N, otherwise, return -N. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL faceforward man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec faceforward( vec const& N, vec const& I, vec const& Nref); /// For the incident vector I and surface orientation N, /// returns the reflection direction : result = I - 2.0 * dot(N, I) * N. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL reflect man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec reflect( vec const& I, vec const& N); /// For the incident vector I and surface normal N, /// and the ratio of indices of refraction eta, /// return the refraction vector. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL refract man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec refract( vec const& I, vec const& N, T eta); /// @} }//namespace glm #include "detail/func_geometric.inl" ================================================ FILE: android/src/glm/glm.hpp ================================================ /// @ref core /// @file glm/glm.hpp /// /// @defgroup core Core features /// /// @brief Features that implement in C++ the GLSL specification as closely as possible. /// /// The GLM core consists of C++ types that mirror GLSL types and /// C++ functions that mirror the GLSL functions. /// /// The best documentation for GLM Core is the current GLSL specification, /// version 4.2 /// (pdf file). /// /// GLM core functionalities require to be included to be used. /// /// /// @defgroup core_vector Vector types /// /// Vector types of two to four components with an exhaustive set of operators. /// /// @ingroup core /// /// /// @defgroup core_vector_precision Vector types with precision qualifiers /// /// @brief Vector types with precision qualifiers which may result in various precision in term of ULPs /// /// GLSL allows defining qualifiers for particular variables. /// With OpenGL's GLSL, these qualifiers have no effect; they are there for compatibility, /// with OpenGL ES's GLSL, these qualifiers do have an effect. /// /// C++ has no language equivalent to qualifier qualifiers. So GLM provides the next-best thing: /// a number of typedefs that use a particular qualifier. /// /// None of these types make any guarantees about the actual qualifier used. /// /// @ingroup core /// /// /// @defgroup core_matrix Matrix types /// /// Matrix types of with C columns and R rows where C and R are values between 2 to 4 included. /// These types have exhaustive sets of operators. /// /// @ingroup core /// /// /// @defgroup core_matrix_precision Matrix types with precision qualifiers /// /// @brief Matrix types with precision qualifiers which may result in various precision in term of ULPs /// /// GLSL allows defining qualifiers for particular variables. /// With OpenGL's GLSL, these qualifiers have no effect; they are there for compatibility, /// with OpenGL ES's GLSL, these qualifiers do have an effect. /// /// C++ has no language equivalent to qualifier qualifiers. So GLM provides the next-best thing: /// a number of typedefs that use a particular qualifier. /// /// None of these types make any guarantees about the actual qualifier used. /// /// @ingroup core /// /// /// @defgroup ext Stable extensions /// /// @brief Additional features not specified by GLSL specification. /// /// EXT extensions are fully tested and documented. /// /// Even if it's highly unrecommended, it's possible to include all the extensions at once by /// including . Otherwise, each extension needs to be included a specific file. /// /// /// @defgroup gtc Recommended extensions /// /// @brief Additional features not specified by GLSL specification. /// /// GTC extensions aim to be stable with tests and documentation. /// /// Even if it's highly unrecommended, it's possible to include all the extensions at once by /// including . Otherwise, each extension needs to be included a specific file. /// /// /// @defgroup gtx Experimental extensions /// /// @brief Experimental features not specified by GLSL specification. /// /// Experimental extensions are useful functions and types, but the development of /// their API and functionality is not necessarily stable. They can change /// substantially between versions. Backwards compatibility is not much of an issue /// for them. /// /// Even if it's highly unrecommended, it's possible to include all the extensions /// at once by including . Otherwise, each extension needs to be /// included a specific file. /// /// @mainpage OpenGL Mathematics (GLM) /// - Website: glm.g-truc.net /// - GLM API documentation /// - GLM Manual #include "detail/_fixes.hpp" #include "detail/setup.hpp" #pragma once #include #include #include #include #include #include "fwd.hpp" #include "vec2.hpp" #include "vec3.hpp" #include "vec4.hpp" #include "mat2x2.hpp" #include "mat2x3.hpp" #include "mat2x4.hpp" #include "mat3x2.hpp" #include "mat3x3.hpp" #include "mat3x4.hpp" #include "mat4x2.hpp" #include "mat4x3.hpp" #include "mat4x4.hpp" #include "trigonometric.hpp" #include "exponential.hpp" #include "common.hpp" #include "packing.hpp" #include "geometric.hpp" #include "matrix.hpp" #include "vector_relational.hpp" #include "integer.hpp" ================================================ FILE: android/src/glm/gtc/bitfield.hpp ================================================ /// @ref gtc_bitfield /// @file glm/gtc/bitfield.hpp /// /// @see core (dependence) /// @see gtc_bitfield (dependence) /// /// @defgroup gtc_bitfield GLM_GTC_bitfield /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Allow to perform bit operations on integer values #include "../detail/setup.hpp" #pragma once // Dependencies #include "../ext/scalar_int_sized.hpp" #include "../ext/scalar_uint_sized.hpp" #include "../detail/qualifier.hpp" #include "../detail/_vectorize.hpp" #include "type_precision.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_bitfield extension included") #endif namespace glm { /// @addtogroup gtc_bitfield /// @{ /// Build a mask of 'count' bits /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType mask(genIUType Bits); /// Build a mask of 'count' bits /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec mask(vec const& v); /// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side. /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType bitfieldRotateRight(genIUType In, int Shift); /// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec bitfieldRotateRight(vec const& In, int Shift); /// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side. /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType bitfieldRotateLeft(genIUType In, int Shift); /// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec bitfieldRotateLeft(vec const& In, int Shift); /// Set to 1 a range of bits. /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount); /// Set to 1 a range of bits. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec bitfieldFillOne(vec const& Value, int FirstBit, int BitCount); /// Set to 0 a range of bits. /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount); /// Set to 0 a range of bits. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec bitfieldFillZero(vec const& Value, int FirstBit, int BitCount); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int16 bitfieldInterleave(int8 x, int8 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint16 bitfieldInterleave(uint8 x, uint8 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of v.x followed by the first bit of v.y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint16 bitfieldInterleave(u8vec2 const& v); /// Deinterleaves the bits of x. /// /// @see gtc_bitfield GLM_FUNC_DECL glm::u8vec2 bitfieldDeinterleave(glm::uint16 x); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int32 bitfieldInterleave(int16 x, int16 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint32 bitfieldInterleave(uint16 x, uint16 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of v.x followed by the first bit of v.y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint32 bitfieldInterleave(u16vec2 const& v); /// Deinterleaves the bits of x. /// /// @see gtc_bitfield GLM_FUNC_DECL glm::u16vec2 bitfieldDeinterleave(glm::uint32 x); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of v.x followed by the first bit of v.y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint64 bitfieldInterleave(u32vec2 const& v); /// Deinterleaves the bits of x. /// /// @see gtc_bitfield GLM_FUNC_DECL glm::u32vec2 bitfieldDeinterleave(glm::uint64 x); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y, int32 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z); /// Interleaves the bits of x, y, z and w. /// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w); /// Interleaves the bits of x, y, z and w. /// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w); /// Interleaves the bits of x, y, z and w. /// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w); /// Interleaves the bits of x, y, z and w. /// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w); /// @} } //namespace glm #include "bitfield.inl" ================================================ FILE: android/src/glm/gtc/bitfield.inl ================================================ /// @ref gtc_bitfield #include "../simd/integer.h" namespace glm{ namespace detail { template GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y); template GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z); template GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w); template<> GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y) { glm::uint16 REG1(x); glm::uint16 REG2(y); REG1 = ((REG1 << 4) | REG1) & static_cast(0x0F0F); REG2 = ((REG2 << 4) | REG2) & static_cast(0x0F0F); REG1 = ((REG1 << 2) | REG1) & static_cast(0x3333); REG2 = ((REG2 << 2) | REG2) & static_cast(0x3333); REG1 = ((REG1 << 1) | REG1) & static_cast(0x5555); REG2 = ((REG2 << 1) | REG2) & static_cast(0x5555); return REG1 | static_cast(REG2 << 1); } template<> GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y) { glm::uint32 REG1(x); glm::uint32 REG2(y); REG1 = ((REG1 << 8) | REG1) & static_cast(0x00FF00FF); REG2 = ((REG2 << 8) | REG2) & static_cast(0x00FF00FF); REG1 = ((REG1 << 4) | REG1) & static_cast(0x0F0F0F0F); REG2 = ((REG2 << 4) | REG2) & static_cast(0x0F0F0F0F); REG1 = ((REG1 << 2) | REG1) & static_cast(0x33333333); REG2 = ((REG2 << 2) | REG2) & static_cast(0x33333333); REG1 = ((REG1 << 1) | REG1) & static_cast(0x55555555); REG2 = ((REG2 << 1) | REG2) & static_cast(0x55555555); return REG1 | (REG2 << 1); } template<> GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y) { glm::uint64 REG1(x); glm::uint64 REG2(y); REG1 = ((REG1 << 16) | REG1) & static_cast(0x0000FFFF0000FFFFull); REG2 = ((REG2 << 16) | REG2) & static_cast(0x0000FFFF0000FFFFull); REG1 = ((REG1 << 8) | REG1) & static_cast(0x00FF00FF00FF00FFull); REG2 = ((REG2 << 8) | REG2) & static_cast(0x00FF00FF00FF00FFull); REG1 = ((REG1 << 4) | REG1) & static_cast(0x0F0F0F0F0F0F0F0Full); REG2 = ((REG2 << 4) | REG2) & static_cast(0x0F0F0F0F0F0F0F0Full); REG1 = ((REG1 << 2) | REG1) & static_cast(0x3333333333333333ull); REG2 = ((REG2 << 2) | REG2) & static_cast(0x3333333333333333ull); REG1 = ((REG1 << 1) | REG1) & static_cast(0x5555555555555555ull); REG2 = ((REG2 << 1) | REG2) & static_cast(0x5555555555555555ull); return REG1 | (REG2 << 1); } template<> GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z) { glm::uint32 REG1(x); glm::uint32 REG2(y); glm::uint32 REG3(z); REG1 = ((REG1 << 16) | REG1) & static_cast(0xFF0000FFu); REG2 = ((REG2 << 16) | REG2) & static_cast(0xFF0000FFu); REG3 = ((REG3 << 16) | REG3) & static_cast(0xFF0000FFu); REG1 = ((REG1 << 8) | REG1) & static_cast(0x0F00F00Fu); REG2 = ((REG2 << 8) | REG2) & static_cast(0x0F00F00Fu); REG3 = ((REG3 << 8) | REG3) & static_cast(0x0F00F00Fu); REG1 = ((REG1 << 4) | REG1) & static_cast(0xC30C30C3u); REG2 = ((REG2 << 4) | REG2) & static_cast(0xC30C30C3u); REG3 = ((REG3 << 4) | REG3) & static_cast(0xC30C30C3u); REG1 = ((REG1 << 2) | REG1) & static_cast(0x49249249u); REG2 = ((REG2 << 2) | REG2) & static_cast(0x49249249u); REG3 = ((REG3 << 2) | REG3) & static_cast(0x49249249u); return REG1 | (REG2 << 1) | (REG3 << 2); } template<> GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z) { glm::uint64 REG1(x); glm::uint64 REG2(y); glm::uint64 REG3(z); REG1 = ((REG1 << 32) | REG1) & static_cast(0xFFFF00000000FFFFull); REG2 = ((REG2 << 32) | REG2) & static_cast(0xFFFF00000000FFFFull); REG3 = ((REG3 << 32) | REG3) & static_cast(0xFFFF00000000FFFFull); REG1 = ((REG1 << 16) | REG1) & static_cast(0x00FF0000FF0000FFull); REG2 = ((REG2 << 16) | REG2) & static_cast(0x00FF0000FF0000FFull); REG3 = ((REG3 << 16) | REG3) & static_cast(0x00FF0000FF0000FFull); REG1 = ((REG1 << 8) | REG1) & static_cast(0xF00F00F00F00F00Full); REG2 = ((REG2 << 8) | REG2) & static_cast(0xF00F00F00F00F00Full); REG3 = ((REG3 << 8) | REG3) & static_cast(0xF00F00F00F00F00Full); REG1 = ((REG1 << 4) | REG1) & static_cast(0x30C30C30C30C30C3ull); REG2 = ((REG2 << 4) | REG2) & static_cast(0x30C30C30C30C30C3ull); REG3 = ((REG3 << 4) | REG3) & static_cast(0x30C30C30C30C30C3ull); REG1 = ((REG1 << 2) | REG1) & static_cast(0x9249249249249249ull); REG2 = ((REG2 << 2) | REG2) & static_cast(0x9249249249249249ull); REG3 = ((REG3 << 2) | REG3) & static_cast(0x9249249249249249ull); return REG1 | (REG2 << 1) | (REG3 << 2); } template<> GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z) { glm::uint64 REG1(x); glm::uint64 REG2(y); glm::uint64 REG3(z); REG1 = ((REG1 << 32) | REG1) & static_cast(0xFFFF00000000FFFFull); REG2 = ((REG2 << 32) | REG2) & static_cast(0xFFFF00000000FFFFull); REG3 = ((REG3 << 32) | REG3) & static_cast(0xFFFF00000000FFFFull); REG1 = ((REG1 << 16) | REG1) & static_cast(0x00FF0000FF0000FFull); REG2 = ((REG2 << 16) | REG2) & static_cast(0x00FF0000FF0000FFull); REG3 = ((REG3 << 16) | REG3) & static_cast(0x00FF0000FF0000FFull); REG1 = ((REG1 << 8) | REG1) & static_cast(0xF00F00F00F00F00Full); REG2 = ((REG2 << 8) | REG2) & static_cast(0xF00F00F00F00F00Full); REG3 = ((REG3 << 8) | REG3) & static_cast(0xF00F00F00F00F00Full); REG1 = ((REG1 << 4) | REG1) & static_cast(0x30C30C30C30C30C3ull); REG2 = ((REG2 << 4) | REG2) & static_cast(0x30C30C30C30C30C3ull); REG3 = ((REG3 << 4) | REG3) & static_cast(0x30C30C30C30C30C3ull); REG1 = ((REG1 << 2) | REG1) & static_cast(0x9249249249249249ull); REG2 = ((REG2 << 2) | REG2) & static_cast(0x9249249249249249ull); REG3 = ((REG3 << 2) | REG3) & static_cast(0x9249249249249249ull); return REG1 | (REG2 << 1) | (REG3 << 2); } template<> GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w) { glm::uint32 REG1(x); glm::uint32 REG2(y); glm::uint32 REG3(z); glm::uint32 REG4(w); REG1 = ((REG1 << 12) | REG1) & static_cast(0x000F000Fu); REG2 = ((REG2 << 12) | REG2) & static_cast(0x000F000Fu); REG3 = ((REG3 << 12) | REG3) & static_cast(0x000F000Fu); REG4 = ((REG4 << 12) | REG4) & static_cast(0x000F000Fu); REG1 = ((REG1 << 6) | REG1) & static_cast(0x03030303u); REG2 = ((REG2 << 6) | REG2) & static_cast(0x03030303u); REG3 = ((REG3 << 6) | REG3) & static_cast(0x03030303u); REG4 = ((REG4 << 6) | REG4) & static_cast(0x03030303u); REG1 = ((REG1 << 3) | REG1) & static_cast(0x11111111u); REG2 = ((REG2 << 3) | REG2) & static_cast(0x11111111u); REG3 = ((REG3 << 3) | REG3) & static_cast(0x11111111u); REG4 = ((REG4 << 3) | REG4) & static_cast(0x11111111u); return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3); } template<> GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w) { glm::uint64 REG1(x); glm::uint64 REG2(y); glm::uint64 REG3(z); glm::uint64 REG4(w); REG1 = ((REG1 << 24) | REG1) & static_cast(0x000000FF000000FFull); REG2 = ((REG2 << 24) | REG2) & static_cast(0x000000FF000000FFull); REG3 = ((REG3 << 24) | REG3) & static_cast(0x000000FF000000FFull); REG4 = ((REG4 << 24) | REG4) & static_cast(0x000000FF000000FFull); REG1 = ((REG1 << 12) | REG1) & static_cast(0x000F000F000F000Full); REG2 = ((REG2 << 12) | REG2) & static_cast(0x000F000F000F000Full); REG3 = ((REG3 << 12) | REG3) & static_cast(0x000F000F000F000Full); REG4 = ((REG4 << 12) | REG4) & static_cast(0x000F000F000F000Full); REG1 = ((REG1 << 6) | REG1) & static_cast(0x0303030303030303ull); REG2 = ((REG2 << 6) | REG2) & static_cast(0x0303030303030303ull); REG3 = ((REG3 << 6) | REG3) & static_cast(0x0303030303030303ull); REG4 = ((REG4 << 6) | REG4) & static_cast(0x0303030303030303ull); REG1 = ((REG1 << 3) | REG1) & static_cast(0x1111111111111111ull); REG2 = ((REG2 << 3) | REG2) & static_cast(0x1111111111111111ull); REG3 = ((REG3 << 3) | REG3) & static_cast(0x1111111111111111ull); REG4 = ((REG4 << 3) | REG4) & static_cast(0x1111111111111111ull); return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3); } }//namespace detail template GLM_FUNC_QUALIFIER genIUType mask(genIUType Bits) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'mask' accepts only integer values"); return Bits >= sizeof(genIUType) * 8 ? ~static_cast(0) : (static_cast(1) << Bits) - static_cast(1); } template GLM_FUNC_QUALIFIER vec mask(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'mask' accepts only integer values"); return detail::functor1::call(mask, v); } template GLM_FUNC_QUALIFIER genIType bitfieldRotateRight(genIType In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateRight' accepts only integer values"); int const BitSize = static_cast(sizeof(genIType) * 8); return (In << static_cast(Shift)) | (In >> static_cast(BitSize - Shift)); } template GLM_FUNC_QUALIFIER vec bitfieldRotateRight(vec const& In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateRight' accepts only integer values"); int const BitSize = static_cast(sizeof(T) * 8); return (In << static_cast(Shift)) | (In >> static_cast(BitSize - Shift)); } template GLM_FUNC_QUALIFIER genIType bitfieldRotateLeft(genIType In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateLeft' accepts only integer values"); int const BitSize = static_cast(sizeof(genIType) * 8); return (In >> static_cast(Shift)) | (In << static_cast(BitSize - Shift)); } template GLM_FUNC_QUALIFIER vec bitfieldRotateLeft(vec const& In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateLeft' accepts only integer values"); int const BitSize = static_cast(sizeof(T) * 8); return (In >> static_cast(Shift)) | (In << static_cast(BitSize - Shift)); } template GLM_FUNC_QUALIFIER genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount) { return Value | static_cast(mask(BitCount) << FirstBit); } template GLM_FUNC_QUALIFIER vec bitfieldFillOne(vec const& Value, int FirstBit, int BitCount) { return Value | static_cast(mask(BitCount) << FirstBit); } template GLM_FUNC_QUALIFIER genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount) { return Value & static_cast(~(mask(BitCount) << FirstBit)); } template GLM_FUNC_QUALIFIER vec bitfieldFillZero(vec const& Value, int FirstBit, int BitCount) { return Value & static_cast(~(mask(BitCount) << FirstBit)); } GLM_FUNC_QUALIFIER int16 bitfieldInterleave(int8 x, int8 y) { union sign8 { int8 i; uint8 u; } sign_x, sign_y; union sign16 { int16 i; uint16 u; } result; sign_x.i = x; sign_y.i = y; result.u = bitfieldInterleave(sign_x.u, sign_y.u); return result.i; } GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(uint8 x, uint8 y) { return detail::bitfieldInterleave(x, y); } GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(u8vec2 const& v) { return detail::bitfieldInterleave(v.x, v.y); } GLM_FUNC_QUALIFIER u8vec2 bitfieldDeinterleave(glm::uint16 x) { uint16 REG1(x); uint16 REG2(x >>= 1); REG1 = REG1 & static_cast(0x5555); REG2 = REG2 & static_cast(0x5555); REG1 = ((REG1 >> 1) | REG1) & static_cast(0x3333); REG2 = ((REG2 >> 1) | REG2) & static_cast(0x3333); REG1 = ((REG1 >> 2) | REG1) & static_cast(0x0F0F); REG2 = ((REG2 >> 2) | REG2) & static_cast(0x0F0F); REG1 = ((REG1 >> 4) | REG1) & static_cast(0x00FF); REG2 = ((REG2 >> 4) | REG2) & static_cast(0x00FF); REG1 = ((REG1 >> 8) | REG1) & static_cast(0xFFFF); REG2 = ((REG2 >> 8) | REG2) & static_cast(0xFFFF); return glm::u8vec2(REG1, REG2); } GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int16 x, int16 y) { union sign16 { int16 i; uint16 u; } sign_x, sign_y; union sign32 { int32 i; uint32 u; } result; sign_x.i = x; sign_y.i = y; result.u = bitfieldInterleave(sign_x.u, sign_y.u); return result.i; } GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint16 x, uint16 y) { return detail::bitfieldInterleave(x, y); } GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(u16vec2 const& v) { return detail::bitfieldInterleave(v.x, v.y); } GLM_FUNC_QUALIFIER glm::u16vec2 bitfieldDeinterleave(glm::uint32 x) { glm::uint32 REG1(x); glm::uint32 REG2(x >>= 1); REG1 = REG1 & static_cast(0x55555555); REG2 = REG2 & static_cast(0x55555555); REG1 = ((REG1 >> 1) | REG1) & static_cast(0x33333333); REG2 = ((REG2 >> 1) | REG2) & static_cast(0x33333333); REG1 = ((REG1 >> 2) | REG1) & static_cast(0x0F0F0F0F); REG2 = ((REG2 >> 2) | REG2) & static_cast(0x0F0F0F0F); REG1 = ((REG1 >> 4) | REG1) & static_cast(0x00FF00FF); REG2 = ((REG2 >> 4) | REG2) & static_cast(0x00FF00FF); REG1 = ((REG1 >> 8) | REG1) & static_cast(0x0000FFFF); REG2 = ((REG2 >> 8) | REG2) & static_cast(0x0000FFFF); return glm::u16vec2(REG1, REG2); } GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y) { union sign32 { int32 i; uint32 u; } sign_x, sign_y; union sign64 { int64 i; uint64 u; } result; sign_x.i = x; sign_y.i = y; result.u = bitfieldInterleave(sign_x.u, sign_y.u); return result.i; } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y) { return detail::bitfieldInterleave(x, y); } GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(u32vec2 const& v) { return detail::bitfieldInterleave(v.x, v.y); } GLM_FUNC_QUALIFIER glm::u32vec2 bitfieldDeinterleave(glm::uint64 x) { glm::uint64 REG1(x); glm::uint64 REG2(x >>= 1); REG1 = REG1 & static_cast(0x5555555555555555ull); REG2 = REG2 & static_cast(0x5555555555555555ull); REG1 = ((REG1 >> 1) | REG1) & static_cast(0x3333333333333333ull); REG2 = ((REG2 >> 1) | REG2) & static_cast(0x3333333333333333ull); REG1 = ((REG1 >> 2) | REG1) & static_cast(0x0F0F0F0F0F0F0F0Full); REG2 = ((REG2 >> 2) | REG2) & static_cast(0x0F0F0F0F0F0F0F0Full); REG1 = ((REG1 >> 4) | REG1) & static_cast(0x00FF00FF00FF00FFull); REG2 = ((REG2 >> 4) | REG2) & static_cast(0x00FF00FF00FF00FFull); REG1 = ((REG1 >> 8) | REG1) & static_cast(0x0000FFFF0000FFFFull); REG2 = ((REG2 >> 8) | REG2) & static_cast(0x0000FFFF0000FFFFull); REG1 = ((REG1 >> 16) | REG1) & static_cast(0x00000000FFFFFFFFull); REG2 = ((REG2 >> 16) | REG2) & static_cast(0x00000000FFFFFFFFull); return glm::u32vec2(REG1, REG2); } GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z) { union sign8 { int8 i; uint8 u; } sign_x, sign_y, sign_z; union sign32 { int32 i; uint32 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u); return result.i; } GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z) { return detail::bitfieldInterleave(x, y, z); } GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(u8vec3 const& v) { return detail::bitfieldInterleave(v.x, v.y, v.z); } GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z) { union sign16 { int16 i; uint16 u; } sign_x, sign_y, sign_z; union sign64 { int64 i; uint64 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u); return result.i; } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z) { return detail::bitfieldInterleave(x, y, z); } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(u16vec3 const& v) { return detail::bitfieldInterleave(v.x, v.y, v.z); } GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y, int32 z) { union sign16 { int32 i; uint32 u; } sign_x, sign_y, sign_z; union sign64 { int64 i; uint64 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u); return result.i; } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z) { return detail::bitfieldInterleave(x, y, z); } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(u32vec3 const& v) { return detail::bitfieldInterleave(v.x, v.y, v.z); } GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w) { union sign8 { int8 i; uint8 u; } sign_x, sign_y, sign_z, sign_w; union sign32 { int32 i; uint32 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; sign_w.i = w; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u); return result.i; } GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w) { return detail::bitfieldInterleave(x, y, z, w); } GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(u8vec4 const& v) { return detail::bitfieldInterleave(v.x, v.y, v.z, v.w); } GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w) { union sign16 { int16 i; uint16 u; } sign_x, sign_y, sign_z, sign_w; union sign64 { int64 i; uint64 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; sign_w.i = w; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u); return result.i; } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w) { return detail::bitfieldInterleave(x, y, z, w); } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(u16vec4 const& v) { return detail::bitfieldInterleave(v.x, v.y, v.z, v.w); } }//namespace glm ================================================ FILE: android/src/glm/gtc/color_space.hpp ================================================ /// @ref gtc_color_space /// @file glm/gtc/color_space.hpp /// /// @see core (dependence) /// @see gtc_color_space (dependence) /// /// @defgroup gtc_color_space GLM_GTC_color_space /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Allow to perform bit operations on integer values #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../exponential.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_color_space extension included") #endif namespace glm { /// @addtogroup gtc_color_space /// @{ /// Convert a linear color to sRGB color using a standard gamma correction. /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb template GLM_FUNC_DECL vec convertLinearToSRGB(vec const& ColorLinear); /// Convert a linear color to sRGB color using a custom gamma correction. /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb template GLM_FUNC_DECL vec convertLinearToSRGB(vec const& ColorLinear, T Gamma); /// Convert a sRGB color to linear color using a standard gamma correction. /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb template GLM_FUNC_DECL vec convertSRGBToLinear(vec const& ColorSRGB); /// Convert a sRGB color to linear color using a custom gamma correction. // IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb template GLM_FUNC_DECL vec convertSRGBToLinear(vec const& ColorSRGB, T Gamma); /// @} } //namespace glm #include "color_space.inl" ================================================ FILE: android/src/glm/gtc/color_space.inl ================================================ /// @ref gtc_color_space namespace glm{ namespace detail { template struct compute_rgbToSrgb { GLM_FUNC_QUALIFIER static vec call(vec const& ColorRGB, T GammaCorrection) { vec const ClampedColor(clamp(ColorRGB, static_cast(0), static_cast(1))); return mix( pow(ClampedColor, vec(GammaCorrection)) * static_cast(1.055) - static_cast(0.055), ClampedColor * static_cast(12.92), lessThan(ClampedColor, vec(static_cast(0.0031308)))); } }; template struct compute_rgbToSrgb<4, T, Q> { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& ColorRGB, T GammaCorrection) { return vec<4, T, Q>(compute_rgbToSrgb<3, T, Q>::call(vec<3, T, Q>(ColorRGB), GammaCorrection), ColorRGB.w); } }; template struct compute_srgbToRgb { GLM_FUNC_QUALIFIER static vec call(vec const& ColorSRGB, T Gamma) { return mix( pow((ColorSRGB + static_cast(0.055)) * static_cast(0.94786729857819905213270142180095), vec(Gamma)), ColorSRGB * static_cast(0.07739938080495356037151702786378), lessThanEqual(ColorSRGB, vec(static_cast(0.04045)))); } }; template struct compute_srgbToRgb<4, T, Q> { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& ColorSRGB, T Gamma) { return vec<4, T, Q>(compute_srgbToRgb<3, T, Q>::call(vec<3, T, Q>(ColorSRGB), Gamma), ColorSRGB.w); } }; }//namespace detail template GLM_FUNC_QUALIFIER vec convertLinearToSRGB(vec const& ColorLinear) { return detail::compute_rgbToSrgb::call(ColorLinear, static_cast(0.41666)); } // Based on Ian Taylor http://chilliant.blogspot.fr/2012/08/srgb-approximations-for-hlsl.html template<> GLM_FUNC_QUALIFIER vec<3, float, lowp> convertLinearToSRGB(vec<3, float, lowp> const& ColorLinear) { vec<3, float, lowp> S1 = sqrt(ColorLinear); vec<3, float, lowp> S2 = sqrt(S1); vec<3, float, lowp> S3 = sqrt(S2); return 0.662002687f * S1 + 0.684122060f * S2 - 0.323583601f * S3 - 0.0225411470f * ColorLinear; } template GLM_FUNC_QUALIFIER vec convertLinearToSRGB(vec const& ColorLinear, T Gamma) { return detail::compute_rgbToSrgb::call(ColorLinear, static_cast(1) / Gamma); } template GLM_FUNC_QUALIFIER vec convertSRGBToLinear(vec const& ColorSRGB) { return detail::compute_srgbToRgb::call(ColorSRGB, static_cast(2.4)); } template GLM_FUNC_QUALIFIER vec convertSRGBToLinear(vec const& ColorSRGB, T Gamma) { return detail::compute_srgbToRgb::call(ColorSRGB, Gamma); } }//namespace glm ================================================ FILE: android/src/glm/gtc/constants.hpp ================================================ /// @ref gtc_constants /// @file glm/gtc/constants.hpp /// /// @see core (dependence) /// /// @defgroup gtc_constants GLM_GTC_constants /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Provide a list of constants and precomputed useful values. #pragma once // Dependencies #include "../ext/scalar_constants.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_constants extension included") #endif namespace glm { /// @addtogroup gtc_constants /// @{ /// Return 0. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType zero(); /// Return 1. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType one(); /// Return pi * 2. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType two_pi(); /// Return square root of pi. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_pi(); /// Return pi / 2. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType half_pi(); /// Return pi / 2 * 3. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType three_over_two_pi(); /// Return pi / 4. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType quarter_pi(); /// Return 1 / pi. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_pi(); /// Return 1 / (pi * 2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_two_pi(); /// Return 2 / pi. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_pi(); /// Return 4 / pi. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType four_over_pi(); /// Return 2 / sqrt(pi). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_root_pi(); /// Return 1 / sqrt(2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_root_two(); /// Return sqrt(pi / 2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_half_pi(); /// Return sqrt(2 * pi). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_two_pi(); /// Return sqrt(ln(4)). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_ln_four(); /// Return e constant. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType e(); /// Return Euler's constant. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType euler(); /// Return sqrt(2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_two(); /// Return sqrt(3). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_three(); /// Return sqrt(5). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_five(); /// Return ln(2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType ln_two(); /// Return ln(10). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ten(); /// Return ln(ln(2)). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ln_two(); /// Return 1 / 3. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType third(); /// Return 2 / 3. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType two_thirds(); /// Return the golden ratio constant. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType golden_ratio(); /// @} } //namespace glm #include "constants.inl" ================================================ FILE: android/src/glm/gtc/constants.inl ================================================ /// @ref gtc_constants namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType zero() { return genType(0); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one() { return genType(1); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_pi() { return genType(6.28318530717958647692528676655900576); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_pi() { return genType(1.772453850905516027); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType half_pi() { return genType(1.57079632679489661923132169163975144); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType three_over_two_pi() { return genType(4.71238898038468985769396507491925432); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType quarter_pi() { return genType(0.785398163397448309615660845819875721); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_pi() { return genType(0.318309886183790671537767526745028724); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_two_pi() { return genType(0.159154943091895335768883763372514362); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_pi() { return genType(0.636619772367581343075535053490057448); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType four_over_pi() { return genType(1.273239544735162686151070106980114898); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_root_pi() { return genType(1.12837916709551257389615890312154517); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_root_two() { return genType(0.707106781186547524400844362104849039); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_half_pi() { return genType(1.253314137315500251); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two_pi() { return genType(2.506628274631000502); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_ln_four() { return genType(1.17741002251547469); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType e() { return genType(2.71828182845904523536); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType euler() { return genType(0.577215664901532860606); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two() { return genType(1.41421356237309504880168872420969808); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_three() { return genType(1.73205080756887729352744634150587236); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_five() { return genType(2.23606797749978969640917366873127623); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_two() { return genType(0.693147180559945309417232121458176568); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ten() { return genType(2.30258509299404568401799145468436421); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ln_two() { return genType(-0.3665129205816643); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType third() { return genType(0.3333333333333333333333333333333333333333); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_thirds() { return genType(0.666666666666666666666666666666666666667); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType golden_ratio() { return genType(1.61803398874989484820458683436563811); } } //namespace glm ================================================ FILE: android/src/glm/gtc/epsilon.hpp ================================================ /// @ref gtc_epsilon /// @file glm/gtc/epsilon.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtc_epsilon GLM_GTC_epsilon /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Comparison functions for a user defined epsilon values. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_epsilon extension included") #endif namespace glm { /// @addtogroup gtc_epsilon /// @{ /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @see gtc_epsilon template GLM_FUNC_DECL vec epsilonEqual(vec const& x, vec const& y, T const& epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @see gtc_epsilon template GLM_FUNC_DECL bool epsilonEqual(genType const& x, genType const& y, genType const& epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is not satisfied. /// /// @see gtc_epsilon template GLM_FUNC_DECL vec epsilonNotEqual(vec const& x, vec const& y, T const& epsilon); /// Returns the component-wise comparison of |x - y| >= epsilon. /// True if this expression is not satisfied. /// /// @see gtc_epsilon template GLM_FUNC_DECL bool epsilonNotEqual(genType const& x, genType const& y, genType const& epsilon); /// @} }//namespace glm #include "epsilon.inl" ================================================ FILE: android/src/glm/gtc/epsilon.inl ================================================ /// @ref gtc_epsilon // Dependency: #include "../vector_relational.hpp" #include "../common.hpp" namespace glm { template<> GLM_FUNC_QUALIFIER bool epsilonEqual ( float const& x, float const& y, float const& epsilon ) { return abs(x - y) < epsilon; } template<> GLM_FUNC_QUALIFIER bool epsilonEqual ( double const& x, double const& y, double const& epsilon ) { return abs(x - y) < epsilon; } template GLM_FUNC_QUALIFIER vec epsilonEqual(vec const& x, vec const& y, T const& epsilon) { return lessThan(abs(x - y), vec(epsilon)); } template GLM_FUNC_QUALIFIER vec epsilonEqual(vec const& x, vec const& y, vec const& epsilon) { return lessThan(abs(x - y), vec(epsilon)); } template<> GLM_FUNC_QUALIFIER bool epsilonNotEqual(float const& x, float const& y, float const& epsilon) { return abs(x - y) >= epsilon; } template<> GLM_FUNC_QUALIFIER bool epsilonNotEqual(double const& x, double const& y, double const& epsilon) { return abs(x - y) >= epsilon; } template GLM_FUNC_QUALIFIER vec epsilonNotEqual(vec const& x, vec const& y, T const& epsilon) { return greaterThanEqual(abs(x - y), vec(epsilon)); } template GLM_FUNC_QUALIFIER vec epsilonNotEqual(vec const& x, vec const& y, vec const& epsilon) { return greaterThanEqual(abs(x - y), vec(epsilon)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> epsilonEqual(qua const& x, qua const& y, T const& epsilon) { vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); return lessThan(abs(v), vec<4, T, Q>(epsilon)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> epsilonNotEqual(qua const& x, qua const& y, T const& epsilon) { vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); return greaterThanEqual(abs(v), vec<4, T, Q>(epsilon)); } }//namespace glm ================================================ FILE: android/src/glm/gtc/integer.hpp ================================================ /// @ref gtc_integer /// @file glm/gtc/integer.hpp /// /// @see core (dependence) /// @see gtc_integer (dependence) /// /// @defgroup gtc_integer GLM_GTC_integer /// @ingroup gtc /// /// Include to use the features of this extension. /// /// @brief Allow to perform bit operations on integer values #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../common.hpp" #include "../integer.hpp" #include "../exponential.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_integer extension included") #endif namespace glm { /// @addtogroup gtc_integer /// @{ /// Returns the log2 of x for integer values. Usefull to compute mipmap count from the texture size. /// @see gtc_integer template GLM_FUNC_DECL genIUType log2(genIUType 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. /// /// @param x The values of the argument must be greater or equal to zero. /// @tparam T floating point scalar types. /// /// @see GLSL round man page /// @see gtc_integer template GLM_FUNC_DECL vec iround(vec 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. /// /// @param x The values of the argument must be greater or equal to zero. /// @tparam T floating point scalar types. /// /// @see GLSL round man page /// @see gtc_integer template GLM_FUNC_DECL vec uround(vec const& x); /// @} } //namespace glm #include "integer.inl" ================================================ FILE: android/src/glm/gtc/integer.inl ================================================ /// @ref gtc_integer namespace glm{ namespace detail { template struct compute_log2 { GLM_FUNC_QUALIFIER static vec call(vec const& v) { //Equivalent to return findMSB(vec); but save one function call in ASM with VC //return findMSB(vec); return vec(detail::compute_findMSB_vec::call(v)); } }; # if GLM_HAS_BITSCAN_WINDOWS template struct compute_log2<4, int, Q, false, Aligned> { GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v) { vec<4, int, Q> Result; _BitScanReverse(reinterpret_cast(&Result.x), v.x); _BitScanReverse(reinterpret_cast(&Result.y), v.y); _BitScanReverse(reinterpret_cast(&Result.z), v.z); _BitScanReverse(reinterpret_cast(&Result.w), v.w); return Result; } }; # endif//GLM_HAS_BITSCAN_WINDOWS }//namespace detail template GLM_FUNC_QUALIFIER int iround(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'iround' only accept floating-point inputs"); assert(static_cast(0.0) <= x); return static_cast(x + static_cast(0.5)); } template GLM_FUNC_QUALIFIER vec iround(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'iround' only accept floating-point inputs"); assert(all(lessThanEqual(vec(0), x))); return vec(x + static_cast(0.5)); } template GLM_FUNC_QUALIFIER uint uround(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'uround' only accept floating-point inputs"); assert(static_cast(0.0) <= x); return static_cast(x + static_cast(0.5)); } template GLM_FUNC_QUALIFIER vec uround(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'uround' only accept floating-point inputs"); assert(all(lessThanEqual(vec(0), x))); return vec(x + static_cast(0.5)); } }//namespace glm ================================================ FILE: android/src/glm/gtc/matrix_access.hpp ================================================ /// @ref gtc_matrix_access /// @file glm/gtc/matrix_access.hpp /// /// @see core (dependence) /// /// @defgroup gtc_matrix_access GLM_GTC_matrix_access /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines functions to access rows or columns of a matrix easily. #pragma once // Dependency: #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_matrix_access extension included") #endif namespace glm { /// @addtogroup gtc_matrix_access /// @{ /// Get a specific row of a matrix. /// @see gtc_matrix_access template GLM_FUNC_DECL typename genType::row_type row( genType const& m, length_t index); /// Set a specific row to a matrix. /// @see gtc_matrix_access template GLM_FUNC_DECL genType row( genType const& m, length_t index, typename genType::row_type const& x); /// Get a specific column of a matrix. /// @see gtc_matrix_access template GLM_FUNC_DECL typename genType::col_type column( genType const& m, length_t index); /// Set a specific column to a matrix. /// @see gtc_matrix_access template GLM_FUNC_DECL genType column( genType const& m, length_t index, typename genType::col_type const& x); /// @} }//namespace glm #include "matrix_access.inl" ================================================ FILE: android/src/glm/gtc/matrix_access.inl ================================================ /// @ref gtc_matrix_access namespace glm { template GLM_FUNC_QUALIFIER genType row ( genType const& m, length_t index, typename genType::row_type const& x ) { assert(index >= 0 && index < m[0].length()); genType Result = m; for(length_t i = 0; i < m.length(); ++i) Result[i][index] = x[i]; return Result; } template GLM_FUNC_QUALIFIER typename genType::row_type row ( genType const& m, length_t index ) { assert(index >= 0 && index < m[0].length()); typename genType::row_type Result(0); for(length_t i = 0; i < m.length(); ++i) Result[i] = m[i][index]; return Result; } template GLM_FUNC_QUALIFIER genType column ( genType const& m, length_t index, typename genType::col_type const& x ) { assert(index >= 0 && index < m.length()); genType Result = m; Result[index] = x; return Result; } template GLM_FUNC_QUALIFIER typename genType::col_type column ( genType const& m, length_t index ) { assert(index >= 0 && index < m.length()); return m[index]; } }//namespace glm ================================================ FILE: android/src/glm/gtc/matrix_integer.hpp ================================================ /// @ref gtc_matrix_integer /// @file glm/gtc/matrix_integer.hpp /// /// @see core (dependence) /// /// @defgroup gtc_matrix_integer GLM_GTC_matrix_integer /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x2.hpp" #include "../mat2x3.hpp" #include "../mat2x4.hpp" #include "../mat3x2.hpp" #include "../mat3x3.hpp" #include "../mat3x4.hpp" #include "../mat4x2.hpp" #include "../mat4x3.hpp" #include "../mat4x4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_matrix_integer extension included") #endif namespace glm { /// @addtogroup gtc_matrix_integer /// @{ /// High-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, highp> highp_imat2; /// High-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, highp> highp_imat3; /// High-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, highp> highp_imat4; /// High-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, highp> highp_imat2x2; /// High-qualifier signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, highp> highp_imat2x3; /// High-qualifier signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, highp> highp_imat2x4; /// High-qualifier signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, highp> highp_imat3x2; /// High-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, highp> highp_imat3x3; /// High-qualifier signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, highp> highp_imat3x4; /// High-qualifier signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, highp> highp_imat4x2; /// High-qualifier signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, highp> highp_imat4x3; /// High-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, highp> highp_imat4x4; /// Medium-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, mediump> mediump_imat2; /// Medium-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, mediump> mediump_imat3; /// Medium-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, mediump> mediump_imat4; /// Medium-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, mediump> mediump_imat2x2; /// Medium-qualifier signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, mediump> mediump_imat2x3; /// Medium-qualifier signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, mediump> mediump_imat2x4; /// Medium-qualifier signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, mediump> mediump_imat3x2; /// Medium-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, mediump> mediump_imat3x3; /// Medium-qualifier signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, mediump> mediump_imat3x4; /// Medium-qualifier signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, mediump> mediump_imat4x2; /// Medium-qualifier signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, mediump> mediump_imat4x3; /// Medium-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, mediump> mediump_imat4x4; /// Low-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, lowp> lowp_imat2; /// Low-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, lowp> lowp_imat3; /// Low-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, lowp> lowp_imat4; /// Low-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, lowp> lowp_imat2x2; /// Low-qualifier signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, lowp> lowp_imat2x3; /// Low-qualifier signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, lowp> lowp_imat2x4; /// Low-qualifier signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, lowp> lowp_imat3x2; /// Low-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, lowp> lowp_imat3x3; /// Low-qualifier signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, lowp> lowp_imat3x4; /// Low-qualifier signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, lowp> lowp_imat4x2; /// Low-qualifier signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, lowp> lowp_imat4x3; /// Low-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, lowp> lowp_imat4x4; /// High-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, highp> highp_umat2; /// High-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, highp> highp_umat3; /// High-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, highp> highp_umat4; /// High-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, highp> highp_umat2x2; /// High-qualifier unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, highp> highp_umat2x3; /// High-qualifier unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, highp> highp_umat2x4; /// High-qualifier unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, highp> highp_umat3x2; /// High-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, highp> highp_umat3x3; /// High-qualifier unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, highp> highp_umat3x4; /// High-qualifier unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, highp> highp_umat4x2; /// High-qualifier unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, highp> highp_umat4x3; /// High-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, highp> highp_umat4x4; /// Medium-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, mediump> mediump_umat2; /// Medium-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, mediump> mediump_umat3; /// Medium-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, mediump> mediump_umat4; /// Medium-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, mediump> mediump_umat2x2; /// Medium-qualifier unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, mediump> mediump_umat2x3; /// Medium-qualifier unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, mediump> mediump_umat2x4; /// Medium-qualifier unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, mediump> mediump_umat3x2; /// Medium-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, mediump> mediump_umat3x3; /// Medium-qualifier unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, mediump> mediump_umat3x4; /// Medium-qualifier unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, mediump> mediump_umat4x2; /// Medium-qualifier unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, mediump> mediump_umat4x3; /// Medium-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, mediump> mediump_umat4x4; /// Low-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, lowp> lowp_umat2; /// Low-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, lowp> lowp_umat3; /// Low-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, lowp> lowp_umat4; /// Low-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, lowp> lowp_umat2x2; /// Low-qualifier unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, lowp> lowp_umat2x3; /// Low-qualifier unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, lowp> lowp_umat2x4; /// Low-qualifier unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, lowp> lowp_umat3x2; /// Low-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, lowp> lowp_umat3x3; /// Low-qualifier unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, lowp> lowp_umat3x4; /// Low-qualifier unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, lowp> lowp_umat4x2; /// Low-qualifier unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, lowp> lowp_umat4x3; /// Low-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, lowp> lowp_umat4x4; /// Signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, defaultp> imat2; /// Signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, defaultp> imat3; /// Signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, defaultp> imat4; /// Signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, defaultp> imat2x2; /// Signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, defaultp> imat2x3; /// Signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, defaultp> imat2x4; /// Signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, defaultp> imat3x2; /// Signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, defaultp> imat3x3; /// Signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, defaultp> imat3x4; /// Signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, defaultp> imat4x2; /// Signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, defaultp> imat4x3; /// Signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, defaultp> imat4x4; /// Unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, defaultp> umat2; /// Unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, defaultp> umat3; /// Unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, defaultp> umat4; /// Unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, defaultp> umat2x2; /// Unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, defaultp> umat2x3; /// Unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, defaultp> umat2x4; /// Unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, defaultp> umat3x2; /// Unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, defaultp> umat3x3; /// Unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, defaultp> umat3x4; /// Unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, defaultp> umat4x2; /// Unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, defaultp> umat4x3; /// Unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, defaultp> umat4x4; /// @} }//namespace glm ================================================ FILE: android/src/glm/gtc/matrix_inverse.hpp ================================================ /// @ref gtc_matrix_inverse /// @file glm/gtc/matrix_inverse.hpp /// /// @see core (dependence) /// /// @defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines additional matrix inverting functions. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../matrix.hpp" #include "../mat2x2.hpp" #include "../mat3x3.hpp" #include "../mat4x4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_matrix_inverse extension included") #endif namespace glm { /// @addtogroup gtc_matrix_inverse /// @{ /// Fast matrix inverse for affine matrix. /// /// @param m Input matrix to invert. /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. /// @see gtc_matrix_inverse template GLM_FUNC_DECL genType affineInverse(genType const& m); /// Compute the inverse transpose of a matrix. /// /// @param m Input matrix to invert transpose. /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. /// @see gtc_matrix_inverse template GLM_FUNC_DECL genType inverseTranspose(genType const& m); /// @} }//namespace glm #include "matrix_inverse.inl" ================================================ FILE: android/src/glm/gtc/matrix_inverse.inl ================================================ /// @ref gtc_matrix_inverse namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> affineInverse(mat<3, 3, T, Q> const& m) { mat<2, 2, T, Q> const Inv(inverse(mat<2, 2, T, Q>(m))); return mat<3, 3, T, Q>( vec<3, T, Q>(Inv[0], static_cast(0)), vec<3, T, Q>(Inv[1], static_cast(0)), vec<3, T, Q>(-Inv * vec<2, T, Q>(m[2]), static_cast(1))); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> affineInverse(mat<4, 4, T, Q> const& m) { mat<3, 3, T, Q> const Inv(inverse(mat<3, 3, T, Q>(m))); return mat<4, 4, T, Q>( vec<4, T, Q>(Inv[0], static_cast(0)), vec<4, T, Q>(Inv[1], static_cast(0)), vec<4, T, Q>(Inv[2], static_cast(0)), vec<4, T, Q>(-Inv * vec<3, T, Q>(m[3]), static_cast(1))); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> inverseTranspose(mat<2, 2, T, Q> const& m) { T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1]; mat<2, 2, T, Q> Inverse( + m[1][1] / Determinant, - m[0][1] / Determinant, - m[1][0] / Determinant, + m[0][0] / Determinant); return Inverse; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> inverseTranspose(mat<3, 3, T, Q> const& m) { T Determinant = + m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]); mat<3, 3, T, Q> Inverse; Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]); Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]); Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]); Inverse[1][0] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]); Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]); Inverse[1][2] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]); Inverse[2][0] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]); Inverse[2][1] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]); Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]); Inverse /= Determinant; return Inverse; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> inverseTranspose(mat<4, 4, T, Q> const& m) { T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; T SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; T SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; T SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; T SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; T SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; T SubFactor11 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; T SubFactor12 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; T SubFactor13 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; T SubFactor14 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; T SubFactor15 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; T SubFactor16 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; T SubFactor17 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; mat<4, 4, T, Q> Inverse; Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02); Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04); Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05); Inverse[0][3] = - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05); Inverse[1][0] = - (m[0][1] * SubFactor00 - m[0][2] * SubFactor01 + m[0][3] * SubFactor02); Inverse[1][1] = + (m[0][0] * SubFactor00 - m[0][2] * SubFactor03 + m[0][3] * SubFactor04); Inverse[1][2] = - (m[0][0] * SubFactor01 - m[0][1] * SubFactor03 + m[0][3] * SubFactor05); Inverse[1][3] = + (m[0][0] * SubFactor02 - m[0][1] * SubFactor04 + m[0][2] * SubFactor05); Inverse[2][0] = + (m[0][1] * SubFactor06 - m[0][2] * SubFactor07 + m[0][3] * SubFactor08); Inverse[2][1] = - (m[0][0] * SubFactor06 - m[0][2] * SubFactor09 + m[0][3] * SubFactor10); Inverse[2][2] = + (m[0][0] * SubFactor07 - m[0][1] * SubFactor09 + m[0][3] * SubFactor11); Inverse[2][3] = - (m[0][0] * SubFactor08 - m[0][1] * SubFactor10 + m[0][2] * SubFactor11); Inverse[3][0] = - (m[0][1] * SubFactor12 - m[0][2] * SubFactor13 + m[0][3] * SubFactor14); Inverse[3][1] = + (m[0][0] * SubFactor12 - m[0][2] * SubFactor15 + m[0][3] * SubFactor16); Inverse[3][2] = - (m[0][0] * SubFactor13 - m[0][1] * SubFactor15 + m[0][3] * SubFactor17); Inverse[3][3] = + (m[0][0] * SubFactor14 - m[0][1] * SubFactor16 + m[0][2] * SubFactor17); T Determinant = + m[0][0] * Inverse[0][0] + m[0][1] * Inverse[0][1] + m[0][2] * Inverse[0][2] + m[0][3] * Inverse[0][3]; Inverse /= Determinant; return Inverse; } }//namespace glm ================================================ FILE: android/src/glm/gtc/matrix_transform.hpp ================================================ /// @ref gtc_matrix_transform /// @file glm/gtc/matrix_transform.hpp /// /// @see core (dependence) /// @see gtx_transform /// @see gtx_transform2 /// /// @defgroup gtc_matrix_transform GLM_GTC_matrix_transform /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines functions that generate common transformation matrices. /// /// The matrices generated by this extension use standard OpenGL fixed-function /// conventions. For example, the lookAt function generates a transform from world /// space into the specific eye space that the projective matrix functions /// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility /// specifications defines the particular layout of this eye space. #pragma once // Dependencies #include "../mat4x4.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../ext/matrix_projection.hpp" #include "../ext/matrix_clip_space.hpp" #include "../ext/matrix_transform.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_matrix_transform extension included") #endif #include "matrix_transform.inl" ================================================ FILE: android/src/glm/gtc/matrix_transform.inl ================================================ #include "../geometric.hpp" #include "../trigonometric.hpp" #include "../matrix.hpp" ================================================ FILE: android/src/glm/gtc/noise.hpp ================================================ /// @ref gtc_noise /// @file glm/gtc/noise.hpp /// /// @see core (dependence) /// /// @defgroup gtc_noise GLM_GTC_noise /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines 2D, 3D and 4D procedural noise functions /// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": /// https://github.com/ashima/webgl-noise /// Following Stefan Gustavson's paper "Simplex noise demystified": /// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/_noise.hpp" #include "../geometric.hpp" #include "../common.hpp" #include "../vector_relational.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_noise extension included") #endif namespace glm { /// @addtogroup gtc_noise /// @{ /// Classic perlin noise. /// @see gtc_noise template GLM_FUNC_DECL T perlin( vec const& p); /// Periodic perlin noise. /// @see gtc_noise template GLM_FUNC_DECL T perlin( vec const& p, vec const& rep); /// Simplex noise. /// @see gtc_noise template GLM_FUNC_DECL T simplex( vec const& p); /// @} }//namespace glm #include "noise.inl" ================================================ FILE: android/src/glm/gtc/noise.inl ================================================ /// @ref gtc_noise /// // Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": // https://github.com/ashima/webgl-noise // Following Stefan Gustavson's paper "Simplex noise demystified": // http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf namespace glm{ namespace gtc { template GLM_FUNC_QUALIFIER vec<4, T, Q> grad4(T const& j, vec<4, T, Q> const& ip) { vec<3, T, Q> pXYZ = floor(fract(vec<3, T, Q>(j) * vec<3, T, Q>(ip)) * T(7)) * ip[2] - T(1); T pW = static_cast(1.5) - dot(abs(pXYZ), vec<3, T, Q>(1)); vec<4, T, Q> s = vec<4, T, Q>(lessThan(vec<4, T, Q>(pXYZ, pW), vec<4, T, Q>(0.0))); pXYZ = pXYZ + (vec<3, T, Q>(s) * T(2) - T(1)) * s.w; return vec<4, T, Q>(pXYZ, pW); } }//namespace gtc // Classic Perlin noise template GLM_FUNC_QUALIFIER T perlin(vec<2, T, Q> const& Position) { vec<4, T, Q> Pi = glm::floor(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, Q>(0.0, 0.0, 1.0, 1.0); vec<4, T, Q> Pf = glm::fract(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, Q>(0.0, 0.0, 1.0, 1.0); Pi = mod(Pi, vec<4, T, Q>(289)); // To avoid truncation effects in permutation vec<4, T, Q> ix(Pi.x, Pi.z, Pi.x, Pi.z); vec<4, T, Q> iy(Pi.y, Pi.y, Pi.w, Pi.w); vec<4, T, Q> fx(Pf.x, Pf.z, Pf.x, Pf.z); vec<4, T, Q> fy(Pf.y, Pf.y, Pf.w, Pf.w); vec<4, T, Q> i = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> gx = static_cast(2) * glm::fract(i / T(41)) - T(1); vec<4, T, Q> gy = glm::abs(gx) - T(0.5); vec<4, T, Q> tx = glm::floor(gx + T(0.5)); gx = gx - tx; vec<2, T, Q> g00(gx.x, gy.x); vec<2, T, Q> g10(gx.y, gy.y); vec<2, T, Q> g01(gx.z, gy.z); vec<2, T, Q> g11(gx.w, gy.w); vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11))); g00 *= norm.x; g01 *= norm.y; g10 *= norm.z; g11 *= norm.w; T n00 = dot(g00, vec<2, T, Q>(fx.x, fy.x)); T n10 = dot(g10, vec<2, T, Q>(fx.y, fy.y)); T n01 = dot(g01, vec<2, T, Q>(fx.z, fy.z)); T n11 = dot(g11, vec<2, T, Q>(fx.w, fy.w)); vec<2, T, Q> fade_xy = detail::fade(vec<2, T, Q>(Pf.x, Pf.y)); vec<2, T, Q> n_x = mix(vec<2, T, Q>(n00, n01), vec<2, T, Q>(n10, n11), fade_xy.x); T n_xy = mix(n_x.x, n_x.y, fade_xy.y); return T(2.3) * n_xy; } // Classic Perlin noise template GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& Position) { vec<3, T, Q> Pi0 = floor(Position); // Integer part for indexing vec<3, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1 Pi0 = detail::mod289(Pi0); Pi1 = detail::mod289(Pi1); vec<3, T, Q> Pf0 = fract(Position); // Fractional part for interpolation vec<3, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0 vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy = vec<4, T, Q>(vec<2, T, Q>(Pi0.y), vec<2, T, Q>(Pi1.y)); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> ixy0 = detail::permute(ixy + iz0); vec<4, T, Q> ixy1 = detail::permute(ixy + iz1); vec<4, T, Q> gx0 = ixy0 * T(1.0 / 7.0); vec<4, T, Q> gy0 = fract(floor(gx0) * T(1.0 / 7.0)) - T(0.5); gx0 = fract(gx0); vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0); vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0.0)); gx0 -= sz0 * (step(T(0), gx0) - T(0.5)); gy0 -= sz0 * (step(T(0), gy0) - T(0.5)); vec<4, T, Q> gx1 = ixy1 * T(1.0 / 7.0); vec<4, T, Q> gy1 = fract(floor(gx1) * T(1.0 / 7.0)) - T(0.5); gx1 = fract(gx1); vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1); vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(0.0)); gx1 -= sz1 * (step(T(0), gx1) - T(0.5)); gy1 -= sz1 * (step(T(0), gy1) - T(0.5)); vec<3, T, Q> g000(gx0.x, gy0.x, gz0.x); vec<3, T, Q> g100(gx0.y, gy0.y, gz0.y); vec<3, T, Q> g010(gx0.z, gy0.z, gz0.z); vec<3, T, Q> g110(gx0.w, gy0.w, gz0.w); vec<3, T, Q> g001(gx1.x, gy1.x, gz1.x); vec<3, T, Q> g101(gx1.y, gy1.y, gz1.y); vec<3, T, Q> g011(gx1.z, gy1.z, gz1.z); vec<3, T, Q> g111(gx1.w, gy1.w, gz1.w); vec<4, T, Q> norm0 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110))); g000 *= norm0.x; g010 *= norm0.y; g100 *= norm0.z; g110 *= norm0.w; vec<4, T, Q> norm1 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111))); g001 *= norm1.x; g011 *= norm1.y; g101 *= norm1.z; g111 *= norm1.w; T n000 = dot(g000, Pf0); T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z)); T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z)); T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z)); T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z)); T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z)); T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z)); T n111 = dot(g111, Pf1); vec<3, T, Q> fade_xyz = detail::fade(Pf0); vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z); vec<2, T, Q> n_yz = mix(vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y); T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); return T(2.2) * n_xyz; } /* // Classic Perlin noise template GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& P) { vec<3, T, Q> Pi0 = floor(P); // Integer part for indexing vec<3, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1 Pi0 = mod(Pi0, T(289)); Pi1 = mod(Pi1, T(289)); vec<3, T, Q> Pf0 = fract(P); // Fractional part for interpolation vec<3, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0 vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> ixy = permute(permute(ix) + iy); vec<4, T, Q> ixy0 = permute(ixy + iz0); vec<4, T, Q> ixy1 = permute(ixy + iz1); vec<4, T, Q> gx0 = ixy0 / T(7); vec<4, T, Q> gy0 = fract(floor(gx0) / T(7)) - T(0.5); gx0 = fract(gx0); vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0); vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0.0)); gx0 -= sz0 * (step(0.0, gx0) - T(0.5)); gy0 -= sz0 * (step(0.0, gy0) - T(0.5)); vec<4, T, Q> gx1 = ixy1 / T(7); vec<4, T, Q> gy1 = fract(floor(gx1) / T(7)) - T(0.5); gx1 = fract(gx1); vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1); vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(0.0)); gx1 -= sz1 * (step(T(0), gx1) - T(0.5)); gy1 -= sz1 * (step(T(0), gy1) - T(0.5)); vec<3, T, Q> g000(gx0.x, gy0.x, gz0.x); vec<3, T, Q> g100(gx0.y, gy0.y, gz0.y); vec<3, T, Q> g010(gx0.z, gy0.z, gz0.z); vec<3, T, Q> g110(gx0.w, gy0.w, gz0.w); vec<3, T, Q> g001(gx1.x, gy1.x, gz1.x); vec<3, T, Q> g101(gx1.y, gy1.y, gz1.y); vec<3, T, Q> g011(gx1.z, gy1.z, gz1.z); vec<3, T, Q> g111(gx1.w, gy1.w, gz1.w); vec<4, T, Q> norm0 = taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110))); g000 *= norm0.x; g010 *= norm0.y; g100 *= norm0.z; g110 *= norm0.w; vec<4, T, Q> norm1 = taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111))); g001 *= norm1.x; g011 *= norm1.y; g101 *= norm1.z; g111 *= norm1.w; T n000 = dot(g000, Pf0); T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z)); T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z)); T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z)); T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z)); T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z)); T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z)); T n111 = dot(g111, Pf1); vec<3, T, Q> fade_xyz = fade(Pf0); vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z); vec<2, T, Q> n_yz = mix( vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y); T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); return T(2.2) * n_xyz; } */ // Classic Perlin noise template GLM_FUNC_QUALIFIER T perlin(vec<4, T, Q> const& Position) { vec<4, T, Q> Pi0 = floor(Position); // Integer part for indexing vec<4, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1 Pi0 = mod(Pi0, vec<4, T, Q>(289)); Pi1 = mod(Pi1, vec<4, T, Q>(289)); vec<4, T, Q> Pf0 = fract(Position); // Fractional part for interpolation vec<4, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0 vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> iw0(Pi0.w); vec<4, T, Q> iw1(Pi1.w); vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> ixy0 = detail::permute(ixy + iz0); vec<4, T, Q> ixy1 = detail::permute(ixy + iz1); vec<4, T, Q> ixy00 = detail::permute(ixy0 + iw0); vec<4, T, Q> ixy01 = detail::permute(ixy0 + iw1); vec<4, T, Q> ixy10 = detail::permute(ixy1 + iw0); vec<4, T, Q> ixy11 = detail::permute(ixy1 + iw1); vec<4, T, Q> gx00 = ixy00 / T(7); vec<4, T, Q> gy00 = floor(gx00) / T(7); vec<4, T, Q> gz00 = floor(gy00) / T(6); gx00 = fract(gx00) - T(0.5); gy00 = fract(gy00) - T(0.5); gz00 = fract(gz00) - T(0.5); vec<4, T, Q> gw00 = vec<4, T, Q>(0.75) - abs(gx00) - abs(gy00) - abs(gz00); vec<4, T, Q> sw00 = step(gw00, vec<4, T, Q>(0.0)); gx00 -= sw00 * (step(T(0), gx00) - T(0.5)); gy00 -= sw00 * (step(T(0), gy00) - T(0.5)); vec<4, T, Q> gx01 = ixy01 / T(7); vec<4, T, Q> gy01 = floor(gx01) / T(7); vec<4, T, Q> gz01 = floor(gy01) / T(6); gx01 = fract(gx01) - T(0.5); gy01 = fract(gy01) - T(0.5); gz01 = fract(gz01) - T(0.5); vec<4, T, Q> gw01 = vec<4, T, Q>(0.75) - abs(gx01) - abs(gy01) - abs(gz01); vec<4, T, Q> sw01 = step(gw01, vec<4, T, Q>(0.0)); gx01 -= sw01 * (step(T(0), gx01) - T(0.5)); gy01 -= sw01 * (step(T(0), gy01) - T(0.5)); vec<4, T, Q> gx10 = ixy10 / T(7); vec<4, T, Q> gy10 = floor(gx10) / T(7); vec<4, T, Q> gz10 = floor(gy10) / T(6); gx10 = fract(gx10) - T(0.5); gy10 = fract(gy10) - T(0.5); gz10 = fract(gz10) - T(0.5); vec<4, T, Q> gw10 = vec<4, T, Q>(0.75) - abs(gx10) - abs(gy10) - abs(gz10); vec<4, T, Q> sw10 = step(gw10, vec<4, T, Q>(0)); gx10 -= sw10 * (step(T(0), gx10) - T(0.5)); gy10 -= sw10 * (step(T(0), gy10) - T(0.5)); vec<4, T, Q> gx11 = ixy11 / T(7); vec<4, T, Q> gy11 = floor(gx11) / T(7); vec<4, T, Q> gz11 = floor(gy11) / T(6); gx11 = fract(gx11) - T(0.5); gy11 = fract(gy11) - T(0.5); gz11 = fract(gz11) - T(0.5); vec<4, T, Q> gw11 = vec<4, T, Q>(0.75) - abs(gx11) - abs(gy11) - abs(gz11); vec<4, T, Q> sw11 = step(gw11, vec<4, T, Q>(0.0)); gx11 -= sw11 * (step(T(0), gx11) - T(0.5)); gy11 -= sw11 * (step(T(0), gy11) - T(0.5)); vec<4, T, Q> g0000(gx00.x, gy00.x, gz00.x, gw00.x); vec<4, T, Q> g1000(gx00.y, gy00.y, gz00.y, gw00.y); vec<4, T, Q> g0100(gx00.z, gy00.z, gz00.z, gw00.z); vec<4, T, Q> g1100(gx00.w, gy00.w, gz00.w, gw00.w); vec<4, T, Q> g0010(gx10.x, gy10.x, gz10.x, gw10.x); vec<4, T, Q> g1010(gx10.y, gy10.y, gz10.y, gw10.y); vec<4, T, Q> g0110(gx10.z, gy10.z, gz10.z, gw10.z); vec<4, T, Q> g1110(gx10.w, gy10.w, gz10.w, gw10.w); vec<4, T, Q> g0001(gx01.x, gy01.x, gz01.x, gw01.x); vec<4, T, Q> g1001(gx01.y, gy01.y, gz01.y, gw01.y); vec<4, T, Q> g0101(gx01.z, gy01.z, gz01.z, gw01.z); vec<4, T, Q> g1101(gx01.w, gy01.w, gz01.w, gw01.w); vec<4, T, Q> g0011(gx11.x, gy11.x, gz11.x, gw11.x); vec<4, T, Q> g1011(gx11.y, gy11.y, gz11.y, gw11.y); vec<4, T, Q> g0111(gx11.z, gy11.z, gz11.z, gw11.z); vec<4, T, Q> g1111(gx11.w, gy11.w, gz11.w, gw11.w); vec<4, T, Q> norm00 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100))); g0000 *= norm00.x; g0100 *= norm00.y; g1000 *= norm00.z; g1100 *= norm00.w; vec<4, T, Q> norm01 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101))); g0001 *= norm01.x; g0101 *= norm01.y; g1001 *= norm01.z; g1101 *= norm01.w; vec<4, T, Q> norm10 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110))); g0010 *= norm10.x; g0110 *= norm10.y; g1010 *= norm10.z; g1110 *= norm10.w; vec<4, T, Q> norm11 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111))); g0011 *= norm11.x; g0111 *= norm11.y; g1011 *= norm11.z; g1111 *= norm11.w; T n0000 = dot(g0000, Pf0); T n1000 = dot(g1000, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf0.w)); T n0100 = dot(g0100, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf0.w)); T n1100 = dot(g1100, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf0.w)); T n0010 = dot(g0010, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf0.w)); T n1010 = dot(g1010, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf0.w)); T n0110 = dot(g0110, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf0.w)); T n1110 = dot(g1110, vec<4, T, Q>(Pf1.x, Pf1.y, Pf1.z, Pf0.w)); T n0001 = dot(g0001, vec<4, T, Q>(Pf0.x, Pf0.y, Pf0.z, Pf1.w)); T n1001 = dot(g1001, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf1.w)); T n0101 = dot(g0101, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf1.w)); T n1101 = dot(g1101, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf1.w)); T n0011 = dot(g0011, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf1.w)); T n1011 = dot(g1011, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf1.w)); T n0111 = dot(g0111, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf1.w)); T n1111 = dot(g1111, Pf1); vec<4, T, Q> fade_xyzw = detail::fade(Pf0); vec<4, T, Q> n_0w = mix(vec<4, T, Q>(n0000, n1000, n0100, n1100), vec<4, T, Q>(n0001, n1001, n0101, n1101), fade_xyzw.w); vec<4, T, Q> n_1w = mix(vec<4, T, Q>(n0010, n1010, n0110, n1110), vec<4, T, Q>(n0011, n1011, n0111, n1111), fade_xyzw.w); vec<4, T, Q> n_zw = mix(n_0w, n_1w, fade_xyzw.z); vec<2, T, Q> n_yzw = mix(vec<2, T, Q>(n_zw.x, n_zw.y), vec<2, T, Q>(n_zw.z, n_zw.w), fade_xyzw.y); T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x); return T(2.2) * n_xyzw; } // Classic Perlin noise, periodic variant template GLM_FUNC_QUALIFIER T perlin(vec<2, T, Q> const& Position, vec<2, T, Q> const& rep) { vec<4, T, Q> Pi = floor(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, Q>(0.0, 0.0, 1.0, 1.0); vec<4, T, Q> Pf = fract(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, Q>(0.0, 0.0, 1.0, 1.0); Pi = mod(Pi, vec<4, T, Q>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period Pi = mod(Pi, vec<4, T, Q>(289)); // To avoid truncation effects in permutation vec<4, T, Q> ix(Pi.x, Pi.z, Pi.x, Pi.z); vec<4, T, Q> iy(Pi.y, Pi.y, Pi.w, Pi.w); vec<4, T, Q> fx(Pf.x, Pf.z, Pf.x, Pf.z); vec<4, T, Q> fy(Pf.y, Pf.y, Pf.w, Pf.w); vec<4, T, Q> i = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> gx = static_cast(2) * fract(i / T(41)) - T(1); vec<4, T, Q> gy = abs(gx) - T(0.5); vec<4, T, Q> tx = floor(gx + T(0.5)); gx = gx - tx; vec<2, T, Q> g00(gx.x, gy.x); vec<2, T, Q> g10(gx.y, gy.y); vec<2, T, Q> g01(gx.z, gy.z); vec<2, T, Q> g11(gx.w, gy.w); vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11))); g00 *= norm.x; g01 *= norm.y; g10 *= norm.z; g11 *= norm.w; T n00 = dot(g00, vec<2, T, Q>(fx.x, fy.x)); T n10 = dot(g10, vec<2, T, Q>(fx.y, fy.y)); T n01 = dot(g01, vec<2, T, Q>(fx.z, fy.z)); T n11 = dot(g11, vec<2, T, Q>(fx.w, fy.w)); vec<2, T, Q> fade_xy = detail::fade(vec<2, T, Q>(Pf.x, Pf.y)); vec<2, T, Q> n_x = mix(vec<2, T, Q>(n00, n01), vec<2, T, Q>(n10, n11), fade_xy.x); T n_xy = mix(n_x.x, n_x.y, fade_xy.y); return T(2.3) * n_xy; } // Classic Perlin noise, periodic variant template GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& Position, vec<3, T, Q> const& rep) { vec<3, T, Q> Pi0 = mod(floor(Position), rep); // Integer part, modulo period vec<3, T, Q> Pi1 = mod(Pi0 + vec<3, T, Q>(T(1)), rep); // Integer part + 1, mod period Pi0 = mod(Pi0, vec<3, T, Q>(289)); Pi1 = mod(Pi1, vec<3, T, Q>(289)); vec<3, T, Q> Pf0 = fract(Position); // Fractional part for interpolation vec<3, T, Q> Pf1 = Pf0 - vec<3, T, Q>(T(1)); // Fractional part - 1.0 vec<4, T, Q> ix = vec<4, T, Q>(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy = vec<4, T, Q>(Pi0.y, Pi0.y, Pi1.y, Pi1.y); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> ixy0 = detail::permute(ixy + iz0); vec<4, T, Q> ixy1 = detail::permute(ixy + iz1); vec<4, T, Q> gx0 = ixy0 / T(7); vec<4, T, Q> gy0 = fract(floor(gx0) / T(7)) - T(0.5); gx0 = fract(gx0); vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0); vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0)); gx0 -= sz0 * (step(T(0), gx0) - T(0.5)); gy0 -= sz0 * (step(T(0), gy0) - T(0.5)); vec<4, T, Q> gx1 = ixy1 / T(7); vec<4, T, Q> gy1 = fract(floor(gx1) / T(7)) - T(0.5); gx1 = fract(gx1); vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1); vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(T(0))); gx1 -= sz1 * (step(T(0), gx1) - T(0.5)); gy1 -= sz1 * (step(T(0), gy1) - T(0.5)); vec<3, T, Q> g000 = vec<3, T, Q>(gx0.x, gy0.x, gz0.x); vec<3, T, Q> g100 = vec<3, T, Q>(gx0.y, gy0.y, gz0.y); vec<3, T, Q> g010 = vec<3, T, Q>(gx0.z, gy0.z, gz0.z); vec<3, T, Q> g110 = vec<3, T, Q>(gx0.w, gy0.w, gz0.w); vec<3, T, Q> g001 = vec<3, T, Q>(gx1.x, gy1.x, gz1.x); vec<3, T, Q> g101 = vec<3, T, Q>(gx1.y, gy1.y, gz1.y); vec<3, T, Q> g011 = vec<3, T, Q>(gx1.z, gy1.z, gz1.z); vec<3, T, Q> g111 = vec<3, T, Q>(gx1.w, gy1.w, gz1.w); vec<4, T, Q> norm0 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110))); g000 *= norm0.x; g010 *= norm0.y; g100 *= norm0.z; g110 *= norm0.w; vec<4, T, Q> norm1 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111))); g001 *= norm1.x; g011 *= norm1.y; g101 *= norm1.z; g111 *= norm1.w; T n000 = dot(g000, Pf0); T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z)); T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z)); T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z)); T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z)); T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z)); T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z)); T n111 = dot(g111, Pf1); vec<3, T, Q> fade_xyz = detail::fade(Pf0); vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z); vec<2, T, Q> n_yz = mix(vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y); T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); return T(2.2) * n_xyz; } // Classic Perlin noise, periodic version template GLM_FUNC_QUALIFIER T perlin(vec<4, T, Q> const& Position, vec<4, T, Q> const& rep) { vec<4, T, Q> Pi0 = mod(floor(Position), rep); // Integer part modulo rep vec<4, T, Q> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep vec<4, T, Q> Pf0 = fract(Position); // Fractional part for interpolation vec<4, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0 vec<4, T, Q> ix = vec<4, T, Q>(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy = vec<4, T, Q>(Pi0.y, Pi0.y, Pi1.y, Pi1.y); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> iw0(Pi0.w); vec<4, T, Q> iw1(Pi1.w); vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> ixy0 = detail::permute(ixy + iz0); vec<4, T, Q> ixy1 = detail::permute(ixy + iz1); vec<4, T, Q> ixy00 = detail::permute(ixy0 + iw0); vec<4, T, Q> ixy01 = detail::permute(ixy0 + iw1); vec<4, T, Q> ixy10 = detail::permute(ixy1 + iw0); vec<4, T, Q> ixy11 = detail::permute(ixy1 + iw1); vec<4, T, Q> gx00 = ixy00 / T(7); vec<4, T, Q> gy00 = floor(gx00) / T(7); vec<4, T, Q> gz00 = floor(gy00) / T(6); gx00 = fract(gx00) - T(0.5); gy00 = fract(gy00) - T(0.5); gz00 = fract(gz00) - T(0.5); vec<4, T, Q> gw00 = vec<4, T, Q>(0.75) - abs(gx00) - abs(gy00) - abs(gz00); vec<4, T, Q> sw00 = step(gw00, vec<4, T, Q>(0)); gx00 -= sw00 * (step(T(0), gx00) - T(0.5)); gy00 -= sw00 * (step(T(0), gy00) - T(0.5)); vec<4, T, Q> gx01 = ixy01 / T(7); vec<4, T, Q> gy01 = floor(gx01) / T(7); vec<4, T, Q> gz01 = floor(gy01) / T(6); gx01 = fract(gx01) - T(0.5); gy01 = fract(gy01) - T(0.5); gz01 = fract(gz01) - T(0.5); vec<4, T, Q> gw01 = vec<4, T, Q>(0.75) - abs(gx01) - abs(gy01) - abs(gz01); vec<4, T, Q> sw01 = step(gw01, vec<4, T, Q>(0.0)); gx01 -= sw01 * (step(T(0), gx01) - T(0.5)); gy01 -= sw01 * (step(T(0), gy01) - T(0.5)); vec<4, T, Q> gx10 = ixy10 / T(7); vec<4, T, Q> gy10 = floor(gx10) / T(7); vec<4, T, Q> gz10 = floor(gy10) / T(6); gx10 = fract(gx10) - T(0.5); gy10 = fract(gy10) - T(0.5); gz10 = fract(gz10) - T(0.5); vec<4, T, Q> gw10 = vec<4, T, Q>(0.75) - abs(gx10) - abs(gy10) - abs(gz10); vec<4, T, Q> sw10 = step(gw10, vec<4, T, Q>(0.0)); gx10 -= sw10 * (step(T(0), gx10) - T(0.5)); gy10 -= sw10 * (step(T(0), gy10) - T(0.5)); vec<4, T, Q> gx11 = ixy11 / T(7); vec<4, T, Q> gy11 = floor(gx11) / T(7); vec<4, T, Q> gz11 = floor(gy11) / T(6); gx11 = fract(gx11) - T(0.5); gy11 = fract(gy11) - T(0.5); gz11 = fract(gz11) - T(0.5); vec<4, T, Q> gw11 = vec<4, T, Q>(0.75) - abs(gx11) - abs(gy11) - abs(gz11); vec<4, T, Q> sw11 = step(gw11, vec<4, T, Q>(T(0))); gx11 -= sw11 * (step(T(0), gx11) - T(0.5)); gy11 -= sw11 * (step(T(0), gy11) - T(0.5)); vec<4, T, Q> g0000(gx00.x, gy00.x, gz00.x, gw00.x); vec<4, T, Q> g1000(gx00.y, gy00.y, gz00.y, gw00.y); vec<4, T, Q> g0100(gx00.z, gy00.z, gz00.z, gw00.z); vec<4, T, Q> g1100(gx00.w, gy00.w, gz00.w, gw00.w); vec<4, T, Q> g0010(gx10.x, gy10.x, gz10.x, gw10.x); vec<4, T, Q> g1010(gx10.y, gy10.y, gz10.y, gw10.y); vec<4, T, Q> g0110(gx10.z, gy10.z, gz10.z, gw10.z); vec<4, T, Q> g1110(gx10.w, gy10.w, gz10.w, gw10.w); vec<4, T, Q> g0001(gx01.x, gy01.x, gz01.x, gw01.x); vec<4, T, Q> g1001(gx01.y, gy01.y, gz01.y, gw01.y); vec<4, T, Q> g0101(gx01.z, gy01.z, gz01.z, gw01.z); vec<4, T, Q> g1101(gx01.w, gy01.w, gz01.w, gw01.w); vec<4, T, Q> g0011(gx11.x, gy11.x, gz11.x, gw11.x); vec<4, T, Q> g1011(gx11.y, gy11.y, gz11.y, gw11.y); vec<4, T, Q> g0111(gx11.z, gy11.z, gz11.z, gw11.z); vec<4, T, Q> g1111(gx11.w, gy11.w, gz11.w, gw11.w); vec<4, T, Q> norm00 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100))); g0000 *= norm00.x; g0100 *= norm00.y; g1000 *= norm00.z; g1100 *= norm00.w; vec<4, T, Q> norm01 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101))); g0001 *= norm01.x; g0101 *= norm01.y; g1001 *= norm01.z; g1101 *= norm01.w; vec<4, T, Q> norm10 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110))); g0010 *= norm10.x; g0110 *= norm10.y; g1010 *= norm10.z; g1110 *= norm10.w; vec<4, T, Q> norm11 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111))); g0011 *= norm11.x; g0111 *= norm11.y; g1011 *= norm11.z; g1111 *= norm11.w; T n0000 = dot(g0000, Pf0); T n1000 = dot(g1000, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf0.w)); T n0100 = dot(g0100, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf0.w)); T n1100 = dot(g1100, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf0.w)); T n0010 = dot(g0010, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf0.w)); T n1010 = dot(g1010, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf0.w)); T n0110 = dot(g0110, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf0.w)); T n1110 = dot(g1110, vec<4, T, Q>(Pf1.x, Pf1.y, Pf1.z, Pf0.w)); T n0001 = dot(g0001, vec<4, T, Q>(Pf0.x, Pf0.y, Pf0.z, Pf1.w)); T n1001 = dot(g1001, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf1.w)); T n0101 = dot(g0101, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf1.w)); T n1101 = dot(g1101, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf1.w)); T n0011 = dot(g0011, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf1.w)); T n1011 = dot(g1011, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf1.w)); T n0111 = dot(g0111, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf1.w)); T n1111 = dot(g1111, Pf1); vec<4, T, Q> fade_xyzw = detail::fade(Pf0); vec<4, T, Q> n_0w = mix(vec<4, T, Q>(n0000, n1000, n0100, n1100), vec<4, T, Q>(n0001, n1001, n0101, n1101), fade_xyzw.w); vec<4, T, Q> n_1w = mix(vec<4, T, Q>(n0010, n1010, n0110, n1110), vec<4, T, Q>(n0011, n1011, n0111, n1111), fade_xyzw.w); vec<4, T, Q> n_zw = mix(n_0w, n_1w, fade_xyzw.z); vec<2, T, Q> n_yzw = mix(vec<2, T, Q>(n_zw.x, n_zw.y), vec<2, T, Q>(n_zw.z, n_zw.w), fade_xyzw.y); T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x); return T(2.2) * n_xyzw; } template GLM_FUNC_QUALIFIER T simplex(glm::vec<2, T, Q> const& v) { vec<4, T, Q> const C = vec<4, T, Q>( T( 0.211324865405187), // (3.0 - sqrt(3.0)) / 6.0 T( 0.366025403784439), // 0.5 * (sqrt(3.0) - 1.0) T(-0.577350269189626), // -1.0 + 2.0 * C.x T( 0.024390243902439)); // 1.0 / 41.0 // First corner vec<2, T, Q> i = floor(v + dot(v, vec<2, T, Q>(C[1]))); vec<2, T, Q> x0 = v - i + dot(i, vec<2, T, Q>(C[0])); // Other corners //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0 //i1.y = 1.0 - i1.x; vec<2, T, Q> i1 = (x0.x > x0.y) ? vec<2, T, Q>(1, 0) : vec<2, T, Q>(0, 1); // x0 = x0 - 0.0 + 0.0 * C.xx ; // x1 = x0 - i1 + 1.0 * C.xx ; // x2 = x0 - 1.0 + 2.0 * C.xx ; vec<4, T, Q> x12 = vec<4, T, Q>(x0.x, x0.y, x0.x, x0.y) + vec<4, T, Q>(C.x, C.x, C.z, C.z); x12 = vec<4, T, Q>(vec<2, T, Q>(x12) - i1, x12.z, x12.w); // Permutations i = mod(i, vec<2, T, Q>(289)); // Avoid truncation effects in permutation vec<3, T, Q> p = detail::permute( detail::permute(i.y + vec<3, T, Q>(T(0), i1.y, T(1))) + i.x + vec<3, T, Q>(T(0), i1.x, T(1))); vec<3, T, Q> m = max(vec<3, T, Q>(0.5) - vec<3, T, Q>( dot(x0, x0), dot(vec<2, T, Q>(x12.x, x12.y), vec<2, T, Q>(x12.x, x12.y)), dot(vec<2, T, Q>(x12.z, x12.w), vec<2, T, Q>(x12.z, x12.w))), vec<3, T, Q>(0)); m = m * m ; m = m * m ; // Gradients: 41 points uniformly over a line, mapped onto a diamond. // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287) vec<3, T, Q> x = static_cast(2) * fract(p * C.w) - T(1); vec<3, T, Q> h = abs(x) - T(0.5); vec<3, T, Q> ox = floor(x + T(0.5)); vec<3, T, Q> a0 = x - ox; // Normalise gradients implicitly by scaling m // Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h ); m *= static_cast(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h); // Compute final noise value at P vec<3, T, Q> g; g.x = a0.x * x0.x + h.x * x0.y; //g.yz = a0.yz * x12.xz + h.yz * x12.yw; g.y = a0.y * x12.x + h.y * x12.y; g.z = a0.z * x12.z + h.z * x12.w; return T(130) * dot(m, g); } template GLM_FUNC_QUALIFIER T simplex(vec<3, T, Q> const& v) { vec<2, T, Q> const C(1.0 / 6.0, 1.0 / 3.0); vec<4, T, Q> const D(0.0, 0.5, 1.0, 2.0); // First corner vec<3, T, Q> i(floor(v + dot(v, vec<3, T, Q>(C.y)))); vec<3, T, Q> x0(v - i + dot(i, vec<3, T, Q>(C.x))); // Other corners vec<3, T, Q> g(step(vec<3, T, Q>(x0.y, x0.z, x0.x), x0)); vec<3, T, Q> l(T(1) - g); vec<3, T, Q> i1(min(g, vec<3, T, Q>(l.z, l.x, l.y))); vec<3, T, Q> i2(max(g, vec<3, T, Q>(l.z, l.x, l.y))); // x0 = x0 - 0.0 + 0.0 * C.xxx; // x1 = x0 - i1 + 1.0 * C.xxx; // x2 = x0 - i2 + 2.0 * C.xxx; // x3 = x0 - 1.0 + 3.0 * C.xxx; vec<3, T, Q> x1(x0 - i1 + C.x); vec<3, T, Q> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y vec<3, T, Q> x3(x0 - D.y); // -1.0+3.0*C.x = -0.5 = -D.y // Permutations i = detail::mod289(i); vec<4, T, Q> p(detail::permute(detail::permute(detail::permute( i.z + vec<4, T, Q>(T(0), i1.z, i2.z, T(1))) + i.y + vec<4, T, Q>(T(0), i1.y, i2.y, T(1))) + i.x + vec<4, T, Q>(T(0), i1.x, i2.x, T(1)))); // Gradients: 7x7 points over a square, mapped onto an octahedron. // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294) T n_ = static_cast(0.142857142857); // 1.0/7.0 vec<3, T, Q> ns(n_ * vec<3, T, Q>(D.w, D.y, D.z) - vec<3, T, Q>(D.x, D.z, D.x)); vec<4, T, Q> j(p - T(49) * floor(p * ns.z * ns.z)); // mod(p,7*7) vec<4, T, Q> x_(floor(j * ns.z)); vec<4, T, Q> y_(floor(j - T(7) * x_)); // mod(j,N) vec<4, T, Q> x(x_ * ns.x + ns.y); vec<4, T, Q> y(y_ * ns.x + ns.y); vec<4, T, Q> h(T(1) - abs(x) - abs(y)); vec<4, T, Q> b0(x.x, x.y, y.x, y.y); vec<4, T, Q> b1(x.z, x.w, y.z, y.w); // vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0; // vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0; vec<4, T, Q> s0(floor(b0) * T(2) + T(1)); vec<4, T, Q> s1(floor(b1) * T(2) + T(1)); vec<4, T, Q> sh(-step(h, vec<4, T, Q>(0.0))); vec<4, T, Q> a0 = vec<4, T, Q>(b0.x, b0.z, b0.y, b0.w) + vec<4, T, Q>(s0.x, s0.z, s0.y, s0.w) * vec<4, T, Q>(sh.x, sh.x, sh.y, sh.y); vec<4, T, Q> a1 = vec<4, T, Q>(b1.x, b1.z, b1.y, b1.w) + vec<4, T, Q>(s1.x, s1.z, s1.y, s1.w) * vec<4, T, Q>(sh.z, sh.z, sh.w, sh.w); vec<3, T, Q> p0(a0.x, a0.y, h.x); vec<3, T, Q> p1(a0.z, a0.w, h.y); vec<3, T, Q> p2(a1.x, a1.y, h.z); vec<3, T, Q> p3(a1.z, a1.w, h.w); // Normalise gradients vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3))); p0 *= norm.x; p1 *= norm.y; p2 *= norm.z; p3 *= norm.w; // Mix final noise value vec<4, T, Q> m = max(T(0.6) - vec<4, T, Q>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), vec<4, T, Q>(0)); m = m * m; return T(42) * dot(m * m, vec<4, T, Q>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))); } template GLM_FUNC_QUALIFIER T simplex(vec<4, T, Q> const& v) { vec<4, T, Q> const C( 0.138196601125011, // (5 - sqrt(5))/20 G4 0.276393202250021, // 2 * G4 0.414589803375032, // 3 * G4 -0.447213595499958); // -1 + 4 * G4 // (sqrt(5) - 1)/4 = F4, used once below T const F4 = static_cast(0.309016994374947451); // First corner vec<4, T, Q> i = floor(v + dot(v, vec<4, T, Q>(F4))); vec<4, T, Q> x0 = v - i + dot(i, vec<4, T, Q>(C.x)); // Other corners // Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI) vec<4, T, Q> i0; vec<3, T, Q> isX = step(vec<3, T, Q>(x0.y, x0.z, x0.w), vec<3, T, Q>(x0.x)); vec<3, T, Q> isYZ = step(vec<3, T, Q>(x0.z, x0.w, x0.w), vec<3, T, Q>(x0.y, x0.y, x0.z)); // i0.x = dot(isX, vec3(1.0)); //i0.x = isX.x + isX.y + isX.z; //i0.yzw = static_cast(1) - isX; i0 = vec<4, T, Q>(isX.x + isX.y + isX.z, T(1) - isX); // i0.y += dot(isYZ.xy, vec2(1.0)); i0.y += isYZ.x + isYZ.y; //i0.zw += 1.0 - vec<2, T, Q>(isYZ.x, isYZ.y); i0.z += static_cast(1) - isYZ.x; i0.w += static_cast(1) - isYZ.y; i0.z += isYZ.z; i0.w += static_cast(1) - isYZ.z; // i0 now contains the unique values 0,1,2,3 in each channel vec<4, T, Q> i3 = clamp(i0, T(0), T(1)); vec<4, T, Q> i2 = clamp(i0 - T(1), T(0), T(1)); vec<4, T, Q> i1 = clamp(i0 - T(2), T(0), T(1)); // x0 = x0 - 0.0 + 0.0 * C.xxxx // x1 = x0 - i1 + 0.0 * C.xxxx // x2 = x0 - i2 + 0.0 * C.xxxx // x3 = x0 - i3 + 0.0 * C.xxxx // x4 = x0 - 1.0 + 4.0 * C.xxxx vec<4, T, Q> x1 = x0 - i1 + C.x; vec<4, T, Q> x2 = x0 - i2 + C.y; vec<4, T, Q> x3 = x0 - i3 + C.z; vec<4, T, Q> x4 = x0 + C.w; // Permutations i = mod(i, vec<4, T, Q>(289)); T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x); vec<4, T, Q> j1 = detail::permute(detail::permute(detail::permute(detail::permute( i.w + vec<4, T, Q>(i1.w, i2.w, i3.w, T(1))) + i.z + vec<4, T, Q>(i1.z, i2.z, i3.z, T(1))) + i.y + vec<4, T, Q>(i1.y, i2.y, i3.y, T(1))) + i.x + vec<4, T, Q>(i1.x, i2.x, i3.x, T(1))); // Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope // 7*7*6 = 294, which is close to the ring size 17*17 = 289. vec<4, T, Q> ip = vec<4, T, Q>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0)); vec<4, T, Q> p0 = gtc::grad4(j0, ip); vec<4, T, Q> p1 = gtc::grad4(j1.x, ip); vec<4, T, Q> p2 = gtc::grad4(j1.y, ip); vec<4, T, Q> p3 = gtc::grad4(j1.z, ip); vec<4, T, Q> p4 = gtc::grad4(j1.w, ip); // Normalise gradients vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3))); p0 *= norm.x; p1 *= norm.y; p2 *= norm.z; p3 *= norm.w; p4 *= detail::taylorInvSqrt(dot(p4, p4)); // Mix contributions from the five corners vec<3, T, Q> m0 = max(T(0.6) - vec<3, T, Q>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), vec<3, T, Q>(0)); vec<2, T, Q> m1 = max(T(0.6) - vec<2, T, Q>(dot(x3, x3), dot(x4, x4) ), vec<2, T, Q>(0)); m0 = m0 * m0; m1 = m1 * m1; return T(49) * (dot(m0 * m0, vec<3, T, Q>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + dot(m1 * m1, vec<2, T, Q>(dot(p3, x3), dot(p4, x4)))); } }//namespace glm ================================================ FILE: android/src/glm/gtc/packing.hpp ================================================ /// @ref gtc_packing /// @file glm/gtc/packing.hpp /// /// @see core (dependence) /// /// @defgroup gtc_packing GLM_GTC_packing /// @ingroup gtc /// /// Include to use the features of this extension. /// /// This extension provides a set of function to convert vertors to packed /// formats. #pragma once // Dependency: #include "type_precision.hpp" #include "../ext/vector_packing.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_packing extension included") #endif namespace glm { /// @addtogroup gtc_packing /// @{ /// First, converts the normalized floating-point value v into a 8-bit integer value. /// Then, the results are packed into the returned 8-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm1x8: round(clamp(c, 0, +1) * 255.0) /// /// @see gtc_packing /// @see uint16 packUnorm2x8(vec2 const& v) /// @see uint32 packUnorm4x8(vec4 const& v) /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint8 packUnorm1x8(float v); /// Convert a single 8-bit integer to a normalized floating-point value. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm4x8: f / 255.0 /// /// @see gtc_packing /// @see vec2 unpackUnorm2x8(uint16 p) /// @see vec4 unpackUnorm4x8(uint32 p) /// @see GLSL unpackUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackUnorm1x8(uint8 p); /// First, converts each component of the normalized floating-point value v into 8-bit integer values. /// Then, the results are packed into the returned 16-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm2x8: round(clamp(c, 0, +1) * 255.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see gtc_packing /// @see uint8 packUnorm1x8(float const& v) /// @see uint32 packUnorm4x8(vec4 const& v) /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packUnorm2x8(vec2 const& v); /// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit unsigned integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm4x8: f / 255.0 /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see float unpackUnorm1x8(uint8 v) /// @see vec4 unpackUnorm4x8(uint32 p) /// @see GLSL unpackUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 p); /// First, converts the normalized floating-point value v into 8-bit integer value. /// Then, the results are packed into the returned 8-bit unsigned integer. /// /// The conversion to fixed point is done as follows: /// packSnorm1x8: round(clamp(s, -1, +1) * 127.0) /// /// @see gtc_packing /// @see uint16 packSnorm2x8(vec2 const& v) /// @see uint32 packSnorm4x8(vec4 const& v) /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint8 packSnorm1x8(float s); /// First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers. /// Then, the value is converted to a normalized floating-point value to generate the returned scalar. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm1x8: clamp(f / 127.0, -1, +1) /// /// @see gtc_packing /// @see vec2 unpackSnorm2x8(uint16 p) /// @see vec4 unpackSnorm4x8(uint32 p) /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackSnorm1x8(uint8 p); /// First, converts each component of the normalized floating-point value v into 8-bit integer values. /// Then, the results are packed into the returned 16-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm2x8: round(clamp(c, -1, +1) * 127.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see gtc_packing /// @see uint8 packSnorm1x8(float const& v) /// @see uint32 packSnorm4x8(vec4 const& v) /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packSnorm2x8(vec2 const& v); /// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm2x8: clamp(f / 127.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see float unpackSnorm1x8(uint8 p) /// @see vec4 unpackSnorm4x8(uint32 p) /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 p); /// First, converts the normalized floating-point value v into a 16-bit integer value. /// Then, the results are packed into the returned 16-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm1x16: round(clamp(c, 0, +1) * 65535.0) /// /// @see gtc_packing /// @see uint16 packSnorm1x16(float const& v) /// @see uint64 packSnorm4x16(vec4 const& v) /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packUnorm1x16(float v); /// First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers. /// Then, the value is converted to a normalized floating-point value to generate the returned scalar. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm1x16: f / 65535.0 /// /// @see gtc_packing /// @see vec2 unpackUnorm2x16(uint32 p) /// @see vec4 unpackUnorm4x16(uint64 p) /// @see GLSL unpackUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackUnorm1x16(uint16 p); /// First, converts each component of the normalized floating-point value v into 16-bit integer values. /// Then, the results are packed into the returned 64-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm4x16: round(clamp(c, 0, +1) * 65535.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see gtc_packing /// @see uint16 packUnorm1x16(float const& v) /// @see uint32 packUnorm2x16(vec2 const& v) /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint64 packUnorm4x16(vec4 const& v); /// First, unpacks a single 64-bit unsigned integer p into four 16-bit unsigned integers. /// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnormx4x16: f / 65535.0 /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see float unpackUnorm1x16(uint16 p) /// @see vec2 unpackUnorm2x16(uint32 p) /// @see GLSL unpackUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 p); /// First, converts the normalized floating-point value v into 16-bit integer value. /// Then, the results are packed into the returned 16-bit unsigned integer. /// /// The conversion to fixed point is done as follows: /// packSnorm1x8: round(clamp(s, -1, +1) * 32767.0) /// /// @see gtc_packing /// @see uint32 packSnorm2x16(vec2 const& v) /// @see uint64 packSnorm4x16(vec4 const& v) /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packSnorm1x16(float v); /// First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned scalar. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm1x16: clamp(f / 32767.0, -1, +1) /// /// @see gtc_packing /// @see vec2 unpackSnorm2x16(uint32 p) /// @see vec4 unpackSnorm4x16(uint64 p) /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackSnorm1x16(uint16 p); /// First, converts each component of the normalized floating-point value v into 16-bit integer values. /// Then, the results are packed into the returned 64-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm2x8: round(clamp(c, -1, +1) * 32767.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see gtc_packing /// @see uint16 packSnorm1x16(float const& v) /// @see uint32 packSnorm2x16(vec2 const& v) /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint64 packSnorm4x16(vec4 const& v); /// First, unpacks a single 64-bit unsigned integer p into four 16-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm4x16: clamp(f / 32767.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see float unpackSnorm1x16(uint16 p) /// @see vec2 unpackSnorm2x16(uint32 p) /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackSnorm4x16(uint64 p); /// Returns an unsigned integer obtained by converting the components of a floating-point scalar /// to the 16-bit floating-point representation found in the OpenGL Specification, /// and then packing this 16-bit value into a 16-bit unsigned integer. /// /// @see gtc_packing /// @see uint32 packHalf2x16(vec2 const& v) /// @see uint64 packHalf4x16(vec4 const& v) /// @see GLSL packHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packHalf1x16(float v); /// Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into a 16-bit value, /// interpreted as a 16-bit floating-point number according to the OpenGL Specification, /// and converting it to 32-bit floating-point values. /// /// @see gtc_packing /// @see vec2 unpackHalf2x16(uint32 const& v) /// @see vec4 unpackHalf4x16(uint64 const& v) /// @see GLSL unpackHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackHalf1x16(uint16 v); /// Returns an unsigned integer obtained by converting the components of a four-component floating-point vector /// to the 16-bit floating-point representation found in the OpenGL Specification, /// and then packing these four 16-bit values into a 64-bit unsigned integer. /// The first vector component specifies the 16 least-significant bits of the result; /// the forth component specifies the 16 most-significant bits. /// /// @see gtc_packing /// @see uint16 packHalf1x16(float const& v) /// @see uint32 packHalf2x16(vec2 const& v) /// @see GLSL packHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint64 packHalf4x16(vec4 const& v); /// Returns a four-component floating-point vector with components obtained by unpacking a 64-bit unsigned integer into four 16-bit values, /// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, /// and converting them to 32-bit floating-point values. /// The first component of the vector is obtained from the 16 least-significant bits of v; /// the forth component is obtained from the 16 most-significant bits of v. /// /// @see gtc_packing /// @see float unpackHalf1x16(uint16 const& v) /// @see vec2 unpackHalf2x16(uint32 const& v) /// @see GLSL unpackHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 p); /// Returns an unsigned integer obtained by converting the components of a four-component signed integer vector /// to the 10-10-10-2-bit signed integer representation found in the OpenGL Specification, /// and then packing these four values into a 32-bit unsigned integer. /// The first vector component specifies the 10 least-significant bits of the result; /// the forth component specifies the 2 most-significant bits. /// /// @see gtc_packing /// @see uint32 packI3x10_1x2(uvec4 const& v) /// @see uint32 packSnorm3x10_1x2(vec4 const& v) /// @see uint32 packUnorm3x10_1x2(vec4 const& v) /// @see ivec4 unpackI3x10_1x2(uint32 const& p) GLM_FUNC_DECL uint32 packI3x10_1x2(ivec4 const& v); /// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit signed integers. /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packU3x10_1x2(uvec4 const& v) /// @see vec4 unpackSnorm3x10_1x2(uint32 const& p); /// @see uvec4 unpackI3x10_1x2(uint32 const& p); GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 p); /// Returns an unsigned integer obtained by converting the components of a four-component unsigned integer vector /// to the 10-10-10-2-bit unsigned integer representation found in the OpenGL Specification, /// and then packing these four values into a 32-bit unsigned integer. /// The first vector component specifies the 10 least-significant bits of the result; /// the forth component specifies the 2 most-significant bits. /// /// @see gtc_packing /// @see uint32 packI3x10_1x2(ivec4 const& v) /// @see uint32 packSnorm3x10_1x2(vec4 const& v) /// @see uint32 packUnorm3x10_1x2(vec4 const& v) /// @see ivec4 unpackU3x10_1x2(uint32 const& p) GLM_FUNC_DECL uint32 packU3x10_1x2(uvec4 const& v); /// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit unsigned integers. /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packU3x10_1x2(uvec4 const& v) /// @see vec4 unpackSnorm3x10_1x2(uint32 const& p); /// @see uvec4 unpackI3x10_1x2(uint32 const& p); GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 p); /// First, converts the first three components of the normalized floating-point value v into 10-bit signed integer values. /// Then, converts the forth component of the normalized floating-point value v into 2-bit signed integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm3x10_1x2(xyz): round(clamp(c, -1, +1) * 511.0) /// packSnorm3x10_1x2(w): round(clamp(c, -1, +1) * 1.0) /// /// The first vector component specifies the 10 least-significant bits of the result; /// the forth component specifies the 2 most-significant bits. /// /// @see gtc_packing /// @see vec4 unpackSnorm3x10_1x2(uint32 const& p) /// @see uint32 packUnorm3x10_1x2(vec4 const& v) /// @see uint32 packU3x10_1x2(uvec4 const& v) /// @see uint32 packI3x10_1x2(ivec4 const& v) GLM_FUNC_DECL uint32 packSnorm3x10_1x2(vec4 const& v); /// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm3x10_1x2(xyz): clamp(f / 511.0, -1, +1) /// unpackSnorm3x10_1x2(w): clamp(f / 511.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packSnorm3x10_1x2(vec4 const& v) /// @see vec4 unpackUnorm3x10_1x2(uint32 const& p)) /// @see uvec4 unpackI3x10_1x2(uint32 const& p) /// @see uvec4 unpackU3x10_1x2(uint32 const& p) GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 p); /// First, converts the first three components of the normalized floating-point value v into 10-bit unsigned integer values. /// Then, converts the forth component of the normalized floating-point value v into 2-bit signed uninteger values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm3x10_1x2(xyz): round(clamp(c, 0, +1) * 1023.0) /// packUnorm3x10_1x2(w): round(clamp(c, 0, +1) * 3.0) /// /// The first vector component specifies the 10 least-significant bits of the result; /// the forth component specifies the 2 most-significant bits. /// /// @see gtc_packing /// @see vec4 unpackUnorm3x10_1x2(uint32 const& p) /// @see uint32 packUnorm3x10_1x2(vec4 const& v) /// @see uint32 packU3x10_1x2(uvec4 const& v) /// @see uint32 packI3x10_1x2(ivec4 const& v) GLM_FUNC_DECL uint32 packUnorm3x10_1x2(vec4 const& v); /// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm3x10_1x2(xyz): clamp(f / 1023.0, 0, +1) /// unpackSnorm3x10_1x2(w): clamp(f / 3.0, 0, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packSnorm3x10_1x2(vec4 const& v) /// @see vec4 unpackInorm3x10_1x2(uint32 const& p)) /// @see uvec4 unpackI3x10_1x2(uint32 const& p) /// @see uvec4 unpackU3x10_1x2(uint32 const& p) GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 p); /// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values. /// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The first vector component specifies the 11 least-significant bits of the result; /// the last component specifies the 10 most-significant bits. /// /// @see gtc_packing /// @see vec3 unpackF2x11_1x10(uint32 const& p) GLM_FUNC_DECL uint32 packF2x11_1x10(vec3 const& v); /// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value . /// Then, each component is converted to a normalized floating-point value to generate the returned three-component vector. /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packF2x11_1x10(vec3 const& v) GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 p); /// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values. /// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The first vector component specifies the 11 least-significant bits of the result; /// the last component specifies the 10 most-significant bits. /// /// packF3x9_E1x5 allows encoding into RGBE / RGB9E5 format /// /// @see gtc_packing /// @see vec3 unpackF3x9_E1x5(uint32 const& p) GLM_FUNC_DECL uint32 packF3x9_E1x5(vec3 const& v); /// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value . /// Then, each component is converted to a normalized floating-point value to generate the returned three-component vector. /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// unpackF3x9_E1x5 allows decoding RGBE / RGB9E5 data /// /// @see gtc_packing /// @see uint32 packF3x9_E1x5(vec3 const& v) GLM_FUNC_DECL vec3 unpackF3x9_E1x5(uint32 p); /// Returns an unsigned integer vector obtained by converting the components of a floating-point vector /// to the 16-bit floating-point representation found in the OpenGL Specification. /// The first vector component specifies the 16 least-significant bits of the result; /// the forth component specifies the 16 most-significant bits. /// /// @see gtc_packing /// @see vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& p) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template GLM_FUNC_DECL vec<4, T, Q> packRGBM(vec<3, T, Q> const& rgb); /// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values. /// The first component of the vector is obtained from the 16 least-significant bits of v; /// the forth component is obtained from the 16 most-significant bits of v. /// /// @see gtc_packing /// @see vec<4, T, Q> packRGBM(vec<3, float, Q> const& v) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template GLM_FUNC_DECL vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& rgbm); /// Returns an unsigned integer vector obtained by converting the components of a floating-point vector /// to the 16-bit floating-point representation found in the OpenGL Specification. /// The first vector component specifies the 16 least-significant bits of the result; /// the forth component specifies the 16 most-significant bits. /// /// @see gtc_packing /// @see vec unpackHalf(vec const& p) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template GLM_FUNC_DECL vec packHalf(vec const& v); /// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values. /// The first component of the vector is obtained from the 16 least-significant bits of v; /// the forth component is obtained from the 16 most-significant bits of v. /// /// @see gtc_packing /// @see vec packHalf(vec const& v) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template GLM_FUNC_DECL vec unpackHalf(vec const& p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec unpackUnorm(vec const& p); template GLM_FUNC_DECL vec packUnorm(vec const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see vec packUnorm(vec const& v) template GLM_FUNC_DECL vec unpackUnorm(vec const& v); /// Convert each component of the normalized floating-point vector into signed integer values. /// /// @see gtc_packing /// @see vec unpackSnorm(vec const& p); template GLM_FUNC_DECL vec packSnorm(vec const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see vec packSnorm(vec const& v) template GLM_FUNC_DECL vec unpackSnorm(vec const& v); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec2 unpackUnorm2x4(uint8 p) GLM_FUNC_DECL uint8 packUnorm2x4(vec2 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint8 packUnorm2x4(vec2 const& v) GLM_FUNC_DECL vec2 unpackUnorm2x4(uint8 p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec4 unpackUnorm4x4(uint16 p) GLM_FUNC_DECL uint16 packUnorm4x4(vec4 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint16 packUnorm4x4(vec4 const& v) GLM_FUNC_DECL vec4 unpackUnorm4x4(uint16 p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec3 unpackUnorm1x5_1x6_1x5(uint16 p) GLM_FUNC_DECL uint16 packUnorm1x5_1x6_1x5(vec3 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint16 packUnorm1x5_1x6_1x5(vec3 const& v) GLM_FUNC_DECL vec3 unpackUnorm1x5_1x6_1x5(uint16 p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec4 unpackUnorm3x5_1x1(uint16 p) GLM_FUNC_DECL uint16 packUnorm3x5_1x1(vec4 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint16 packUnorm3x5_1x1(vec4 const& v) GLM_FUNC_DECL vec4 unpackUnorm3x5_1x1(uint16 p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec3 unpackUnorm2x3_1x2(uint8 p) GLM_FUNC_DECL uint8 packUnorm2x3_1x2(vec3 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint8 packUnorm2x3_1x2(vec3 const& v) GLM_FUNC_DECL vec3 unpackUnorm2x3_1x2(uint8 p); /// Convert each component from an integer vector into a packed integer. /// /// @see gtc_packing /// @see i8vec2 unpackInt2x8(int16 p) GLM_FUNC_DECL int16 packInt2x8(i8vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int16 packInt2x8(i8vec2 const& v) GLM_FUNC_DECL i8vec2 unpackInt2x8(int16 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u8vec2 unpackInt2x8(uint16 p) GLM_FUNC_DECL uint16 packUint2x8(u8vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see uint16 packInt2x8(u8vec2 const& v) GLM_FUNC_DECL u8vec2 unpackUint2x8(uint16 p); /// Convert each component from an integer vector into a packed integer. /// /// @see gtc_packing /// @see i8vec4 unpackInt4x8(int32 p) GLM_FUNC_DECL int32 packInt4x8(i8vec4 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int32 packInt2x8(i8vec4 const& v) GLM_FUNC_DECL i8vec4 unpackInt4x8(int32 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u8vec4 unpackUint4x8(uint32 p) GLM_FUNC_DECL uint32 packUint4x8(u8vec4 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see uint32 packUint4x8(u8vec2 const& v) GLM_FUNC_DECL u8vec4 unpackUint4x8(uint32 p); /// Convert each component from an integer vector into a packed integer. /// /// @see gtc_packing /// @see i16vec2 unpackInt2x16(int p) GLM_FUNC_DECL int packInt2x16(i16vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int packInt2x16(i16vec2 const& v) GLM_FUNC_DECL i16vec2 unpackInt2x16(int p); /// Convert each component from an integer vector into a packed integer. /// /// @see gtc_packing /// @see i16vec4 unpackInt4x16(int64 p) GLM_FUNC_DECL int64 packInt4x16(i16vec4 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int64 packInt4x16(i16vec4 const& v) GLM_FUNC_DECL i16vec4 unpackInt4x16(int64 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u16vec2 unpackUint2x16(uint p) GLM_FUNC_DECL uint packUint2x16(u16vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see uint packUint2x16(u16vec2 const& v) GLM_FUNC_DECL u16vec2 unpackUint2x16(uint p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u16vec4 unpackUint4x16(uint64 p) GLM_FUNC_DECL uint64 packUint4x16(u16vec4 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see uint64 packUint4x16(u16vec4 const& v) GLM_FUNC_DECL u16vec4 unpackUint4x16(uint64 p); /// Convert each component from an integer vector into a packed integer. /// /// @see gtc_packing /// @see i32vec2 unpackInt2x32(int p) GLM_FUNC_DECL int64 packInt2x32(i32vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int packInt2x16(i32vec2 const& v) GLM_FUNC_DECL i32vec2 unpackInt2x32(int64 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u32vec2 unpackUint2x32(int p) GLM_FUNC_DECL uint64 packUint2x32(u32vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int packUint2x16(u32vec2 const& v) GLM_FUNC_DECL u32vec2 unpackUint2x32(uint64 p); /// @} }// namespace glm #include "packing.inl" ================================================ FILE: android/src/glm/gtc/packing.inl ================================================ /// @ref gtc_packing #include "../ext/scalar_relational.hpp" #include "../ext/vector_relational.hpp" #include "../common.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../detail/type_half.hpp" #include #include namespace glm{ namespace detail { GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 f) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x00007c00 => 00000000 00000000 01111100 00000000 // 0x000003ff => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((f >> 16) & 0x8000) | // sign ((((f & 0x7f800000) - 0x38000000) >> 13) & 0x7c00) | // exponential ((f >> 13) & 0x03ff); // Mantissa } GLM_FUNC_QUALIFIER glm::uint32 float2packed11(glm::uint32 f) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x000007c0 => 00000000 00000000 00000111 11000000 // 0x00007c00 => 00000000 00000000 01111100 00000000 // 0x000003ff => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((((f & 0x7f800000) - 0x38000000) >> 17) & 0x07c0) | // exponential ((f >> 17) & 0x003f); // Mantissa } GLM_FUNC_QUALIFIER glm::uint32 packed11ToFloat(glm::uint32 p) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x000007c0 => 00000000 00000000 00000111 11000000 // 0x00007c00 => 00000000 00000000 01111100 00000000 // 0x000003ff => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((((p & 0x07c0) << 17) + 0x38000000) & 0x7f800000) | // exponential ((p & 0x003f) << 17); // Mantissa } GLM_FUNC_QUALIFIER glm::uint32 float2packed10(glm::uint32 f) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x0000001F => 00000000 00000000 00000000 00011111 // 0x0000003F => 00000000 00000000 00000000 00111111 // 0x000003E0 => 00000000 00000000 00000011 11100000 // 0x000007C0 => 00000000 00000000 00000111 11000000 // 0x00007C00 => 00000000 00000000 01111100 00000000 // 0x000003FF => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((((f & 0x7f800000) - 0x38000000) >> 18) & 0x03E0) | // exponential ((f >> 18) & 0x001f); // Mantissa } GLM_FUNC_QUALIFIER glm::uint32 packed10ToFloat(glm::uint32 p) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x0000001F => 00000000 00000000 00000000 00011111 // 0x0000003F => 00000000 00000000 00000000 00111111 // 0x000003E0 => 00000000 00000000 00000011 11100000 // 0x000007C0 => 00000000 00000000 00000111 11000000 // 0x00007C00 => 00000000 00000000 01111100 00000000 // 0x000003FF => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((((p & 0x03E0) << 18) + 0x38000000) & 0x7f800000) | // exponential ((p & 0x001f) << 18); // Mantissa } GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint h) { return ((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13); } GLM_FUNC_QUALIFIER glm::uint floatTo11bit(float x) { if(x == 0.0f) return 0u; else if(glm::isnan(x)) return ~0u; else if(glm::isinf(x)) return 0x1Fu << 6u; uint Pack = 0u; memcpy(&Pack, &x, sizeof(Pack)); return float2packed11(Pack); } GLM_FUNC_QUALIFIER float packed11bitToFloat(glm::uint x) { if(x == 0) return 0.0f; else if(x == ((1 << 11) - 1)) return ~0;//NaN else if(x == (0x1f << 6)) return ~0;//Inf uint Result = packed11ToFloat(x); float Temp = 0; memcpy(&Temp, &Result, sizeof(Temp)); return Temp; } GLM_FUNC_QUALIFIER glm::uint floatTo10bit(float x) { if(x == 0.0f) return 0u; else if(glm::isnan(x)) return ~0u; else if(glm::isinf(x)) return 0x1Fu << 5u; uint Pack = 0; memcpy(&Pack, &x, sizeof(Pack)); return float2packed10(Pack); } GLM_FUNC_QUALIFIER float packed10bitToFloat(glm::uint x) { if(x == 0) return 0.0f; else if(x == ((1 << 10) - 1)) return ~0;//NaN else if(x == (0x1f << 5)) return ~0;//Inf uint Result = packed10ToFloat(x); float Temp = 0; memcpy(&Temp, &Result, sizeof(Temp)); return Temp; } // GLM_FUNC_QUALIFIER glm::uint f11_f11_f10(float x, float y, float z) // { // return ((floatTo11bit(x) & ((1 << 11) - 1)) << 0) | ((floatTo11bit(y) & ((1 << 11) - 1)) << 11) | ((floatTo10bit(z) & ((1 << 10) - 1)) << 22); // } union u3u3u2 { struct { uint x : 3; uint y : 3; uint z : 2; } data; uint8 pack; }; union u4u4 { struct { uint x : 4; uint y : 4; } data; uint8 pack; }; union u4u4u4u4 { struct { uint x : 4; uint y : 4; uint z : 4; uint w : 4; } data; uint16 pack; }; union u5u6u5 { struct { uint x : 5; uint y : 6; uint z : 5; } data; uint16 pack; }; union u5u5u5u1 { struct { uint x : 5; uint y : 5; uint z : 5; uint w : 1; } data; uint16 pack; }; union u10u10u10u2 { struct { uint x : 10; uint y : 10; uint z : 10; uint w : 2; } data; uint32 pack; }; union i10i10i10i2 { struct { int x : 10; int y : 10; int z : 10; int w : 2; } data; uint32 pack; }; union u9u9u9e5 { struct { uint x : 9; uint y : 9; uint z : 9; uint w : 5; } data; uint32 pack; }; template struct compute_half {}; template struct compute_half<1, Q> { GLM_FUNC_QUALIFIER static vec<1, uint16, Q> pack(vec<1, float, Q> const& v) { int16 const Unpack(detail::toFloat16(v.x)); u16vec1 Packed; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER static vec<1, float, Q> unpack(vec<1, uint16, Q> const& v) { i16vec1 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec<1, float, Q>(detail::toFloat32(v.x)); } }; template struct compute_half<2, Q> { GLM_FUNC_QUALIFIER static vec<2, uint16, Q> pack(vec<2, float, Q> const& v) { vec<2, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y)); u16vec2 Packed; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER static vec<2, float, Q> unpack(vec<2, uint16, Q> const& v) { i16vec2 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec<2, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y)); } }; template struct compute_half<3, Q> { GLM_FUNC_QUALIFIER static vec<3, uint16, Q> pack(vec<3, float, Q> const& v) { vec<3, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z)); u16vec3 Packed; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER static vec<3, float, Q> unpack(vec<3, uint16, Q> const& v) { i16vec3 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec<3, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z)); } }; template struct compute_half<4, Q> { GLM_FUNC_QUALIFIER static vec<4, uint16, Q> pack(vec<4, float, Q> const& v) { vec<4, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w)); u16vec4 Packed; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER static vec<4, float, Q> unpack(vec<4, uint16, Q> const& v) { i16vec4 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec<4, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z), detail::toFloat32(v.w)); } }; }//namespace detail GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float v) { return static_cast(round(clamp(v, 0.0f, 1.0f) * 255.0f)); } GLM_FUNC_QUALIFIER float unpackUnorm1x8(uint8 p) { float const Unpack(p); return Unpack * static_cast(0.0039215686274509803921568627451); // 1 / 255 } GLM_FUNC_QUALIFIER uint16 packUnorm2x8(vec2 const& v) { u8vec2 const Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f)); uint16 Unpack = 0; memcpy(&Unpack, &Topack, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER vec2 unpackUnorm2x8(uint16 p) { u8vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return vec2(Unpack) * float(0.0039215686274509803921568627451); // 1 / 255 } GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float v) { int8 const Topack(static_cast(round(clamp(v ,-1.0f, 1.0f) * 127.0f))); uint8 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER float unpackSnorm1x8(uint8 p) { int8 Unpack = 0; memcpy(&Unpack, &p, sizeof(Unpack)); return clamp( static_cast(Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint16 packSnorm2x8(vec2 const& v) { i8vec2 const Topack(round(clamp(v, -1.0f, 1.0f) * 127.0f)); uint16 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER vec2 unpackSnorm2x8(uint16 p) { i8vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return clamp( vec2(Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint16 packUnorm1x16(float s) { return static_cast(round(clamp(s, 0.0f, 1.0f) * 65535.0f)); } GLM_FUNC_QUALIFIER float unpackUnorm1x16(uint16 p) { float const Unpack(p); return Unpack * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0 } GLM_FUNC_QUALIFIER uint64 packUnorm4x16(vec4 const& v) { u16vec4 const Topack(round(clamp(v , 0.0f, 1.0f) * 65535.0f)); uint64 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER vec4 unpackUnorm4x16(uint64 p) { u16vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return vec4(Unpack) * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0 } GLM_FUNC_QUALIFIER uint16 packSnorm1x16(float v) { int16 const Topack = static_cast(round(clamp(v ,-1.0f, 1.0f) * 32767.0f)); uint16 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER float unpackSnorm1x16(uint16 p) { int16 Unpack = 0; memcpy(&Unpack, &p, sizeof(Unpack)); return clamp( static_cast(Unpack) * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f, -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint64 packSnorm4x16(vec4 const& v) { i16vec4 const Topack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f)); uint64 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER vec4 unpackSnorm4x16(uint64 p) { i16vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return clamp( vec4(Unpack) * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f, -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint16 packHalf1x16(float v) { int16 const Topack(detail::toFloat16(v)); uint16 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER float unpackHalf1x16(uint16 v) { int16 Unpack = 0; memcpy(&Unpack, &v, sizeof(Unpack)); return detail::toFloat32(Unpack); } GLM_FUNC_QUALIFIER uint64 packHalf4x16(glm::vec4 const& v) { i16vec4 const Unpack( detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w)); uint64 Packed = 0; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER glm::vec4 unpackHalf4x16(uint64 v) { i16vec4 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec4( detail::toFloat32(Unpack.x), detail::toFloat32(Unpack.y), detail::toFloat32(Unpack.z), detail::toFloat32(Unpack.w)); } GLM_FUNC_QUALIFIER uint32 packI3x10_1x2(ivec4 const& v) { detail::i10i10i10i2 Result; Result.data.x = v.x; Result.data.y = v.y; Result.data.z = v.z; Result.data.w = v.w; return Result.pack; } GLM_FUNC_QUALIFIER ivec4 unpackI3x10_1x2(uint32 v) { detail::i10i10i10i2 Unpack; Unpack.pack = v; return ivec4( Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w); } GLM_FUNC_QUALIFIER uint32 packU3x10_1x2(uvec4 const& v) { detail::u10u10u10u2 Result; Result.data.x = v.x; Result.data.y = v.y; Result.data.z = v.z; Result.data.w = v.w; return Result.pack; } GLM_FUNC_QUALIFIER uvec4 unpackU3x10_1x2(uint32 v) { detail::u10u10u10u2 Unpack; Unpack.pack = v; return uvec4( Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w); } GLM_FUNC_QUALIFIER uint32 packSnorm3x10_1x2(vec4 const& v) { ivec4 const Pack(round(clamp(v,-1.0f, 1.0f) * vec4(511.f, 511.f, 511.f, 1.f))); detail::i10i10i10i2 Result; Result.data.x = Pack.x; Result.data.y = Pack.y; Result.data.z = Pack.z; Result.data.w = Pack.w; return Result.pack; } GLM_FUNC_QUALIFIER vec4 unpackSnorm3x10_1x2(uint32 v) { detail::i10i10i10i2 Unpack; Unpack.pack = v; vec4 const Result(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w); return clamp(Result * vec4(1.f / 511.f, 1.f / 511.f, 1.f / 511.f, 1.f), -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint32 packUnorm3x10_1x2(vec4 const& v) { uvec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec4(1023.f, 1023.f, 1023.f, 3.f))); detail::u10u10u10u2 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; Result.data.w = Unpack.w; return Result.pack; } GLM_FUNC_QUALIFIER vec4 unpackUnorm3x10_1x2(uint32 v) { vec4 const ScaleFactors(1.0f / 1023.f, 1.0f / 1023.f, 1.0f / 1023.f, 1.0f / 3.f); detail::u10u10u10u2 Unpack; Unpack.pack = v; return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactors; } GLM_FUNC_QUALIFIER uint32 packF2x11_1x10(vec3 const& v) { return ((detail::floatTo11bit(v.x) & ((1 << 11) - 1)) << 0) | ((detail::floatTo11bit(v.y) & ((1 << 11) - 1)) << 11) | ((detail::floatTo10bit(v.z) & ((1 << 10) - 1)) << 22); } GLM_FUNC_QUALIFIER vec3 unpackF2x11_1x10(uint32 v) { return vec3( detail::packed11bitToFloat(v >> 0), detail::packed11bitToFloat(v >> 11), detail::packed10bitToFloat(v >> 22)); } GLM_FUNC_QUALIFIER uint32 packF3x9_E1x5(vec3 const& v) { float const SharedExpMax = (pow(2.0f, 9.0f - 1.0f) / pow(2.0f, 9.0f)) * pow(2.0f, 31.f - 15.f); vec3 const Color = clamp(v, 0.0f, SharedExpMax); float const MaxColor = max(Color.x, max(Color.y, Color.z)); float const ExpSharedP = max(-15.f - 1.f, floor(log2(MaxColor))) + 1.0f + 15.f; float const MaxShared = floor(MaxColor / pow(2.0f, (ExpSharedP - 15.f - 9.f)) + 0.5f); float const ExpShared = equal(MaxShared, pow(2.0f, 9.0f), epsilon()) ? ExpSharedP + 1.0f : ExpSharedP; uvec3 const ColorComp(floor(Color / pow(2.f, (ExpShared - 15.f - 9.f)) + 0.5f)); detail::u9u9u9e5 Unpack; Unpack.data.x = ColorComp.x; Unpack.data.y = ColorComp.y; Unpack.data.z = ColorComp.z; Unpack.data.w = uint(ExpShared); return Unpack.pack; } GLM_FUNC_QUALIFIER vec3 unpackF3x9_E1x5(uint32 v) { detail::u9u9u9e5 Unpack; Unpack.pack = v; return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * pow(2.0f, Unpack.data.w - 15.f - 9.f); } // Based on Brian Karis http://graphicrants.blogspot.fr/2009/04/rgbm-color-encoding.html template GLM_FUNC_QUALIFIER vec<4, T, Q> packRGBM(vec<3, T, Q> const& rgb) { vec<3, T, Q> const Color(rgb * static_cast(1.0 / 6.0)); T Alpha = clamp(max(max(Color.x, Color.y), max(Color.z, static_cast(1e-6))), static_cast(0), static_cast(1)); Alpha = ceil(Alpha * static_cast(255.0)) / static_cast(255.0); return vec<4, T, Q>(Color / Alpha, Alpha); } template GLM_FUNC_QUALIFIER vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& rgbm) { return vec<3, T, Q>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast(6); } template GLM_FUNC_QUALIFIER vec packHalf(vec const& v) { return detail::compute_half::pack(v); } template GLM_FUNC_QUALIFIER vec unpackHalf(vec const& v) { return detail::compute_half::unpack(v); } template GLM_FUNC_QUALIFIER vec packUnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return vec(round(clamp(v, static_cast(0), static_cast(1)) * static_cast(std::numeric_limits::max()))); } template GLM_FUNC_QUALIFIER vec unpackUnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return vec(v) * (static_cast(1) / static_cast(std::numeric_limits::max())); } template GLM_FUNC_QUALIFIER vec packSnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return vec(round(clamp(v , static_cast(-1), static_cast(1)) * static_cast(std::numeric_limits::max()))); } template GLM_FUNC_QUALIFIER vec unpackSnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return clamp(vec(v) * (static_cast(1) / static_cast(std::numeric_limits::max())), static_cast(-1), static_cast(1)); } GLM_FUNC_QUALIFIER uint8 packUnorm2x4(vec2 const& v) { u32vec2 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f)); detail::u4u4 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; return Result.pack; } GLM_FUNC_QUALIFIER vec2 unpackUnorm2x4(uint8 v) { float const ScaleFactor(1.f / 15.f); detail::u4u4 Unpack; Unpack.pack = v; return vec2(Unpack.data.x, Unpack.data.y) * ScaleFactor; } GLM_FUNC_QUALIFIER uint16 packUnorm4x4(vec4 const& v) { u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f)); detail::u4u4u4u4 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; Result.data.w = Unpack.w; return Result.pack; } GLM_FUNC_QUALIFIER vec4 unpackUnorm4x4(uint16 v) { float const ScaleFactor(1.f / 15.f); detail::u4u4u4u4 Unpack; Unpack.pack = v; return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor; } GLM_FUNC_QUALIFIER uint16 packUnorm1x5_1x6_1x5(vec3 const& v) { u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(31.f, 63.f, 31.f))); detail::u5u6u5 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; return Result.pack; } GLM_FUNC_QUALIFIER vec3 unpackUnorm1x5_1x6_1x5(uint16 v) { vec3 const ScaleFactor(1.f / 31.f, 1.f / 63.f, 1.f / 31.f); detail::u5u6u5 Unpack; Unpack.pack = v; return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor; } GLM_FUNC_QUALIFIER uint16 packUnorm3x5_1x1(vec4 const& v) { u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec4(31.f, 31.f, 31.f, 1.f))); detail::u5u5u5u1 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; Result.data.w = Unpack.w; return Result.pack; } GLM_FUNC_QUALIFIER vec4 unpackUnorm3x5_1x1(uint16 v) { vec4 const ScaleFactor(1.f / 31.f, 1.f / 31.f, 1.f / 31.f, 1.f); detail::u5u5u5u1 Unpack; Unpack.pack = v; return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor; } GLM_FUNC_QUALIFIER uint8 packUnorm2x3_1x2(vec3 const& v) { u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(7.f, 7.f, 3.f))); detail::u3u3u2 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; return Result.pack; } GLM_FUNC_QUALIFIER vec3 unpackUnorm2x3_1x2(uint8 v) { vec3 const ScaleFactor(1.f / 7.f, 1.f / 7.f, 1.f / 3.f); detail::u3u3u2 Unpack; Unpack.pack = v; return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor; } GLM_FUNC_QUALIFIER int16 packInt2x8(i8vec2 const& v) { int16 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i8vec2 unpackInt2x8(int16 p) { i8vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint16 packUint2x8(u8vec2 const& v) { uint16 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u8vec2 unpackUint2x8(uint16 p) { u8vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER int32 packInt4x8(i8vec4 const& v) { int32 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i8vec4 unpackInt4x8(int32 p) { i8vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint32 packUint4x8(u8vec4 const& v) { uint32 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u8vec4 unpackUint4x8(uint32 p) { u8vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER int packInt2x16(i16vec2 const& v) { int Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i16vec2 unpackInt2x16(int p) { i16vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER int64 packInt4x16(i16vec4 const& v) { int64 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i16vec4 unpackInt4x16(int64 p) { i16vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint packUint2x16(u16vec2 const& v) { uint Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u16vec2 unpackUint2x16(uint p) { u16vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint64 packUint4x16(u16vec4 const& v) { uint64 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u16vec4 unpackUint4x16(uint64 p) { u16vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER int64 packInt2x32(i32vec2 const& v) { int64 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i32vec2 unpackInt2x32(int64 p) { i32vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint64 packUint2x32(u32vec2 const& v) { uint64 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u32vec2 unpackUint2x32(uint64 p) { u32vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } }//namespace glm ================================================ FILE: android/src/glm/gtc/quaternion.hpp ================================================ /// @ref gtc_quaternion /// @file glm/gtc/quaternion.hpp /// /// @see core (dependence) /// @see gtc_constants (dependence) /// /// @defgroup gtc_quaternion GLM_GTC_quaternion /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines a templated quaternion type and several quaternion operations. #pragma once // Dependency: #include "../gtc/constants.hpp" #include "../gtc/matrix_transform.hpp" #include "../ext/vector_relational.hpp" #include "../ext/quaternion_common.hpp" #include "../ext/quaternion_float.hpp" #include "../ext/quaternion_float_precision.hpp" #include "../ext/quaternion_double.hpp" #include "../ext/quaternion_double_precision.hpp" #include "../ext/quaternion_relational.hpp" #include "../ext/quaternion_geometric.hpp" #include "../ext/quaternion_trigonometric.hpp" #include "../ext/quaternion_transform.hpp" #include "../detail/type_mat3x3.hpp" #include "../detail/type_mat4x4.hpp" #include "../detail/type_vec3.hpp" #include "../detail/type_vec4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_quaternion extension included") #endif namespace glm { /// @addtogroup gtc_quaternion /// @{ /// Returns euler angles, pitch as x, yaw as y, roll as z. /// The result is expressed in radians. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<3, T, Q> eulerAngles(qua const& x); /// Returns roll value of euler angles expressed in radians. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL T roll(qua const& x); /// Returns pitch value of euler angles expressed in radians. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL T pitch(qua const& x); /// Returns yaw value of euler angles expressed in radians. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL T yaw(qua const& x); /// Converts a quaternion to a 3 * 3 matrix. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL mat<3, 3, T, Q> mat3_cast(qua const& x); /// Converts a quaternion to a 4 * 4 matrix. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL mat<4, 4, T, Q> mat4_cast(qua const& x); /// Converts a pure rotation 3 * 3 matrix to a quaternion. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL qua quat_cast(mat<3, 3, T, Q> const& x); /// Converts a pure rotation 4 * 4 matrix to a quaternion. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL qua quat_cast(mat<4, 4, T, Q> const& x); /// Returns the component-wise comparison result of x < y. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_quaternion_relational template GLM_FUNC_DECL vec<4, bool, Q> lessThan(qua const& x, qua const& y); /// Returns the component-wise comparison of result x <= y. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_quaternion_relational template GLM_FUNC_DECL vec<4, bool, Q> lessThanEqual(qua const& x, qua const& y); /// Returns the component-wise comparison of result x > y. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_quaternion_relational template GLM_FUNC_DECL vec<4, bool, Q> greaterThan(qua const& x, qua const& y); /// Returns the component-wise comparison of result x >= y. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_quaternion_relational template GLM_FUNC_DECL vec<4, bool, Q> greaterThanEqual(qua const& x, qua const& y); /// Build a look at quaternion based on the default handedness. /// /// @param direction Desired forward direction. Needs to be normalized. /// @param up Up vector, how the capture is oriented. Typically (0, 1, 0). template GLM_FUNC_DECL qua quatLookAt( vec<3, T, Q> const& direction, vec<3, T, Q> const& up); /// Build a right-handed look at quaternion. /// /// @param direction Desired forward direction onto which the -z-axis gets mapped. Needs to be normalized. /// @param up Up vector, how the capture is oriented. Typically (0, 1, 0). template GLM_FUNC_DECL qua quatLookAtRH( vec<3, T, Q> const& direction, vec<3, T, Q> const& up); /// Build a left-handed look at quaternion. /// /// @param direction Desired forward direction onto which the +z-axis gets mapped. Needs to be normalized. /// @param up Up vector, how the capture is oriented. Typically (0, 1, 0). template GLM_FUNC_DECL qua quatLookAtLH( vec<3, T, Q> const& direction, vec<3, T, Q> const& up); /// @} } //namespace glm #include "quaternion.inl" ================================================ FILE: android/src/glm/gtc/quaternion.inl ================================================ #include "../trigonometric.hpp" #include "../geometric.hpp" #include "../exponential.hpp" #include "epsilon.hpp" #include namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> eulerAngles(qua const& x) { return vec<3, T, Q>(pitch(x), yaw(x), roll(x)); } template GLM_FUNC_QUALIFIER T roll(qua const& q) { return static_cast(atan(static_cast(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z)); } template GLM_FUNC_QUALIFIER T pitch(qua const& q) { //return T(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z)); T const y = static_cast(2) * (q.y * q.z + q.w * q.x); T const x = q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z; if(all(equal(vec<2, T, Q>(x, y), vec<2, T, Q>(0), epsilon()))) //avoid atan2(0,0) - handle singularity - Matiis return static_cast(static_cast(2) * atan(q.x, q.w)); return static_cast(atan(y, x)); } template GLM_FUNC_QUALIFIER T yaw(qua const& q) { return asin(clamp(static_cast(-2) * (q.x * q.z - q.w * q.y), static_cast(-1), static_cast(1))); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat3_cast(qua const& q) { mat<3, 3, T, Q> Result(T(1)); T qxx(q.x * q.x); T qyy(q.y * q.y); T qzz(q.z * q.z); T qxz(q.x * q.z); T qxy(q.x * q.y); T qyz(q.y * q.z); T qwx(q.w * q.x); T qwy(q.w * q.y); T qwz(q.w * q.z); Result[0][0] = T(1) - T(2) * (qyy + qzz); Result[0][1] = T(2) * (qxy + qwz); Result[0][2] = T(2) * (qxz - qwy); Result[1][0] = T(2) * (qxy - qwz); Result[1][1] = T(1) - T(2) * (qxx + qzz); Result[1][2] = T(2) * (qyz + qwx); Result[2][0] = T(2) * (qxz + qwy); Result[2][1] = T(2) * (qyz - qwx); Result[2][2] = T(1) - T(2) * (qxx + qyy); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat4_cast(qua const& q) { return mat<4, 4, T, Q>(mat3_cast(q)); } template GLM_FUNC_QUALIFIER qua quat_cast(mat<3, 3, T, Q> const& m) { T fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2]; T fourYSquaredMinus1 = m[1][1] - m[0][0] - m[2][2]; T fourZSquaredMinus1 = m[2][2] - m[0][0] - m[1][1]; T fourWSquaredMinus1 = m[0][0] + m[1][1] + m[2][2]; int biggestIndex = 0; T fourBiggestSquaredMinus1 = fourWSquaredMinus1; if(fourXSquaredMinus1 > fourBiggestSquaredMinus1) { fourBiggestSquaredMinus1 = fourXSquaredMinus1; biggestIndex = 1; } if(fourYSquaredMinus1 > fourBiggestSquaredMinus1) { fourBiggestSquaredMinus1 = fourYSquaredMinus1; biggestIndex = 2; } if(fourZSquaredMinus1 > fourBiggestSquaredMinus1) { fourBiggestSquaredMinus1 = fourZSquaredMinus1; biggestIndex = 3; } T biggestVal = sqrt(fourBiggestSquaredMinus1 + static_cast(1)) * static_cast(0.5); T mult = static_cast(0.25) / biggestVal; switch(biggestIndex) { case 0: return qua(biggestVal, (m[1][2] - m[2][1]) * mult, (m[2][0] - m[0][2]) * mult, (m[0][1] - m[1][0]) * mult); case 1: return qua((m[1][2] - m[2][1]) * mult, biggestVal, (m[0][1] + m[1][0]) * mult, (m[2][0] + m[0][2]) * mult); case 2: return qua((m[2][0] - m[0][2]) * mult, (m[0][1] + m[1][0]) * mult, biggestVal, (m[1][2] + m[2][1]) * mult); case 3: return qua((m[0][1] - m[1][0]) * mult, (m[2][0] + m[0][2]) * mult, (m[1][2] + m[2][1]) * mult, biggestVal); default: // Silence a -Wswitch-default warning in GCC. Should never actually get here. Assert is just for sanity. assert(false); return qua(1, 0, 0, 0); } } template GLM_FUNC_QUALIFIER qua quat_cast(mat<4, 4, T, Q> const& m4) { return quat_cast(mat<3, 3, T, Q>(m4)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThan(qua const& x, qua const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] < y[i]; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThanEqual(qua const& x, qua const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] <= y[i]; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThan(qua const& x, qua const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] > y[i]; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThanEqual(qua const& x, qua const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] >= y[i]; return Result; } template GLM_FUNC_QUALIFIER qua quatLookAt(vec<3, T, Q> const& direction, vec<3, T, Q> const& up) { # if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT return quatLookAtLH(direction, up); # else return quatLookAtRH(direction, up); # endif } template GLM_FUNC_QUALIFIER qua quatLookAtRH(vec<3, T, Q> const& direction, vec<3, T, Q> const& up) { mat<3, 3, T, Q> Result; Result[2] = -direction; vec<3, T, Q> const& Right = cross(up, Result[2]); Result[0] = Right * inversesqrt(max(static_cast(0.00001), dot(Right, Right))); Result[1] = cross(Result[2], Result[0]); return quat_cast(Result); } template GLM_FUNC_QUALIFIER qua quatLookAtLH(vec<3, T, Q> const& direction, vec<3, T, Q> const& up) { mat<3, 3, T, Q> Result; Result[2] = direction; vec<3, T, Q> const& Right = cross(up, Result[2]); Result[0] = Right * inversesqrt(max(static_cast(0.00001), dot(Right, Right))); Result[1] = cross(Result[2], Result[0]); return quat_cast(Result); } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE # include "quaternion_simd.inl" #endif ================================================ FILE: android/src/glm/gtc/quaternion_simd.inl ================================================ ================================================ FILE: android/src/glm/gtc/random.hpp ================================================ /// @ref gtc_random /// @file glm/gtc/random.hpp /// /// @see core (dependence) /// @see gtx_random (extended) /// /// @defgroup gtc_random GLM_GTC_random /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Generate random number from various distribution methods. #pragma once // Dependency: #include "../ext/scalar_int_sized.hpp" #include "../ext/scalar_uint_sized.hpp" #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_random extension included") #endif namespace glm { /// @addtogroup gtc_random /// @{ /// Generate random numbers in the interval [Min, Max], according a linear distribution /// /// @param Min Minimum value included in the sampling /// @param Max Maximum value included in the sampling /// @tparam genType Value type. Currently supported: float or double scalars. /// @see gtc_random template GLM_FUNC_DECL genType linearRand(genType Min, genType Max); /// Generate random numbers in the interval [Min, Max], according a linear distribution /// /// @param Min Minimum value included in the sampling /// @param Max Maximum value included in the sampling /// @tparam T Value type. Currently supported: float or double. /// /// @see gtc_random template GLM_FUNC_DECL vec linearRand(vec const& Min, vec const& Max); /// Generate random numbers in the interval [Min, Max], according a gaussian distribution /// /// @see gtc_random template GLM_FUNC_DECL genType gaussRand(genType Mean, genType Deviation); /// Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius /// /// @see gtc_random template GLM_FUNC_DECL vec<2, T, defaultp> circularRand(T Radius); /// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius /// /// @see gtc_random template GLM_FUNC_DECL vec<3, T, defaultp> sphericalRand(T Radius); /// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius /// /// @see gtc_random template GLM_FUNC_DECL vec<2, T, defaultp> diskRand(T Radius); /// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius /// /// @see gtc_random template GLM_FUNC_DECL vec<3, T, defaultp> ballRand(T Radius); /// @} }//namespace glm #include "random.inl" ================================================ FILE: android/src/glm/gtc/random.inl ================================================ #include "../geometric.hpp" #include "../exponential.hpp" #include "../trigonometric.hpp" #include "../detail/type_vec1.hpp" #include #include #include #include namespace glm{ namespace detail { template struct compute_rand { GLM_FUNC_QUALIFIER static vec call(); }; template struct compute_rand<1, uint8, P> { GLM_FUNC_QUALIFIER static vec<1, uint8, P> call() { return vec<1, uint8, P>( std::rand() % std::numeric_limits::max()); } }; template struct compute_rand<2, uint8, P> { GLM_FUNC_QUALIFIER static vec<2, uint8, P> call() { return vec<2, uint8, P>( std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max()); } }; template struct compute_rand<3, uint8, P> { GLM_FUNC_QUALIFIER static vec<3, uint8, P> call() { return vec<3, uint8, P>( std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max()); } }; template struct compute_rand<4, uint8, P> { GLM_FUNC_QUALIFIER static vec<4, uint8, P> call() { return vec<4, uint8, P>( std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max()); } }; template struct compute_rand { GLM_FUNC_QUALIFIER static vec call() { return (vec(compute_rand::call()) << static_cast(8)) | (vec(compute_rand::call()) << static_cast(0)); } }; template struct compute_rand { GLM_FUNC_QUALIFIER static vec call() { return (vec(compute_rand::call()) << static_cast(16)) | (vec(compute_rand::call()) << static_cast(0)); } }; template struct compute_rand { GLM_FUNC_QUALIFIER static vec call() { return (vec(compute_rand::call()) << static_cast(32)) | (vec(compute_rand::call()) << static_cast(0)); } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max); }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (vec(compute_rand::call() % vec(Max + static_cast(1) - Min))) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (compute_rand::call() % (Max + static_cast(1) - Min)) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (vec(compute_rand::call() % vec(Max + static_cast(1) - Min))) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (compute_rand::call() % (Max + static_cast(1) - Min)) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (vec(compute_rand::call() % vec(Max + static_cast(1) - Min))) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (compute_rand::call() % (Max + static_cast(1) - Min)) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (vec(compute_rand::call() % vec(Max + static_cast(1) - Min))) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (compute_rand::call() % (Max + static_cast(1) - Min)) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; }//namespace detail template GLM_FUNC_QUALIFIER genType linearRand(genType Min, genType Max) { return detail::compute_linearRand<1, genType, highp>::call( vec<1, genType, highp>(Min), vec<1, genType, highp>(Max)).x; } template GLM_FUNC_QUALIFIER vec linearRand(vec const& Min, vec const& Max) { return detail::compute_linearRand::call(Min, Max); } template GLM_FUNC_QUALIFIER genType gaussRand(genType Mean, genType Deviation) { genType w, x1, x2; do { x1 = linearRand(genType(-1), genType(1)); x2 = linearRand(genType(-1), genType(1)); w = x1 * x1 + x2 * x2; } while(w > genType(1)); return static_cast(x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean); } template GLM_FUNC_QUALIFIER vec gaussRand(vec const& Mean, vec const& Deviation) { return detail::functor2::call(gaussRand, Mean, Deviation); } template GLM_FUNC_QUALIFIER vec<2, T, defaultp> diskRand(T Radius) { assert(Radius > static_cast(0)); vec<2, T, defaultp> Result(T(0)); T LenRadius(T(0)); do { Result = linearRand( vec<2, T, defaultp>(-Radius), vec<2, T, defaultp>(Radius)); LenRadius = length(Result); } while(LenRadius > Radius); return Result; } template GLM_FUNC_QUALIFIER vec<3, T, defaultp> ballRand(T Radius) { assert(Radius > static_cast(0)); vec<3, T, defaultp> Result(T(0)); T LenRadius(T(0)); do { Result = linearRand( vec<3, T, defaultp>(-Radius), vec<3, T, defaultp>(Radius)); LenRadius = length(Result); } while(LenRadius > Radius); return Result; } template GLM_FUNC_QUALIFIER vec<2, T, defaultp> circularRand(T Radius) { assert(Radius > static_cast(0)); T a = linearRand(T(0), static_cast(6.283185307179586476925286766559)); return vec<2, T, defaultp>(glm::cos(a), glm::sin(a)) * Radius; } template GLM_FUNC_QUALIFIER vec<3, T, defaultp> sphericalRand(T Radius) { assert(Radius > static_cast(0)); T theta = linearRand(T(0), T(6.283185307179586476925286766559f)); T phi = std::acos(linearRand(T(-1.0f), T(1.0f))); T x = std::sin(phi) * std::cos(theta); T y = std::sin(phi) * std::sin(theta); T z = std::cos(phi); return vec<3, T, defaultp>(x, y, z) * Radius; } }//namespace glm ================================================ FILE: android/src/glm/gtc/reciprocal.hpp ================================================ /// @ref gtc_reciprocal /// @file glm/gtc/reciprocal.hpp /// /// @see core (dependence) /// /// @defgroup gtc_reciprocal GLM_GTC_reciprocal /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Define secant, cosecant and cotangent functions. #pragma once // Dependencies #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_reciprocal extension included") #endif namespace glm { /// @addtogroup gtc_reciprocal /// @{ /// Secant function. /// hypotenuse / adjacent or 1 / cos(x) /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType sec(genType angle); /// Cosecant function. /// hypotenuse / opposite or 1 / sin(x) /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType csc(genType angle); /// Cotangent function. /// adjacent / opposite or 1 / tan(x) /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType cot(genType angle); /// Inverse secant function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType asec(genType x); /// Inverse cosecant function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType acsc(genType x); /// Inverse cotangent function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType acot(genType x); /// Secant hyperbolic function. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType sech(genType angle); /// Cosecant hyperbolic function. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType csch(genType angle); /// Cotangent hyperbolic function. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType coth(genType angle); /// Inverse secant hyperbolic function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType asech(genType x); /// Inverse cosecant hyperbolic function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType acsch(genType x); /// Inverse cotangent hyperbolic function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType acoth(genType x); /// @} }//namespace glm #include "reciprocal.inl" ================================================ FILE: android/src/glm/gtc/reciprocal.inl ================================================ /// @ref gtc_reciprocal #include "../trigonometric.hpp" #include namespace glm { // sec template GLM_FUNC_QUALIFIER genType sec(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sec' only accept floating-point values"); return genType(1) / glm::cos(angle); } template GLM_FUNC_QUALIFIER vec sec(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sec' only accept floating-point inputs"); return detail::functor1::call(sec, x); } // csc template GLM_FUNC_QUALIFIER genType csc(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csc' only accept floating-point values"); return genType(1) / glm::sin(angle); } template GLM_FUNC_QUALIFIER vec csc(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csc' only accept floating-point inputs"); return detail::functor1::call(csc, x); } // cot template GLM_FUNC_QUALIFIER genType cot(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cot' only accept floating-point values"); genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0); return glm::tan(pi_over_2 - angle); } template GLM_FUNC_QUALIFIER vec cot(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cot' only accept floating-point inputs"); return detail::functor1::call(cot, x); } // asec template GLM_FUNC_QUALIFIER genType asec(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asec' only accept floating-point values"); return acos(genType(1) / x); } template GLM_FUNC_QUALIFIER vec asec(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asec' only accept floating-point inputs"); return detail::functor1::call(asec, x); } // acsc template GLM_FUNC_QUALIFIER genType acsc(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsc' only accept floating-point values"); return asin(genType(1) / x); } template GLM_FUNC_QUALIFIER vec acsc(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsc' only accept floating-point inputs"); return detail::functor1::call(acsc, x); } // acot template GLM_FUNC_QUALIFIER genType acot(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acot' only accept floating-point values"); genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0); return pi_over_2 - atan(x); } template GLM_FUNC_QUALIFIER vec acot(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acot' only accept floating-point inputs"); return detail::functor1::call(acot, x); } // sech template GLM_FUNC_QUALIFIER genType sech(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sech' only accept floating-point values"); return genType(1) / glm::cosh(angle); } template GLM_FUNC_QUALIFIER vec sech(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sech' only accept floating-point inputs"); return detail::functor1::call(sech, x); } // csch template GLM_FUNC_QUALIFIER genType csch(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csch' only accept floating-point values"); return genType(1) / glm::sinh(angle); } template GLM_FUNC_QUALIFIER vec csch(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csch' only accept floating-point inputs"); return detail::functor1::call(csch, x); } // coth template GLM_FUNC_QUALIFIER genType coth(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'coth' only accept floating-point values"); return glm::cosh(angle) / glm::sinh(angle); } template GLM_FUNC_QUALIFIER vec coth(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'coth' only accept floating-point inputs"); return detail::functor1::call(coth, x); } // asech template GLM_FUNC_QUALIFIER genType asech(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asech' only accept floating-point values"); return acosh(genType(1) / x); } template GLM_FUNC_QUALIFIER vec asech(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asech' only accept floating-point inputs"); return detail::functor1::call(asech, x); } // acsch template GLM_FUNC_QUALIFIER genType acsch(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsch' only accept floating-point values"); return asinh(genType(1) / x); } template GLM_FUNC_QUALIFIER vec acsch(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsch' only accept floating-point inputs"); return detail::functor1::call(acsch, x); } // acoth template GLM_FUNC_QUALIFIER genType acoth(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acoth' only accept floating-point values"); return atanh(genType(1) / x); } template GLM_FUNC_QUALIFIER vec acoth(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acoth' only accept floating-point inputs"); return detail::functor1::call(acoth, x); } }//namespace glm ================================================ FILE: android/src/glm/gtc/round.hpp ================================================ /// @ref gtc_round /// @file glm/gtc/round.hpp /// /// @see core (dependence) /// @see gtc_round (dependence) /// /// @defgroup gtc_round GLM_GTC_round /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Rounding value to specific boundings #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/_vectorize.hpp" #include "../vector_relational.hpp" #include "../common.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_round extension included") #endif namespace glm { /// @addtogroup gtc_round /// @{ /// Return the power of two number which value is just higher the input value, /// round up to a power of two. /// /// @see gtc_round template GLM_FUNC_DECL genIUType ceilPowerOfTwo(genIUType v); /// Return the power of two number which value is just higher the input value, /// round up to a power of two. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_round template GLM_FUNC_DECL vec ceilPowerOfTwo(vec const& v); /// Return the power of two number which value is just lower the input value, /// round down to a power of two. /// /// @see gtc_round template GLM_FUNC_DECL genIUType floorPowerOfTwo(genIUType v); /// Return the power of two number which value is just lower the input value, /// round down to a power of two. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_round template GLM_FUNC_DECL vec floorPowerOfTwo(vec const& v); /// Return the power of two number which value is the closet to the input value. /// /// @see gtc_round template GLM_FUNC_DECL genIUType roundPowerOfTwo(genIUType v); /// Return the power of two number which value is the closet to the input value. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_round template GLM_FUNC_DECL vec roundPowerOfTwo(vec const& v); /// Higher multiple number of Source. /// /// @tparam genType Floating-point or integer scalar or vector types. /// /// @param v Source value to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL genType ceilMultiple(genType v, genType Multiple); /// Higher multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL vec ceilMultiple(vec const& v, vec const& Multiple); /// Lower multiple number of Source. /// /// @tparam genType Floating-point or integer scalar or vector types. /// /// @param v Source value to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL genType floorMultiple(genType v, genType Multiple); /// Lower multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL vec floorMultiple(vec const& v, vec const& Multiple); /// Lower multiple number of Source. /// /// @tparam genType Floating-point or integer scalar or vector types. /// /// @param v Source value to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL genType roundMultiple(genType v, genType Multiple); /// Lower multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL vec roundMultiple(vec const& v, vec const& Multiple); /// @} } //namespace glm #include "round.inl" ================================================ FILE: android/src/glm/gtc/round.inl ================================================ /// @ref gtc_round #include "../integer.hpp" #include "../ext/vector_integer.hpp" namespace glm{ namespace detail { template struct compute_roundMultiple {}; template<> struct compute_roundMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if (Source >= genType(0)) return Source - std::fmod(Source, Multiple); else { genType Tmp = Source + genType(1); return Tmp - std::fmod(Tmp, Multiple) - Multiple; } } }; template<> struct compute_roundMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if (Source >= genType(0)) return Source - Source % Multiple; else { genType Tmp = Source + genType(1); return Tmp - Tmp % Multiple - Multiple; } } }; template<> struct compute_roundMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if (Source >= genType(0)) return Source - Source % Multiple; else { genType Tmp = Source + genType(1); return Tmp - Tmp % Multiple - Multiple; } } }; }//namespace detail ////////////////// // ceilPowerOfTwo template GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value) { return detail::compute_ceilPowerOfTwo<1, genType, defaultp, std::numeric_limits::is_signed>::call(vec<1, genType, defaultp>(value)).x; } template GLM_FUNC_QUALIFIER vec ceilPowerOfTwo(vec const& v) { return detail::compute_ceilPowerOfTwo::is_signed>::call(v); } /////////////////// // floorPowerOfTwo template GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value) { return isPowerOfTwo(value) ? value : static_cast(1) << findMSB(value); } template GLM_FUNC_QUALIFIER vec floorPowerOfTwo(vec const& v) { return detail::functor1::call(floorPowerOfTwo, v); } /////////////////// // roundPowerOfTwo template GLM_FUNC_QUALIFIER genIUType roundPowerOfTwo(genIUType value) { if(isPowerOfTwo(value)) return value; genIUType const prev = static_cast(1) << findMSB(value); genIUType const next = prev << static_cast(1); return (next - value) < (value - prev) ? next : prev; } template GLM_FUNC_QUALIFIER vec roundPowerOfTwo(vec const& v) { return detail::functor1::call(roundPowerOfTwo, v); } ////////////////////// // ceilMultiple template GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple) { return detail::compute_ceilMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template GLM_FUNC_QUALIFIER vec ceilMultiple(vec const& Source, vec const& Multiple) { return detail::functor2::call(ceilMultiple, Source, Multiple); } ////////////////////// // floorMultiple template GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple) { return detail::compute_floorMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template GLM_FUNC_QUALIFIER vec floorMultiple(vec const& Source, vec const& Multiple) { return detail::functor2::call(floorMultiple, Source, Multiple); } ////////////////////// // roundMultiple template GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple) { return detail::compute_roundMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template GLM_FUNC_QUALIFIER vec roundMultiple(vec const& Source, vec const& Multiple) { return detail::functor2::call(roundMultiple, Source, Multiple); } }//namespace glm ================================================ FILE: android/src/glm/gtc/type_aligned.hpp ================================================ /// @ref gtc_type_aligned /// @file glm/gtc/type_aligned.hpp /// /// @see core (dependence) /// /// @defgroup gtc_type_aligned GLM_GTC_type_aligned /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Aligned types allowing SIMD optimizations of vectors and matrices types #pragma once #if (GLM_CONFIG_ALIGNED_GENTYPES == GLM_DISABLE) # error "GLM: Aligned gentypes require to enable C++ language extensions. Define GLM_FORCE_ALIGNED_GENTYPES before including GLM headers to use aligned types." #endif #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_type_aligned extension included") #endif #include "../mat4x4.hpp" #include "../mat4x3.hpp" #include "../mat4x2.hpp" #include "../mat3x4.hpp" #include "../mat3x3.hpp" #include "../mat3x2.hpp" #include "../mat2x4.hpp" #include "../mat2x3.hpp" #include "../mat2x2.hpp" #include "../gtc/vec1.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" namespace glm { /// @addtogroup gtc_type_aligned /// @{ // -- *vec1 -- /// 1 component vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, float, aligned_highp> aligned_highp_vec1; /// 1 component vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, float, aligned_mediump> aligned_mediump_vec1; /// 1 component vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, float, aligned_lowp> aligned_lowp_vec1; /// 1 component vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, double, aligned_highp> aligned_highp_dvec1; /// 1 component vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, double, aligned_mediump> aligned_mediump_dvec1; /// 1 component vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, double, aligned_lowp> aligned_lowp_dvec1; /// 1 component vector aligned in memory of signed integer numbers. typedef vec<1, int, aligned_highp> aligned_highp_ivec1; /// 1 component vector aligned in memory of signed integer numbers. typedef vec<1, int, aligned_mediump> aligned_mediump_ivec1; /// 1 component vector aligned in memory of signed integer numbers. typedef vec<1, int, aligned_lowp> aligned_lowp_ivec1; /// 1 component vector aligned in memory of unsigned integer numbers. typedef vec<1, uint, aligned_highp> aligned_highp_uvec1; /// 1 component vector aligned in memory of unsigned integer numbers. typedef vec<1, uint, aligned_mediump> aligned_mediump_uvec1; /// 1 component vector aligned in memory of unsigned integer numbers. typedef vec<1, uint, aligned_lowp> aligned_lowp_uvec1; /// 1 component vector aligned in memory of bool values. typedef vec<1, bool, aligned_highp> aligned_highp_bvec1; /// 1 component vector aligned in memory of bool values. typedef vec<1, bool, aligned_mediump> aligned_mediump_bvec1; /// 1 component vector aligned in memory of bool values. typedef vec<1, bool, aligned_lowp> aligned_lowp_bvec1; /// 1 component vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, float, packed_highp> packed_highp_vec1; /// 1 component vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, float, packed_mediump> packed_mediump_vec1; /// 1 component vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, float, packed_lowp> packed_lowp_vec1; /// 1 component vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, double, packed_highp> packed_highp_dvec1; /// 1 component vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, double, packed_mediump> packed_mediump_dvec1; /// 1 component vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, double, packed_lowp> packed_lowp_dvec1; /// 1 component vector tightly packed in memory of signed integer numbers. typedef vec<1, int, packed_highp> packed_highp_ivec1; /// 1 component vector tightly packed in memory of signed integer numbers. typedef vec<1, int, packed_mediump> packed_mediump_ivec1; /// 1 component vector tightly packed in memory of signed integer numbers. typedef vec<1, int, packed_lowp> packed_lowp_ivec1; /// 1 component vector tightly packed in memory of unsigned integer numbers. typedef vec<1, uint, packed_highp> packed_highp_uvec1; /// 1 component vector tightly packed in memory of unsigned integer numbers. typedef vec<1, uint, packed_mediump> packed_mediump_uvec1; /// 1 component vector tightly packed in memory of unsigned integer numbers. typedef vec<1, uint, packed_lowp> packed_lowp_uvec1; /// 1 component vector tightly packed in memory of bool values. typedef vec<1, bool, packed_highp> packed_highp_bvec1; /// 1 component vector tightly packed in memory of bool values. typedef vec<1, bool, packed_mediump> packed_mediump_bvec1; /// 1 component vector tightly packed in memory of bool values. typedef vec<1, bool, packed_lowp> packed_lowp_bvec1; // -- *vec2 -- /// 2 components vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<2, float, aligned_highp> aligned_highp_vec2; /// 2 components vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<2, float, aligned_mediump> aligned_mediump_vec2; /// 2 components vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<2, float, aligned_lowp> aligned_lowp_vec2; /// 2 components vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<2, double, aligned_highp> aligned_highp_dvec2; /// 2 components vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<2, double, aligned_mediump> aligned_mediump_dvec2; /// 2 components vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<2, double, aligned_lowp> aligned_lowp_dvec2; /// 2 components vector aligned in memory of signed integer numbers. typedef vec<2, int, aligned_highp> aligned_highp_ivec2; /// 2 components vector aligned in memory of signed integer numbers. typedef vec<2, int, aligned_mediump> aligned_mediump_ivec2; /// 2 components vector aligned in memory of signed integer numbers. typedef vec<2, int, aligned_lowp> aligned_lowp_ivec2; /// 2 components vector aligned in memory of unsigned integer numbers. typedef vec<2, uint, aligned_highp> aligned_highp_uvec2; /// 2 components vector aligned in memory of unsigned integer numbers. typedef vec<2, uint, aligned_mediump> aligned_mediump_uvec2; /// 2 components vector aligned in memory of unsigned integer numbers. typedef vec<2, uint, aligned_lowp> aligned_lowp_uvec2; /// 2 components vector aligned in memory of bool values. typedef vec<2, bool, aligned_highp> aligned_highp_bvec2; /// 2 components vector aligned in memory of bool values. typedef vec<2, bool, aligned_mediump> aligned_mediump_bvec2; /// 2 components vector aligned in memory of bool values. typedef vec<2, bool, aligned_lowp> aligned_lowp_bvec2; /// 2 components vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<2, float, packed_highp> packed_highp_vec2; /// 2 components vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<2, float, packed_mediump> packed_mediump_vec2; /// 2 components vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<2, float, packed_lowp> packed_lowp_vec2; /// 2 components vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<2, double, packed_highp> packed_highp_dvec2; /// 2 components vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<2, double, packed_mediump> packed_mediump_dvec2; /// 2 components vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<2, double, packed_lowp> packed_lowp_dvec2; /// 2 components vector tightly packed in memory of signed integer numbers. typedef vec<2, int, packed_highp> packed_highp_ivec2; /// 2 components vector tightly packed in memory of signed integer numbers. typedef vec<2, int, packed_mediump> packed_mediump_ivec2; /// 2 components vector tightly packed in memory of signed integer numbers. typedef vec<2, int, packed_lowp> packed_lowp_ivec2; /// 2 components vector tightly packed in memory of unsigned integer numbers. typedef vec<2, uint, packed_highp> packed_highp_uvec2; /// 2 components vector tightly packed in memory of unsigned integer numbers. typedef vec<2, uint, packed_mediump> packed_mediump_uvec2; /// 2 components vector tightly packed in memory of unsigned integer numbers. typedef vec<2, uint, packed_lowp> packed_lowp_uvec2; /// 2 components vector tightly packed in memory of bool values. typedef vec<2, bool, packed_highp> packed_highp_bvec2; /// 2 components vector tightly packed in memory of bool values. typedef vec<2, bool, packed_mediump> packed_mediump_bvec2; /// 2 components vector tightly packed in memory of bool values. typedef vec<2, bool, packed_lowp> packed_lowp_bvec2; // -- *vec3 -- /// 3 components vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<3, float, aligned_highp> aligned_highp_vec3; /// 3 components vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<3, float, aligned_mediump> aligned_mediump_vec3; /// 3 components vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<3, float, aligned_lowp> aligned_lowp_vec3; /// 3 components vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<3, double, aligned_highp> aligned_highp_dvec3; /// 3 components vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<3, double, aligned_mediump> aligned_mediump_dvec3; /// 3 components vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<3, double, aligned_lowp> aligned_lowp_dvec3; /// 3 components vector aligned in memory of signed integer numbers. typedef vec<3, int, aligned_highp> aligned_highp_ivec3; /// 3 components vector aligned in memory of signed integer numbers. typedef vec<3, int, aligned_mediump> aligned_mediump_ivec3; /// 3 components vector aligned in memory of signed integer numbers. typedef vec<3, int, aligned_lowp> aligned_lowp_ivec3; /// 3 components vector aligned in memory of unsigned integer numbers. typedef vec<3, uint, aligned_highp> aligned_highp_uvec3; /// 3 components vector aligned in memory of unsigned integer numbers. typedef vec<3, uint, aligned_mediump> aligned_mediump_uvec3; /// 3 components vector aligned in memory of unsigned integer numbers. typedef vec<3, uint, aligned_lowp> aligned_lowp_uvec3; /// 3 components vector aligned in memory of bool values. typedef vec<3, bool, aligned_highp> aligned_highp_bvec3; /// 3 components vector aligned in memory of bool values. typedef vec<3, bool, aligned_mediump> aligned_mediump_bvec3; /// 3 components vector aligned in memory of bool values. typedef vec<3, bool, aligned_lowp> aligned_lowp_bvec3; /// 3 components vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<3, float, packed_highp> packed_highp_vec3; /// 3 components vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<3, float, packed_mediump> packed_mediump_vec3; /// 3 components vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<3, float, packed_lowp> packed_lowp_vec3; /// 3 components vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<3, double, packed_highp> packed_highp_dvec3; /// 3 components vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<3, double, packed_mediump> packed_mediump_dvec3; /// 3 components vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<3, double, packed_lowp> packed_lowp_dvec3; /// 3 components vector tightly packed in memory of signed integer numbers. typedef vec<3, int, packed_highp> packed_highp_ivec3; /// 3 components vector tightly packed in memory of signed integer numbers. typedef vec<3, int, packed_mediump> packed_mediump_ivec3; /// 3 components vector tightly packed in memory of signed integer numbers. typedef vec<3, int, packed_lowp> packed_lowp_ivec3; /// 3 components vector tightly packed in memory of unsigned integer numbers. typedef vec<3, uint, packed_highp> packed_highp_uvec3; /// 3 components vector tightly packed in memory of unsigned integer numbers. typedef vec<3, uint, packed_mediump> packed_mediump_uvec3; /// 3 components vector tightly packed in memory of unsigned integer numbers. typedef vec<3, uint, packed_lowp> packed_lowp_uvec3; /// 3 components vector tightly packed in memory of bool values. typedef vec<3, bool, packed_highp> packed_highp_bvec3; /// 3 components vector tightly packed in memory of bool values. typedef vec<3, bool, packed_mediump> packed_mediump_bvec3; /// 3 components vector tightly packed in memory of bool values. typedef vec<3, bool, packed_lowp> packed_lowp_bvec3; // -- *vec4 -- /// 4 components vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<4, float, aligned_highp> aligned_highp_vec4; /// 4 components vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<4, float, aligned_mediump> aligned_mediump_vec4; /// 4 components vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<4, float, aligned_lowp> aligned_lowp_vec4; /// 4 components vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<4, double, aligned_highp> aligned_highp_dvec4; /// 4 components vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<4, double, aligned_mediump> aligned_mediump_dvec4; /// 4 components vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<4, double, aligned_lowp> aligned_lowp_dvec4; /// 4 components vector aligned in memory of signed integer numbers. typedef vec<4, int, aligned_highp> aligned_highp_ivec4; /// 4 components vector aligned in memory of signed integer numbers. typedef vec<4, int, aligned_mediump> aligned_mediump_ivec4; /// 4 components vector aligned in memory of signed integer numbers. typedef vec<4, int, aligned_lowp> aligned_lowp_ivec4; /// 4 components vector aligned in memory of unsigned integer numbers. typedef vec<4, uint, aligned_highp> aligned_highp_uvec4; /// 4 components vector aligned in memory of unsigned integer numbers. typedef vec<4, uint, aligned_mediump> aligned_mediump_uvec4; /// 4 components vector aligned in memory of unsigned integer numbers. typedef vec<4, uint, aligned_lowp> aligned_lowp_uvec4; /// 4 components vector aligned in memory of bool values. typedef vec<4, bool, aligned_highp> aligned_highp_bvec4; /// 4 components vector aligned in memory of bool values. typedef vec<4, bool, aligned_mediump> aligned_mediump_bvec4; /// 4 components vector aligned in memory of bool values. typedef vec<4, bool, aligned_lowp> aligned_lowp_bvec4; /// 4 components vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<4, float, packed_highp> packed_highp_vec4; /// 4 components vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<4, float, packed_mediump> packed_mediump_vec4; /// 4 components vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<4, float, packed_lowp> packed_lowp_vec4; /// 4 components vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<4, double, packed_highp> packed_highp_dvec4; /// 4 components vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<4, double, packed_mediump> packed_mediump_dvec4; /// 4 components vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<4, double, packed_lowp> packed_lowp_dvec4; /// 4 components vector tightly packed in memory of signed integer numbers. typedef vec<4, int, packed_highp> packed_highp_ivec4; /// 4 components vector tightly packed in memory of signed integer numbers. typedef vec<4, int, packed_mediump> packed_mediump_ivec4; /// 4 components vector tightly packed in memory of signed integer numbers. typedef vec<4, int, packed_lowp> packed_lowp_ivec4; /// 4 components vector tightly packed in memory of unsigned integer numbers. typedef vec<4, uint, packed_highp> packed_highp_uvec4; /// 4 components vector tightly packed in memory of unsigned integer numbers. typedef vec<4, uint, packed_mediump> packed_mediump_uvec4; /// 4 components vector tightly packed in memory of unsigned integer numbers. typedef vec<4, uint, packed_lowp> packed_lowp_uvec4; /// 4 components vector tightly packed in memory of bool values. typedef vec<4, bool, packed_highp> packed_highp_bvec4; /// 4 components vector tightly packed in memory of bool values. typedef vec<4, bool, packed_mediump> packed_mediump_bvec4; /// 4 components vector tightly packed in memory of bool values. typedef vec<4, bool, packed_lowp> packed_lowp_bvec4; // -- *mat2 -- /// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 2, float, aligned_highp> aligned_highp_mat2; /// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 2, float, aligned_mediump> aligned_mediump_mat2; /// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 2, float, aligned_lowp> aligned_lowp_mat2; /// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 2, double, aligned_highp> aligned_highp_dmat2; /// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 2, double, aligned_mediump> aligned_mediump_dmat2; /// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 2, double, aligned_lowp> aligned_lowp_dmat2; /// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 2, float, packed_highp> packed_highp_mat2; /// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 2, float, packed_mediump> packed_mediump_mat2; /// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 2, float, packed_lowp> packed_lowp_mat2; /// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 2, double, packed_highp> packed_highp_dmat2; /// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 2, double, packed_mediump> packed_mediump_dmat2; /// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 2, double, packed_lowp> packed_lowp_dmat2; // -- *mat3 -- /// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 3, float, aligned_highp> aligned_highp_mat3; /// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 3, float, aligned_mediump> aligned_mediump_mat3; /// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 3, float, aligned_lowp> aligned_lowp_mat3; /// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 3, double, aligned_highp> aligned_highp_dmat3; /// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 3, double, aligned_mediump> aligned_mediump_dmat3; /// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 3, double, aligned_lowp> aligned_lowp_dmat3; /// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 3, float, packed_highp> packed_highp_mat3; /// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 3, float, packed_mediump> packed_mediump_mat3; /// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 3, float, packed_lowp> packed_lowp_mat3; /// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 3, double, packed_highp> packed_highp_dmat3; /// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 3, double, packed_mediump> packed_mediump_dmat3; /// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 3, double, packed_lowp> packed_lowp_dmat3; // -- *mat4 -- /// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 4, float, aligned_highp> aligned_highp_mat4; /// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 4, float, aligned_mediump> aligned_mediump_mat4; /// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 4, float, aligned_lowp> aligned_lowp_mat4; /// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 4, double, aligned_highp> aligned_highp_dmat4; /// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 4, double, aligned_mediump> aligned_mediump_dmat4; /// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 4, double, aligned_lowp> aligned_lowp_dmat4; /// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 4, float, packed_highp> packed_highp_mat4; /// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 4, float, packed_mediump> packed_mediump_mat4; /// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 4, float, packed_lowp> packed_lowp_mat4; /// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 4, double, packed_highp> packed_highp_dmat4; /// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 4, double, packed_mediump> packed_mediump_dmat4; /// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 4, double, packed_lowp> packed_lowp_dmat4; // -- *mat2x2 -- /// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 2, float, aligned_highp> aligned_highp_mat2x2; /// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 2, float, aligned_mediump> aligned_mediump_mat2x2; /// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 2, float, aligned_lowp> aligned_lowp_mat2x2; /// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 2, double, aligned_highp> aligned_highp_dmat2x2; /// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 2, double, aligned_mediump> aligned_mediump_dmat2x2; /// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 2, double, aligned_lowp> aligned_lowp_dmat2x2; /// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 2, float, packed_highp> packed_highp_mat2x2; /// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 2, float, packed_mediump> packed_mediump_mat2x2; /// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 2, float, packed_lowp> packed_lowp_mat2x2; /// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 2, double, packed_highp> packed_highp_dmat2x2; /// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 2, double, packed_mediump> packed_mediump_dmat2x2; /// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 2, double, packed_lowp> packed_lowp_dmat2x2; // -- *mat2x3 -- /// 2 by 3 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 3, float, aligned_highp> aligned_highp_mat2x3; /// 2 by 3 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 3, float, aligned_mediump> aligned_mediump_mat2x3; /// 2 by 3 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 3, float, aligned_lowp> aligned_lowp_mat2x3; /// 2 by 3 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 3, double, aligned_highp> aligned_highp_dmat2x3; /// 2 by 3 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 3, double, aligned_mediump> aligned_mediump_dmat2x3; /// 2 by 3 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 3, double, aligned_lowp> aligned_lowp_dmat2x3; /// 2 by 3 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 3, float, packed_highp> packed_highp_mat2x3; /// 2 by 3 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 3, float, packed_mediump> packed_mediump_mat2x3; /// 2 by 3 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 3, float, packed_lowp> packed_lowp_mat2x3; /// 2 by 3 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 3, double, packed_highp> packed_highp_dmat2x3; /// 2 by 3 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 3, double, packed_mediump> packed_mediump_dmat2x3; /// 2 by 3 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 3, double, packed_lowp> packed_lowp_dmat2x3; // -- *mat2x4 -- /// 2 by 4 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 4, float, aligned_highp> aligned_highp_mat2x4; /// 2 by 4 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 4, float, aligned_mediump> aligned_mediump_mat2x4; /// 2 by 4 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 4, float, aligned_lowp> aligned_lowp_mat2x4; /// 2 by 4 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 4, double, aligned_highp> aligned_highp_dmat2x4; /// 2 by 4 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 4, double, aligned_mediump> aligned_mediump_dmat2x4; /// 2 by 4 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 4, double, aligned_lowp> aligned_lowp_dmat2x4; /// 2 by 4 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 4, float, packed_highp> packed_highp_mat2x4; /// 2 by 4 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 4, float, packed_mediump> packed_mediump_mat2x4; /// 2 by 4 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 4, float, packed_lowp> packed_lowp_mat2x4; /// 2 by 4 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<2, 4, double, packed_highp> packed_highp_dmat2x4; /// 2 by 4 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<2, 4, double, packed_mediump> packed_mediump_dmat2x4; /// 2 by 4 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<2, 4, double, packed_lowp> packed_lowp_dmat2x4; // -- *mat3x2 -- /// 3 by 2 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 2, float, aligned_highp> aligned_highp_mat3x2; /// 3 by 2 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 2, float, aligned_mediump> aligned_mediump_mat3x2; /// 3 by 2 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 2, float, aligned_lowp> aligned_lowp_mat3x2; /// 3 by 2 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 2, double, aligned_highp> aligned_highp_dmat3x2; /// 3 by 2 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 2, double, aligned_mediump> aligned_mediump_dmat3x2; /// 3 by 2 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 2, double, aligned_lowp> aligned_lowp_dmat3x2; /// 3 by 2 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 2, float, packed_highp> packed_highp_mat3x2; /// 3 by 2 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 2, float, packed_mediump> packed_mediump_mat3x2; /// 3 by 2 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 2, float, packed_lowp> packed_lowp_mat3x2; /// 3 by 2 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 2, double, packed_highp> packed_highp_dmat3x2; /// 3 by 2 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 2, double, packed_mediump> packed_mediump_dmat3x2; /// 3 by 2 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 2, double, packed_lowp> packed_lowp_dmat3x2; // -- *mat3x3 -- /// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 3, float, aligned_highp> aligned_highp_mat3x3; /// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 3, float, aligned_mediump> aligned_mediump_mat3x3; /// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 3, float, aligned_lowp> aligned_lowp_mat3x3; /// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 3, double, aligned_highp> aligned_highp_dmat3x3; /// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 3, double, aligned_mediump> aligned_mediump_dmat3x3; /// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 3, double, aligned_lowp> aligned_lowp_dmat3x3; /// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 3, float, packed_highp> packed_highp_mat3x3; /// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 3, float, packed_mediump> packed_mediump_mat3x3; /// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 3, float, packed_lowp> packed_lowp_mat3x3; /// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 3, double, packed_highp> packed_highp_dmat3x3; /// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 3, double, packed_mediump> packed_mediump_dmat3x3; /// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 3, double, packed_lowp> packed_lowp_dmat3x3; // -- *mat3x4 -- /// 3 by 4 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 4, float, aligned_highp> aligned_highp_mat3x4; /// 3 by 4 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 4, float, aligned_mediump> aligned_mediump_mat3x4; /// 3 by 4 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 4, float, aligned_lowp> aligned_lowp_mat3x4; /// 3 by 4 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 4, double, aligned_highp> aligned_highp_dmat3x4; /// 3 by 4 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 4, double, aligned_mediump> aligned_mediump_dmat3x4; /// 3 by 4 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 4, double, aligned_lowp> aligned_lowp_dmat3x4; /// 3 by 4 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 4, float, packed_highp> packed_highp_mat3x4; /// 3 by 4 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 4, float, packed_mediump> packed_mediump_mat3x4; /// 3 by 4 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 4, float, packed_lowp> packed_lowp_mat3x4; /// 3 by 4 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<3, 4, double, packed_highp> packed_highp_dmat3x4; /// 3 by 4 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<3, 4, double, packed_mediump> packed_mediump_dmat3x4; /// 3 by 4 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<3, 4, double, packed_lowp> packed_lowp_dmat3x4; // -- *mat4x2 -- /// 4 by 2 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 2, float, aligned_highp> aligned_highp_mat4x2; /// 4 by 2 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 2, float, aligned_mediump> aligned_mediump_mat4x2; /// 4 by 2 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 2, float, aligned_lowp> aligned_lowp_mat4x2; /// 4 by 2 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 2, double, aligned_highp> aligned_highp_dmat4x2; /// 4 by 2 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 2, double, aligned_mediump> aligned_mediump_dmat4x2; /// 4 by 2 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 2, double, aligned_lowp> aligned_lowp_dmat4x2; /// 4 by 2 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 2, float, packed_highp> packed_highp_mat4x2; /// 4 by 2 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 2, float, packed_mediump> packed_mediump_mat4x2; /// 4 by 2 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 2, float, packed_lowp> packed_lowp_mat4x2; /// 4 by 2 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 2, double, packed_highp> packed_highp_dmat4x2; /// 4 by 2 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 2, double, packed_mediump> packed_mediump_dmat4x2; /// 4 by 2 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 2, double, packed_lowp> packed_lowp_dmat4x2; // -- *mat4x3 -- /// 4 by 3 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 3, float, aligned_highp> aligned_highp_mat4x3; /// 4 by 3 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 3, float, aligned_mediump> aligned_mediump_mat4x3; /// 4 by 3 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 3, float, aligned_lowp> aligned_lowp_mat4x3; /// 4 by 3 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 3, double, aligned_highp> aligned_highp_dmat4x3; /// 4 by 3 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 3, double, aligned_mediump> aligned_mediump_dmat4x3; /// 4 by 3 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 3, double, aligned_lowp> aligned_lowp_dmat4x3; /// 4 by 3 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 3, float, packed_highp> packed_highp_mat4x3; /// 4 by 3 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 3, float, packed_mediump> packed_mediump_mat4x3; /// 4 by 3 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 3, float, packed_lowp> packed_lowp_mat4x3; /// 4 by 3 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 3, double, packed_highp> packed_highp_dmat4x3; /// 4 by 3 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 3, double, packed_mediump> packed_mediump_dmat4x3; /// 4 by 3 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 3, double, packed_lowp> packed_lowp_dmat4x3; // -- *mat4x4 -- /// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 4, float, aligned_highp> aligned_highp_mat4x4; /// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 4, float, aligned_mediump> aligned_mediump_mat4x4; /// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 4, float, aligned_lowp> aligned_lowp_mat4x4; /// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 4, double, aligned_highp> aligned_highp_dmat4x4; /// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 4, double, aligned_mediump> aligned_mediump_dmat4x4; /// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 4, double, aligned_lowp> aligned_lowp_dmat4x4; /// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 4, float, packed_highp> packed_highp_mat4x4; /// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 4, float, packed_mediump> packed_mediump_mat4x4; /// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 4, float, packed_lowp> packed_lowp_mat4x4; /// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef mat<4, 4, double, packed_highp> packed_highp_dmat4x4; /// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef mat<4, 4, double, packed_mediump> packed_mediump_dmat4x4; /// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef mat<4, 4, double, packed_lowp> packed_lowp_dmat4x4; // -- default -- #if(defined(GLM_PRECISION_LOWP_FLOAT)) typedef aligned_lowp_vec1 aligned_vec1; typedef aligned_lowp_vec2 aligned_vec2; typedef aligned_lowp_vec3 aligned_vec3; typedef aligned_lowp_vec4 aligned_vec4; typedef packed_lowp_vec1 packed_vec1; typedef packed_lowp_vec2 packed_vec2; typedef packed_lowp_vec3 packed_vec3; typedef packed_lowp_vec4 packed_vec4; typedef aligned_lowp_mat2 aligned_mat2; typedef aligned_lowp_mat3 aligned_mat3; typedef aligned_lowp_mat4 aligned_mat4; typedef packed_lowp_mat2 packed_mat2; typedef packed_lowp_mat3 packed_mat3; typedef packed_lowp_mat4 packed_mat4; typedef aligned_lowp_mat2x2 aligned_mat2x2; typedef aligned_lowp_mat2x3 aligned_mat2x3; typedef aligned_lowp_mat2x4 aligned_mat2x4; typedef aligned_lowp_mat3x2 aligned_mat3x2; typedef aligned_lowp_mat3x3 aligned_mat3x3; typedef aligned_lowp_mat3x4 aligned_mat3x4; typedef aligned_lowp_mat4x2 aligned_mat4x2; typedef aligned_lowp_mat4x3 aligned_mat4x3; typedef aligned_lowp_mat4x4 aligned_mat4x4; typedef packed_lowp_mat2x2 packed_mat2x2; typedef packed_lowp_mat2x3 packed_mat2x3; typedef packed_lowp_mat2x4 packed_mat2x4; typedef packed_lowp_mat3x2 packed_mat3x2; typedef packed_lowp_mat3x3 packed_mat3x3; typedef packed_lowp_mat3x4 packed_mat3x4; typedef packed_lowp_mat4x2 packed_mat4x2; typedef packed_lowp_mat4x3 packed_mat4x3; typedef packed_lowp_mat4x4 packed_mat4x4; #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) typedef aligned_mediump_vec1 aligned_vec1; typedef aligned_mediump_vec2 aligned_vec2; typedef aligned_mediump_vec3 aligned_vec3; typedef aligned_mediump_vec4 aligned_vec4; typedef packed_mediump_vec1 packed_vec1; typedef packed_mediump_vec2 packed_vec2; typedef packed_mediump_vec3 packed_vec3; typedef packed_mediump_vec4 packed_vec4; typedef aligned_mediump_mat2 aligned_mat2; typedef aligned_mediump_mat3 aligned_mat3; typedef aligned_mediump_mat4 aligned_mat4; typedef packed_mediump_mat2 packed_mat2; typedef packed_mediump_mat3 packed_mat3; typedef packed_mediump_mat4 packed_mat4; typedef aligned_mediump_mat2x2 aligned_mat2x2; typedef aligned_mediump_mat2x3 aligned_mat2x3; typedef aligned_mediump_mat2x4 aligned_mat2x4; typedef aligned_mediump_mat3x2 aligned_mat3x2; typedef aligned_mediump_mat3x3 aligned_mat3x3; typedef aligned_mediump_mat3x4 aligned_mat3x4; typedef aligned_mediump_mat4x2 aligned_mat4x2; typedef aligned_mediump_mat4x3 aligned_mat4x3; typedef aligned_mediump_mat4x4 aligned_mat4x4; typedef packed_mediump_mat2x2 packed_mat2x2; typedef packed_mediump_mat2x3 packed_mat2x3; typedef packed_mediump_mat2x4 packed_mat2x4; typedef packed_mediump_mat3x2 packed_mat3x2; typedef packed_mediump_mat3x3 packed_mat3x3; typedef packed_mediump_mat3x4 packed_mat3x4; typedef packed_mediump_mat4x2 packed_mat4x2; typedef packed_mediump_mat4x3 packed_mat4x3; typedef packed_mediump_mat4x4 packed_mat4x4; #else //defined(GLM_PRECISION_HIGHP_FLOAT) /// 1 component vector aligned in memory of single-precision floating-point numbers. typedef aligned_highp_vec1 aligned_vec1; /// 2 components vector aligned in memory of single-precision floating-point numbers. typedef aligned_highp_vec2 aligned_vec2; /// 3 components vector aligned in memory of single-precision floating-point numbers. typedef aligned_highp_vec3 aligned_vec3; /// 4 components vector aligned in memory of single-precision floating-point numbers. typedef aligned_highp_vec4 aligned_vec4; /// 1 component vector tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_vec1 packed_vec1; /// 2 components vector tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_vec2 packed_vec2; /// 3 components vector tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_vec3 packed_vec3; /// 4 components vector tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_vec4 packed_vec4; /// 2 by 2 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat2 aligned_mat2; /// 3 by 3 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat3 aligned_mat3; /// 4 by 4 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat4 aligned_mat4; /// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat2 packed_mat2; /// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat3 packed_mat3; /// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat4 packed_mat4; /// 2 by 2 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat2x2 aligned_mat2x2; /// 2 by 3 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat2x3 aligned_mat2x3; /// 2 by 4 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat2x4 aligned_mat2x4; /// 3 by 2 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat3x2 aligned_mat3x2; /// 3 by 3 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat3x3 aligned_mat3x3; /// 3 by 4 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat3x4 aligned_mat3x4; /// 4 by 2 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat4x2 aligned_mat4x2; /// 4 by 3 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat4x3 aligned_mat4x3; /// 4 by 4 matrix tightly aligned in memory of single-precision floating-point numbers. typedef aligned_highp_mat4x4 aligned_mat4x4; /// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat2x2 packed_mat2x2; /// 2 by 3 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat2x3 packed_mat2x3; /// 2 by 4 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat2x4 packed_mat2x4; /// 3 by 2 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat3x2 packed_mat3x2; /// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat3x3 packed_mat3x3; /// 3 by 4 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat3x4 packed_mat3x4; /// 4 by 2 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat4x2 packed_mat4x2; /// 4 by 3 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat4x3 packed_mat4x3; /// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_mat4x4 packed_mat4x4; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_LOWP_DOUBLE)) typedef aligned_lowp_dvec1 aligned_dvec1; typedef aligned_lowp_dvec2 aligned_dvec2; typedef aligned_lowp_dvec3 aligned_dvec3; typedef aligned_lowp_dvec4 aligned_dvec4; typedef packed_lowp_dvec1 packed_dvec1; typedef packed_lowp_dvec2 packed_dvec2; typedef packed_lowp_dvec3 packed_dvec3; typedef packed_lowp_dvec4 packed_dvec4; typedef aligned_lowp_dmat2 aligned_dmat2; typedef aligned_lowp_dmat3 aligned_dmat3; typedef aligned_lowp_dmat4 aligned_dmat4; typedef packed_lowp_dmat2 packed_dmat2; typedef packed_lowp_dmat3 packed_dmat3; typedef packed_lowp_dmat4 packed_dmat4; typedef aligned_lowp_dmat2x2 aligned_dmat2x2; typedef aligned_lowp_dmat2x3 aligned_dmat2x3; typedef aligned_lowp_dmat2x4 aligned_dmat2x4; typedef aligned_lowp_dmat3x2 aligned_dmat3x2; typedef aligned_lowp_dmat3x3 aligned_dmat3x3; typedef aligned_lowp_dmat3x4 aligned_dmat3x4; typedef aligned_lowp_dmat4x2 aligned_dmat4x2; typedef aligned_lowp_dmat4x3 aligned_dmat4x3; typedef aligned_lowp_dmat4x4 aligned_dmat4x4; typedef packed_lowp_dmat2x2 packed_dmat2x2; typedef packed_lowp_dmat2x3 packed_dmat2x3; typedef packed_lowp_dmat2x4 packed_dmat2x4; typedef packed_lowp_dmat3x2 packed_dmat3x2; typedef packed_lowp_dmat3x3 packed_dmat3x3; typedef packed_lowp_dmat3x4 packed_dmat3x4; typedef packed_lowp_dmat4x2 packed_dmat4x2; typedef packed_lowp_dmat4x3 packed_dmat4x3; typedef packed_lowp_dmat4x4 packed_dmat4x4; #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE)) typedef aligned_mediump_dvec1 aligned_dvec1; typedef aligned_mediump_dvec2 aligned_dvec2; typedef aligned_mediump_dvec3 aligned_dvec3; typedef aligned_mediump_dvec4 aligned_dvec4; typedef packed_mediump_dvec1 packed_dvec1; typedef packed_mediump_dvec2 packed_dvec2; typedef packed_mediump_dvec3 packed_dvec3; typedef packed_mediump_dvec4 packed_dvec4; typedef aligned_mediump_dmat2 aligned_dmat2; typedef aligned_mediump_dmat3 aligned_dmat3; typedef aligned_mediump_dmat4 aligned_dmat4; typedef packed_mediump_dmat2 packed_dmat2; typedef packed_mediump_dmat3 packed_dmat3; typedef packed_mediump_dmat4 packed_dmat4; typedef aligned_mediump_dmat2x2 aligned_dmat2x2; typedef aligned_mediump_dmat2x3 aligned_dmat2x3; typedef aligned_mediump_dmat2x4 aligned_dmat2x4; typedef aligned_mediump_dmat3x2 aligned_dmat3x2; typedef aligned_mediump_dmat3x3 aligned_dmat3x3; typedef aligned_mediump_dmat3x4 aligned_dmat3x4; typedef aligned_mediump_dmat4x2 aligned_dmat4x2; typedef aligned_mediump_dmat4x3 aligned_dmat4x3; typedef aligned_mediump_dmat4x4 aligned_dmat4x4; typedef packed_mediump_dmat2x2 packed_dmat2x2; typedef packed_mediump_dmat2x3 packed_dmat2x3; typedef packed_mediump_dmat2x4 packed_dmat2x4; typedef packed_mediump_dmat3x2 packed_dmat3x2; typedef packed_mediump_dmat3x3 packed_dmat3x3; typedef packed_mediump_dmat3x4 packed_dmat3x4; typedef packed_mediump_dmat4x2 packed_dmat4x2; typedef packed_mediump_dmat4x3 packed_dmat4x3; typedef packed_mediump_dmat4x4 packed_dmat4x4; #else //defined(GLM_PRECISION_HIGHP_DOUBLE) /// 1 component vector aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dvec1 aligned_dvec1; /// 2 components vector aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dvec2 aligned_dvec2; /// 3 components vector aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dvec3 aligned_dvec3; /// 4 components vector aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dvec4 aligned_dvec4; /// 1 component vector tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dvec1 packed_dvec1; /// 2 components vector tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dvec2 packed_dvec2; /// 3 components vector tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dvec3 packed_dvec3; /// 4 components vector tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dvec4 packed_dvec4; /// 2 by 2 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat2 aligned_dmat2; /// 3 by 3 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat3 aligned_dmat3; /// 4 by 4 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat4 aligned_dmat4; /// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat2 packed_dmat2; /// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat3 packed_dmat3; /// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat4 packed_dmat4; /// 2 by 2 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat2x2 aligned_dmat2x2; /// 2 by 3 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat2x3 aligned_dmat2x3; /// 2 by 4 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat2x4 aligned_dmat2x4; /// 3 by 2 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat3x2 aligned_dmat3x2; /// 3 by 3 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat3x3 aligned_dmat3x3; /// 3 by 4 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat3x4 aligned_dmat3x4; /// 4 by 2 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat4x2 aligned_dmat4x2; /// 4 by 3 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat4x3 aligned_dmat4x3; /// 4 by 4 matrix tightly aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dmat4x4 aligned_dmat4x4; /// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat2x2 packed_dmat2x2; /// 2 by 3 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat2x3 packed_dmat2x3; /// 2 by 4 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat2x4 packed_dmat2x4; /// 3 by 2 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat3x2 packed_dmat3x2; /// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat3x3 packed_dmat3x3; /// 3 by 4 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat3x4 packed_dmat3x4; /// 4 by 2 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat4x2 packed_dmat4x2; /// 4 by 3 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat4x3 packed_dmat4x3; /// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dmat4x4 packed_dmat4x4; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_LOWP_INT)) typedef aligned_lowp_ivec1 aligned_ivec1; typedef aligned_lowp_ivec2 aligned_ivec2; typedef aligned_lowp_ivec3 aligned_ivec3; typedef aligned_lowp_ivec4 aligned_ivec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef aligned_mediump_ivec1 aligned_ivec1; typedef aligned_mediump_ivec2 aligned_ivec2; typedef aligned_mediump_ivec3 aligned_ivec3; typedef aligned_mediump_ivec4 aligned_ivec4; #else //defined(GLM_PRECISION_HIGHP_INT) /// 1 component vector aligned in memory of signed integer numbers. typedef aligned_highp_ivec1 aligned_ivec1; /// 2 components vector aligned in memory of signed integer numbers. typedef aligned_highp_ivec2 aligned_ivec2; /// 3 components vector aligned in memory of signed integer numbers. typedef aligned_highp_ivec3 aligned_ivec3; /// 4 components vector aligned in memory of signed integer numbers. typedef aligned_highp_ivec4 aligned_ivec4; /// 1 component vector tightly packed in memory of signed integer numbers. typedef packed_highp_ivec1 packed_ivec1; /// 2 components vector tightly packed in memory of signed integer numbers. typedef packed_highp_ivec2 packed_ivec2; /// 3 components vector tightly packed in memory of signed integer numbers. typedef packed_highp_ivec3 packed_ivec3; /// 4 components vector tightly packed in memory of signed integer numbers. typedef packed_highp_ivec4 packed_ivec4; #endif//GLM_PRECISION // -- Unsigned integer definition -- #if(defined(GLM_PRECISION_LOWP_UINT)) typedef aligned_lowp_uvec1 aligned_uvec1; typedef aligned_lowp_uvec2 aligned_uvec2; typedef aligned_lowp_uvec3 aligned_uvec3; typedef aligned_lowp_uvec4 aligned_uvec4; #elif(defined(GLM_PRECISION_MEDIUMP_UINT)) typedef aligned_mediump_uvec1 aligned_uvec1; typedef aligned_mediump_uvec2 aligned_uvec2; typedef aligned_mediump_uvec3 aligned_uvec3; typedef aligned_mediump_uvec4 aligned_uvec4; #else //defined(GLM_PRECISION_HIGHP_UINT) /// 1 component vector aligned in memory of unsigned integer numbers. typedef aligned_highp_uvec1 aligned_uvec1; /// 2 components vector aligned in memory of unsigned integer numbers. typedef aligned_highp_uvec2 aligned_uvec2; /// 3 components vector aligned in memory of unsigned integer numbers. typedef aligned_highp_uvec3 aligned_uvec3; /// 4 components vector aligned in memory of unsigned integer numbers. typedef aligned_highp_uvec4 aligned_uvec4; /// 1 component vector tightly packed in memory of unsigned integer numbers. typedef packed_highp_uvec1 packed_uvec1; /// 2 components vector tightly packed in memory of unsigned integer numbers. typedef packed_highp_uvec2 packed_uvec2; /// 3 components vector tightly packed in memory of unsigned integer numbers. typedef packed_highp_uvec3 packed_uvec3; /// 4 components vector tightly packed in memory of unsigned integer numbers. typedef packed_highp_uvec4 packed_uvec4; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_LOWP_BOOL)) typedef aligned_lowp_bvec1 aligned_bvec1; typedef aligned_lowp_bvec2 aligned_bvec2; typedef aligned_lowp_bvec3 aligned_bvec3; typedef aligned_lowp_bvec4 aligned_bvec4; #elif(defined(GLM_PRECISION_MEDIUMP_BOOL)) typedef aligned_mediump_bvec1 aligned_bvec1; typedef aligned_mediump_bvec2 aligned_bvec2; typedef aligned_mediump_bvec3 aligned_bvec3; typedef aligned_mediump_bvec4 aligned_bvec4; #else //defined(GLM_PRECISION_HIGHP_BOOL) /// 1 component vector aligned in memory of bool values. typedef aligned_highp_bvec1 aligned_bvec1; /// 2 components vector aligned in memory of bool values. typedef aligned_highp_bvec2 aligned_bvec2; /// 3 components vector aligned in memory of bool values. typedef aligned_highp_bvec3 aligned_bvec3; /// 4 components vector aligned in memory of bool values. typedef aligned_highp_bvec4 aligned_bvec4; /// 1 components vector tightly packed in memory of bool values. typedef packed_highp_bvec1 packed_bvec1; /// 2 components vector tightly packed in memory of bool values. typedef packed_highp_bvec2 packed_bvec2; /// 3 components vector tightly packed in memory of bool values. typedef packed_highp_bvec3 packed_bvec3; /// 4 components vector tightly packed in memory of bool values. typedef packed_highp_bvec4 packed_bvec4; #endif//GLM_PRECISION /// @} }//namespace glm ================================================ FILE: android/src/glm/gtc/type_precision.hpp ================================================ /// @ref gtc_type_precision /// @file glm/gtc/type_precision.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtc_type_precision GLM_GTC_type_precision /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines specific C++-based qualifier types. #pragma once // Dependency: #include "../gtc/quaternion.hpp" #include "../gtc/vec1.hpp" #include "../ext/vector_int1_sized.hpp" #include "../ext/vector_int2_sized.hpp" #include "../ext/vector_int3_sized.hpp" #include "../ext/vector_int4_sized.hpp" #include "../ext/scalar_int_sized.hpp" #include "../ext/vector_uint1_sized.hpp" #include "../ext/vector_uint2_sized.hpp" #include "../ext/vector_uint3_sized.hpp" #include "../ext/vector_uint4_sized.hpp" #include "../ext/scalar_uint_sized.hpp" #include "../detail/type_vec2.hpp" #include "../detail/type_vec3.hpp" #include "../detail/type_vec4.hpp" #include "../detail/type_mat2x2.hpp" #include "../detail/type_mat2x3.hpp" #include "../detail/type_mat2x4.hpp" #include "../detail/type_mat3x2.hpp" #include "../detail/type_mat3x3.hpp" #include "../detail/type_mat3x4.hpp" #include "../detail/type_mat4x2.hpp" #include "../detail/type_mat4x3.hpp" #include "../detail/type_mat4x4.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_type_precision extension included") #endif namespace glm { /////////////////////////// // Signed int vector types /// @addtogroup gtc_type_precision /// @{ /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8; /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16; /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32; /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64; /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8_t; /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16_t; /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32_t; /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64_t; /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_i8; /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_i16; /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_i32; /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_i64; /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8; /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16; /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32; /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64; /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8_t; /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16_t; /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32_t; /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64_t; /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_i8; /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_i16; /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_i32; /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_i64; /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8; /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16; /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_int32; /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64; /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8_t; /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16_t; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_int32_t; /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64_t; /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_i8; /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_i16; /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_i32; /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_i64; #if GLM_HAS_EXTENDED_INTEGER_TYPE using std::int8_t; using std::int16_t; using std::int32_t; using std::int64_t; #else /// 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 int8_t; /// 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 int16_t; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 int32_t; /// 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 int64_t; #endif /// 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 i8; /// 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 i16; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 i32; /// 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 i64; ///////////////////////////// // Unsigned int vector types /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8; /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16; /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32; /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64; /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8_t; /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16_t; /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32_t; /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64_t; /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_u8; /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_u16; /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_u32; /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_u64; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8_t; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16_t; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32_t; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64_t; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_u8; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_u16; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_u32; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_u64; /// High qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8; /// High qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16; /// High qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32; /// High qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64; /// High qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8_t; /// High qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16_t; /// High qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32_t; /// High qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64_t; /// High qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_u8; /// High qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_u16; /// High qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_u32; /// High qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_u64; #if GLM_HAS_EXTENDED_INTEGER_TYPE using std::uint8_t; using std::uint16_t; using std::uint32_t; using std::uint64_t; #else /// Default qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 uint8_t; /// Default qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 uint16_t; /// Default qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 uint32_t; /// Default qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 uint64_t; #endif /// Default qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 u8; /// Default qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 u16; /// Default qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 u32; /// Default qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 u64; ////////////////////// // Float vector types /// Single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float float32; /// Double-qualifier floating-point scalar. /// @see gtc_type_precision typedef double float64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_float32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_float64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_float32_t; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_float64_t; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_f32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_f64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_float32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_float64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_float32_t; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_float64_t; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_f32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_f64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_float32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_float64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_float32_t; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_float64_t; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_f32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_f64; /// Medium 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 mediump_float32; /// Medium 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 mediump_float64; /// Medium 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 mediump_float32_t; /// Medium 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 mediump_float64_t; /// Medium 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 mediump_f32; /// Medium 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 mediump_f64; /// High 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 highp_float32; /// High 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 highp_float64; /// High 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 highp_float32_t; /// High 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 highp_float64_t; /// High 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 highp_f32; /// High 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 highp_f64; #if(defined(GLM_PRECISION_LOWP_FLOAT)) /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float32_t float32_t; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float64_t float64_t; /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_f32 f32; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_f64 f64; #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float32 float32_t; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float64 float64_t; /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float32 f32; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float64 f64; #else//(defined(GLM_PRECISION_HIGHP_FLOAT)) /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float32_t float32_t; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float64_t float64_t; /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float32_t f32; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float64_t f64; #endif /// Low single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, lowp> lowp_fvec1; /// Low single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, float, lowp> lowp_fvec2; /// Low single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, float, lowp> lowp_fvec3; /// Low single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, float, lowp> lowp_fvec4; /// Medium single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, mediump> mediump_fvec1; /// Medium Single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, float, mediump> mediump_fvec2; /// Medium Single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, float, mediump> mediump_fvec3; /// Medium Single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, float, mediump> mediump_fvec4; /// High single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, highp> highp_fvec1; /// High Single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, float, highp> highp_fvec2; /// High Single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, float, highp> highp_fvec3; /// High Single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, float, highp> highp_fvec4; /// Low single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, lowp> lowp_f32vec1; /// Low single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, f32, lowp> lowp_f32vec2; /// Low single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, f32, lowp> lowp_f32vec3; /// Low single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, f32, lowp> lowp_f32vec4; /// Medium single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, mediump> mediump_f32vec1; /// Medium single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, f32, mediump> mediump_f32vec2; /// Medium single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, f32, mediump> mediump_f32vec3; /// Medium single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, f32, mediump> mediump_f32vec4; /// High single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, highp> highp_f32vec1; /// High single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f32, highp> highp_f32vec2; /// High single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f32, highp> highp_f32vec3; /// High single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f32, highp> highp_f32vec4; /// Low double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, lowp> lowp_f64vec1; /// Low double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, lowp> lowp_f64vec2; /// Low double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, lowp> lowp_f64vec3; /// Low double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, lowp> lowp_f64vec4; /// Medium double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, mediump> mediump_f64vec1; /// Medium double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, mediump> mediump_f64vec2; /// Medium double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, mediump> mediump_f64vec3; /// Medium double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, mediump> mediump_f64vec4; /// High double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, highp> highp_f64vec1; /// High double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, highp> highp_f64vec2; /// High double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, highp> highp_f64vec3; /// High double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, highp> highp_f64vec4; ////////////////////// // Float matrix types /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef lowp_f32 lowp_fmat1x1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, lowp> lowp_fmat2x2; /// Low single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, lowp> lowp_fmat2x3; /// Low single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, lowp> lowp_fmat2x4; /// Low single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, lowp> lowp_fmat3x2; /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, lowp> lowp_fmat3x3; /// Low single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, lowp> lowp_fmat3x4; /// Low single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, lowp> lowp_fmat4x2; /// Low single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, lowp> lowp_fmat4x3; /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, lowp> lowp_fmat4x4; /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef lowp_fmat1x1 lowp_fmat1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef lowp_fmat2x2 lowp_fmat2; /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef lowp_fmat3x3 lowp_fmat3; /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef lowp_fmat4x4 lowp_fmat4; /// Medium single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef mediump_f32 mediump_fmat1x1; /// Medium single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, mediump> mediump_fmat2x2; /// Medium single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, mediump> mediump_fmat2x3; /// Medium single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, mediump> mediump_fmat2x4; /// Medium single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, mediump> mediump_fmat3x2; /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, mediump> mediump_fmat3x3; /// Medium single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, mediump> mediump_fmat3x4; /// Medium single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, mediump> mediump_fmat4x2; /// Medium single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, mediump> mediump_fmat4x3; /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, mediump> mediump_fmat4x4; /// Medium single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef mediump_fmat1x1 mediump_fmat1; /// Medium single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mediump_fmat2x2 mediump_fmat2; /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mediump_fmat3x3 mediump_fmat3; /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mediump_fmat4x4 mediump_fmat4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef highp_f32 highp_fmat1x1; /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, highp> highp_fmat2x2; /// High single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, highp> highp_fmat2x3; /// High single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, highp> highp_fmat2x4; /// High single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, highp> highp_fmat3x2; /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, highp> highp_fmat3x3; /// High single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, highp> highp_fmat3x4; /// High single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, highp> highp_fmat4x2; /// High single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, highp> highp_fmat4x3; /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, highp> highp_fmat4x4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef highp_fmat1x1 highp_fmat1; /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_fmat2x2 highp_fmat2; /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_fmat3x3 highp_fmat3; /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_fmat4x4 highp_fmat4; /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 lowp_f32mat1x1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, lowp> lowp_f32mat2x2; /// Low single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, lowp> lowp_f32mat2x3; /// Low single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, lowp> lowp_f32mat2x4; /// Low single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, lowp> lowp_f32mat3x2; /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, lowp> lowp_f32mat3x3; /// Low single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, lowp> lowp_f32mat3x4; /// Low single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, lowp> lowp_f32mat4x2; /// Low single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, lowp> lowp_f32mat4x3; /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, lowp> lowp_f32mat4x4; /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 lowp_f32mat1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef lowp_f32mat2x2 lowp_f32mat2; /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef lowp_f32mat3x3 lowp_f32mat3; /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef lowp_f32mat4x4 lowp_f32mat4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 mediump_f32mat1x1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, mediump> mediump_f32mat2x2; /// Medium single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, mediump> mediump_f32mat2x3; /// Medium single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, mediump> mediump_f32mat2x4; /// Medium single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, mediump> mediump_f32mat3x2; /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, mediump> mediump_f32mat3x3; /// Medium single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, mediump> mediump_f32mat3x4; /// Medium single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, mediump> mediump_f32mat4x2; /// Medium single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, mediump> mediump_f32mat4x3; /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, mediump> mediump_f32mat4x4; /// Medium single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f32mat1; /// Medium single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mediump_f32mat2x2 mediump_f32mat2; /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mediump_f32mat3x3 mediump_f32mat3; /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mediump_f32mat4x4 mediump_f32mat4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 highp_f32mat1x1; /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, highp> highp_f32mat2x2; /// High single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, highp> highp_f32mat2x3; /// High single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, highp> highp_f32mat2x4; /// High single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, highp> highp_f32mat3x2; /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, highp> highp_f32mat3x3; /// High single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, highp> highp_f32mat3x4; /// High single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, highp> highp_f32mat4x2; /// High single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, highp> highp_f32mat4x3; /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, highp> highp_f32mat4x4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f32mat1; /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f32mat2x2 highp_f32mat2; /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f32mat3x3 highp_f32mat3; /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f32mat4x4 highp_f32mat4; /// Low double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 lowp_f64mat1x1; /// Low double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, lowp> lowp_f64mat2x2; /// Low double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, lowp> lowp_f64mat2x3; /// Low double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, lowp> lowp_f64mat2x4; /// Low double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, lowp> lowp_f64mat3x2; /// Low double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, lowp> lowp_f64mat3x3; /// Low double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, lowp> lowp_f64mat3x4; /// Low double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, lowp> lowp_f64mat4x2; /// Low double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, lowp> lowp_f64mat4x3; /// Low double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, lowp> lowp_f64mat4x4; /// Low double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef lowp_f64mat1x1 lowp_f64mat1; /// Low double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef lowp_f64mat2x2 lowp_f64mat2; /// Low double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef lowp_f64mat3x3 lowp_f64mat3; /// Low double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef lowp_f64mat4x4 lowp_f64mat4; /// Medium double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 Highp_f64mat1x1; /// Medium double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, mediump> mediump_f64mat2x2; /// Medium double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, mediump> mediump_f64mat2x3; /// Medium double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, mediump> mediump_f64mat2x4; /// Medium double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, mediump> mediump_f64mat3x2; /// Medium double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, mediump> mediump_f64mat3x3; /// Medium double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, mediump> mediump_f64mat3x4; /// Medium double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, mediump> mediump_f64mat4x2; /// Medium double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, mediump> mediump_f64mat4x3; /// Medium double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, mediump> mediump_f64mat4x4; /// Medium double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef mediump_f64mat1x1 mediump_f64mat1; /// Medium double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mediump_f64mat2x2 mediump_f64mat2; /// Medium double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mediump_f64mat3x3 mediump_f64mat3; /// Medium double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mediump_f64mat4x4 mediump_f64mat4; /// High double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 highp_f64mat1x1; /// High double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, highp> highp_f64mat2x2; /// High double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, highp> highp_f64mat2x3; /// High double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, highp> highp_f64mat2x4; /// High double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, highp> highp_f64mat3x2; /// High double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, highp> highp_f64mat3x3; /// High double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, highp> highp_f64mat3x4; /// High double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, highp> highp_f64mat4x2; /// High double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, highp> highp_f64mat4x3; /// High double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, highp> highp_f64mat4x4; /// High double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef highp_f64mat1x1 highp_f64mat1; /// High double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f64mat2x2 highp_f64mat2; /// High double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f64mat3x3 highp_f64mat3; /// High double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f64mat4x4 highp_f64mat4; ///////////////////////////// // Signed int vector types /// Low qualifier signed integer vector of 1 component type. /// @see gtc_type_precision typedef vec<1, int, lowp> lowp_ivec1; /// Low qualifier signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, int, lowp> lowp_ivec2; /// Low qualifier signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, int, lowp> lowp_ivec3; /// Low qualifier signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, int, lowp> lowp_ivec4; /// Medium qualifier signed integer vector of 1 component type. /// @see gtc_type_precision typedef vec<1, int, mediump> mediump_ivec1; /// Medium qualifier signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, int, mediump> mediump_ivec2; /// Medium qualifier signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, int, mediump> mediump_ivec3; /// Medium qualifier signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, int, mediump> mediump_ivec4; /// High qualifier signed integer vector of 1 component type. /// @see gtc_type_precision typedef vec<1, int, highp> highp_ivec1; /// High qualifier signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, int, highp> highp_ivec2; /// High qualifier signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, int, highp> highp_ivec3; /// High qualifier signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, int, highp> highp_ivec4; /// Low qualifier 8 bit signed integer vector of 1 component type. /// @see gtc_type_precision typedef vec<1, i8, lowp> lowp_i8vec1; /// Low qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, lowp> lowp_i8vec2; /// Low qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, lowp> lowp_i8vec3; /// Low qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, lowp> lowp_i8vec4; /// Medium qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i8, mediump> mediump_i8vec1; /// Medium qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, mediump> mediump_i8vec2; /// Medium qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, mediump> mediump_i8vec3; /// Medium qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, mediump> mediump_i8vec4; /// High qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i8, highp> highp_i8vec1; /// High qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, highp> highp_i8vec2; /// High qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, highp> highp_i8vec3; /// High qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, highp> highp_i8vec4; /// Low qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, lowp> lowp_i16vec1; /// Low qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, lowp> lowp_i16vec2; /// Low qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, lowp> lowp_i16vec3; /// Low qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, lowp> lowp_i16vec4; /// Medium qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, mediump> mediump_i16vec1; /// Medium qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, mediump> mediump_i16vec2; /// Medium qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, mediump> mediump_i16vec3; /// Medium qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, mediump> mediump_i16vec4; /// High qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, highp> highp_i16vec1; /// High qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, highp> highp_i16vec2; /// High qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, highp> highp_i16vec3; /// High qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, highp> highp_i16vec4; /// Low qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, lowp> lowp_i32vec1; /// Low qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, lowp> lowp_i32vec2; /// Low qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, lowp> lowp_i32vec3; /// Low qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, lowp> lowp_i32vec4; /// Medium qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, mediump> mediump_i32vec1; /// Medium qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, mediump> mediump_i32vec2; /// Medium qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, mediump> mediump_i32vec3; /// Medium qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, mediump> mediump_i32vec4; /// High qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, highp> highp_i32vec1; /// High qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, highp> highp_i32vec2; /// High qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, highp> highp_i32vec3; /// High qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, highp> highp_i32vec4; /// Low qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, lowp> lowp_i64vec1; /// Low qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, lowp> lowp_i64vec2; /// Low qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, lowp> lowp_i64vec3; /// Low qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, lowp> lowp_i64vec4; /// Medium qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, mediump> mediump_i64vec1; /// Medium qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, mediump> mediump_i64vec2; /// Medium qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, mediump> mediump_i64vec3; /// Medium qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, mediump> mediump_i64vec4; /// High qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, highp> highp_i64vec1; /// High qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, highp> highp_i64vec2; /// High qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, highp> highp_i64vec3; /// High qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, highp> highp_i64vec4; ///////////////////////////// // Unsigned int vector types /// Low qualifier unsigned integer vector of 1 component type. /// @see gtc_type_precision typedef vec<1, uint, lowp> lowp_uvec1; /// Low qualifier unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, uint, lowp> lowp_uvec2; /// Low qualifier unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, uint, lowp> lowp_uvec3; /// Low qualifier unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, uint, lowp> lowp_uvec4; /// Medium qualifier unsigned integer vector of 1 component type. /// @see gtc_type_precision typedef vec<1, uint, mediump> mediump_uvec1; /// Medium qualifier unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, uint, mediump> mediump_uvec2; /// Medium qualifier unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, uint, mediump> mediump_uvec3; /// Medium qualifier unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, uint, mediump> mediump_uvec4; /// High qualifier unsigned integer vector of 1 component type. /// @see gtc_type_precision typedef vec<1, uint, highp> highp_uvec1; /// High qualifier unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, uint, highp> highp_uvec2; /// High qualifier unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, uint, highp> highp_uvec3; /// High qualifier unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, uint, highp> highp_uvec4; /// Low qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, lowp> lowp_u8vec1; /// Low qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, lowp> lowp_u8vec2; /// Low qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, lowp> lowp_u8vec3; /// Low qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, lowp> lowp_u8vec4; /// Medium qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, mediump> mediump_u8vec1; /// Medium qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, mediump> mediump_u8vec2; /// Medium qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, mediump> mediump_u8vec3; /// Medium qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, mediump> mediump_u8vec4; /// High qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, highp> highp_u8vec1; /// High qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, highp> highp_u8vec2; /// High qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, highp> highp_u8vec3; /// High qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, highp> highp_u8vec4; /// Low qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, lowp> lowp_u16vec1; /// Low qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, lowp> lowp_u16vec2; /// Low qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, lowp> lowp_u16vec3; /// Low qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, lowp> lowp_u16vec4; /// Medium qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, mediump> mediump_u16vec1; /// Medium qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, mediump> mediump_u16vec2; /// Medium qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, mediump> mediump_u16vec3; /// Medium qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, mediump> mediump_u16vec4; /// High qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, highp> highp_u16vec1; /// High qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, highp> highp_u16vec2; /// High qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, highp> highp_u16vec3; /// High qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, highp> highp_u16vec4; /// Low qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, lowp> lowp_u32vec1; /// Low qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, lowp> lowp_u32vec2; /// Low qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, lowp> lowp_u32vec3; /// Low qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, lowp> lowp_u32vec4; /// Medium qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, mediump> mediump_u32vec1; /// Medium qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, mediump> mediump_u32vec2; /// Medium qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, mediump> mediump_u32vec3; /// Medium qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, mediump> mediump_u32vec4; /// High qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, highp> highp_u32vec1; /// High qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, highp> highp_u32vec2; /// High qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, highp> highp_u32vec3; /// High qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, highp> highp_u32vec4; /// Low qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, lowp> lowp_u64vec1; /// Low qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, lowp> lowp_u64vec2; /// Low qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, lowp> lowp_u64vec3; /// Low qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, lowp> lowp_u64vec4; /// Medium qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, mediump> mediump_u64vec1; /// Medium qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, mediump> mediump_u64vec2; /// Medium qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, mediump> mediump_u64vec3; /// Medium qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, mediump> mediump_u64vec4; /// High qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, highp> highp_u64vec1; /// High qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, highp> highp_u64vec2; /// High qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, highp> highp_u64vec3; /// High qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, highp> highp_u64vec4; ////////////////////// // Float vector types /// 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 float32_t; /// 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 f32; # ifndef GLM_FORCE_SINGLE_ONLY /// 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 float64_t; /// 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 f64; # endif//GLM_FORCE_SINGLE_ONLY /// Single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, defaultp> fvec1; /// Single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, float, defaultp> fvec2; /// Single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, float, defaultp> fvec3; /// Single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, float, defaultp> fvec4; /// Single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, defaultp> f32vec1; /// Single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f32, defaultp> f32vec2; /// Single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f32, defaultp> f32vec3; /// Single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f32, defaultp> f32vec4; # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, defaultp> f64vec1; /// Double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, defaultp> f64vec2; /// Double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, defaultp> f64vec3; /// Double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, defaultp> f64vec4; # endif//GLM_FORCE_SINGLE_ONLY ////////////////////// // Float matrix types /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 fmat1; /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> fmat2; /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> fmat3; /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> fmat4; /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 fmat1x1; /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> fmat2x2; /// Single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, defaultp> fmat2x3; /// Single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, defaultp> fmat2x4; /// Single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, defaultp> fmat3x2; /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> fmat3x3; /// Single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, defaultp> fmat3x4; /// Single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, defaultp> fmat4x2; /// Single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, defaultp> fmat4x3; /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> fmat4x4; /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f32mat1; /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> f32mat2; /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> f32mat3; /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> f32mat4; /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 f32mat1x1; /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> f32mat2x2; /// Single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, defaultp> f32mat2x3; /// Single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, defaultp> f32mat2x4; /// Single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, defaultp> f32mat3x2; /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> f32mat3x3; /// Single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, defaultp> f32mat3x4; /// Single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, defaultp> f32mat4x2; /// Single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, defaultp> f32mat4x3; /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> f32mat4x4; # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f64mat1; /// Double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, defaultp> f64mat2; /// Double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, defaultp> f64mat3; /// Double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, defaultp> f64mat4; /// Double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 f64mat1x1; /// Double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, defaultp> f64mat2x2; /// Double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, defaultp> f64mat2x3; /// Double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, defaultp> f64mat2x4; /// Double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, defaultp> f64mat3x2; /// Double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, defaultp> f64mat3x3; /// Double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, defaultp> f64mat3x4; /// Double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, defaultp> f64mat4x2; /// Double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, defaultp> f64mat4x3; /// Double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, defaultp> f64mat4x4; # endif//GLM_FORCE_SINGLE_ONLY ////////////////////////// // Quaternion types /// Single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef qua f32quat; /// Low single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef qua lowp_f32quat; /// Low double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef qua lowp_f64quat; /// Medium single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef qua mediump_f32quat; # ifndef GLM_FORCE_SINGLE_ONLY /// Medium double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef qua mediump_f64quat; /// High single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef qua highp_f32quat; /// High double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef qua highp_f64quat; /// Double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef qua f64quat; # endif//GLM_FORCE_SINGLE_ONLY /// @} }//namespace glm #include "type_precision.inl" ================================================ FILE: android/src/glm/gtc/type_precision.inl ================================================ /// @ref gtc_precision namespace glm { } ================================================ FILE: android/src/glm/gtc/type_ptr.hpp ================================================ /// @ref gtc_type_ptr /// @file glm/gtc/type_ptr.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtc_type_ptr GLM_GTC_type_ptr /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Handles the interaction between pointers and vector, matrix types. /// /// This extension defines an overloaded function, glm::value_ptr. It returns /// a pointer to the memory layout of the object. Matrix types store their values /// in column-major order. /// /// This is useful for uploading data to matrices or copying data to buffer objects. /// /// Example: /// @code /// #include /// #include /// /// glm::vec3 aVector(3); /// glm::mat4 someMatrix(1.0); /// /// glUniform3fv(uniformLoc, 1, glm::value_ptr(aVector)); /// glUniformMatrix4fv(uniformMatrixLoc, 1, GL_FALSE, glm::value_ptr(someMatrix)); /// @endcode /// /// need to be included to use the features of this extension. #pragma once // Dependency: #include "../gtc/quaternion.hpp" #include "../gtc/vec1.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../mat2x2.hpp" #include "../mat2x3.hpp" #include "../mat2x4.hpp" #include "../mat3x2.hpp" #include "../mat3x3.hpp" #include "../mat3x4.hpp" #include "../mat4x2.hpp" #include "../mat4x3.hpp" #include "../mat4x4.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_type_ptr extension included") #endif namespace glm { /// @addtogroup gtc_type_ptr /// @{ /// Return the constant address to the data of the input parameter. /// @see gtc_type_ptr template GLM_FUNC_DECL typename genType::value_type const * value_ptr(genType const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<1, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<2, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<3, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<4, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<1, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<2, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<3, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<4, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<1, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<2, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<3, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<4, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<1, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<2, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<3, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<4, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, defaultp> make_vec2(T const * const ptr); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, defaultp> make_vec3(T const * const ptr); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, defaultp> make_vec4(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<2, 2, T, defaultp> make_mat2x2(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<2, 3, T, defaultp> make_mat2x3(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<2, 4, T, defaultp> make_mat2x4(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<3, 2, T, defaultp> make_mat3x2(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<3, 3, T, defaultp> make_mat3x3(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<3, 4, T, defaultp> make_mat3x4(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<4, 2, T, defaultp> make_mat4x2(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<4, 3, T, defaultp> make_mat4x3(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<4, 4, T, defaultp> make_mat4x4(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<2, 2, T, defaultp> make_mat2(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<3, 3, T, defaultp> make_mat3(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<4, 4, T, defaultp> make_mat4(T const * const ptr); /// Build a quaternion from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL qua make_quat(T const * const ptr); /// @} }//namespace glm #include "type_ptr.inl" ================================================ FILE: android/src/glm/gtc/type_ptr.inl ================================================ /// @ref gtc_type_ptr #include namespace glm { /// @addtogroup gtc_type_ptr /// @{ template GLM_FUNC_QUALIFIER T const* value_ptr(vec<2, T, Q> const& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T* value_ptr(vec<2, T, Q>& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T const * value_ptr(vec<3, T, Q> const& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T* value_ptr(vec<3, T, Q>& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T const* value_ptr(vec<4, T, Q> const& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T* value_ptr(vec<4, T, Q>& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 2, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 2, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 3, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 3, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 4, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 4, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 3, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 3, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 2, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 2, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 4, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 4, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 2, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 2, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 4, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 4, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 3, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T * value_ptr(mat<4, 3, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const * value_ptr(qua const& q) { return &(q[0]); } template GLM_FUNC_QUALIFIER T* value_ptr(qua& q) { return &(q[0]); } template inline vec<1, T, Q> make_vec1(vec<1, T, Q> const& v) { return v; } template inline vec<1, T, Q> make_vec1(vec<2, T, Q> const& v) { return vec<1, T, Q>(v); } template inline vec<1, T, Q> make_vec1(vec<3, T, Q> const& v) { return vec<1, T, Q>(v); } template inline vec<1, T, Q> make_vec1(vec<4, T, Q> const& v) { return vec<1, T, Q>(v); } template inline vec<2, T, Q> make_vec2(vec<1, T, Q> const& v) { return vec<2, T, Q>(v.x, static_cast(0)); } template inline vec<2, T, Q> make_vec2(vec<2, T, Q> const& v) { return v; } template inline vec<2, T, Q> make_vec2(vec<3, T, Q> const& v) { return vec<2, T, Q>(v); } template inline vec<2, T, Q> make_vec2(vec<4, T, Q> const& v) { return vec<2, T, Q>(v); } template inline vec<3, T, Q> make_vec3(vec<1, T, Q> const& v) { return vec<3, T, Q>(v.x, static_cast(0), static_cast(0)); } template inline vec<3, T, Q> make_vec3(vec<2, T, Q> const& v) { return vec<3, T, Q>(v.x, v.y, static_cast(0)); } template inline vec<3, T, Q> make_vec3(vec<3, T, Q> const& v) { return v; } template inline vec<3, T, Q> make_vec3(vec<4, T, Q> const& v) { return vec<3, T, Q>(v); } template inline vec<4, T, Q> make_vec4(vec<1, T, Q> const& v) { return vec<4, T, Q>(v.x, static_cast(0), static_cast(0), static_cast(1)); } template inline vec<4, T, Q> make_vec4(vec<2, T, Q> const& v) { return vec<4, T, Q>(v.x, v.y, static_cast(0), static_cast(1)); } template inline vec<4, T, Q> make_vec4(vec<3, T, Q> const& v) { return vec<4, T, Q>(v.x, v.y, v.z, static_cast(1)); } template inline vec<4, T, Q> make_vec4(vec<4, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER vec<2, T, defaultp> make_vec2(T const *const ptr) { vec<2, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(vec<2, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER vec<3, T, defaultp> make_vec3(T const *const ptr) { vec<3, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(vec<3, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER vec<4, T, defaultp> make_vec4(T const *const ptr) { vec<4, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(vec<4, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> make_mat2x2(T const *const ptr) { mat<2, 2, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<2, 2, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<2, 3, T, defaultp> make_mat2x3(T const *const ptr) { mat<2, 3, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<2, 3, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, defaultp> make_mat2x4(T const *const ptr) { mat<2, 4, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<2, 4, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, defaultp> make_mat3x2(T const *const ptr) { mat<3, 2, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<3, 2, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> make_mat3x3(T const *const ptr) { mat<3, 3, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<3, 3, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<3, 4, T, defaultp> make_mat3x4(T const *const ptr) { mat<3, 4, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<3, 4, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<4, 2, T, defaultp> make_mat4x2(T const *const ptr) { mat<4, 2, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<4, 2, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, defaultp> make_mat4x3(T const *const ptr) { mat<4, 3, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<4, 3, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> make_mat4x4(T const *const ptr) { mat<4, 4, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<4, 4, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> make_mat2(T const *const ptr) { return make_mat2x2(ptr); } template GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> make_mat3(T const *const ptr) { return make_mat3x3(ptr); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> make_mat4(T const *const ptr) { return make_mat4x4(ptr); } template GLM_FUNC_QUALIFIER qua make_quat(T const *const ptr) { qua Result; memcpy(value_ptr(Result), ptr, sizeof(qua)); return Result; } /// @} }//namespace glm ================================================ FILE: android/src/glm/gtc/ulp.hpp ================================================ /// @ref gtc_ulp /// @file glm/gtc/ulp.hpp /// /// @see core (dependence) /// /// @defgroup gtc_ulp GLM_GTC_ulp /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Allow the measurement of the accuracy of a function against a reference /// implementation. This extension works on floating-point data and provide results /// in ULP. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/_vectorize.hpp" #include "../ext/scalar_int_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_ulp extension included") #endif namespace glm { /// Return the next ULP value(s) after the input value(s). /// /// @tparam genType A floating-point scalar type. /// /// @see gtc_ulp template GLM_FUNC_DECL genType next_float(genType x); /// Return the previous ULP value(s) before the input value(s). /// /// @tparam genType A floating-point scalar type. /// /// @see gtc_ulp template GLM_FUNC_DECL genType prev_float(genType x); /// Return the value(s) ULP distance after the input value(s). /// /// @tparam genType A floating-point scalar type. /// /// @see gtc_ulp template GLM_FUNC_DECL genType next_float(genType x, int ULPs); /// Return the value(s) ULP distance before the input value(s). /// /// @tparam genType A floating-point scalar type. /// /// @see gtc_ulp template GLM_FUNC_DECL genType prev_float(genType x, int ULPs); /// Return the distance in the number of ULP between 2 single-precision floating-point scalars. /// /// @see gtc_ulp GLM_FUNC_DECL int float_distance(float x, float y); /// Return the distance in the number of ULP between 2 double-precision floating-point scalars. /// /// @see gtc_ulp GLM_FUNC_DECL int64 float_distance(double x, double y); /// Return the next ULP value(s) after the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see gtc_ulp template GLM_FUNC_DECL vec next_float(vec const& x); /// Return the value(s) ULP distance after the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see gtc_ulp template GLM_FUNC_DECL vec next_float(vec const& x, int ULPs); /// Return the value(s) ULP distance after the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see gtc_ulp template GLM_FUNC_DECL vec next_float(vec const& x, vec const& ULPs); /// Return the previous ULP value(s) before the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see gtc_ulp template GLM_FUNC_DECL vec prev_float(vec const& x); /// Return the value(s) ULP distance before the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see gtc_ulp template GLM_FUNC_DECL vec prev_float(vec const& x, int ULPs); /// Return the value(s) ULP distance before the input value(s). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point /// @tparam Q Value from qualifier enum /// /// @see gtc_ulp template GLM_FUNC_DECL vec prev_float(vec const& x, vec const& ULPs); /// Return the distance in the number of ULP between 2 single-precision floating-point scalars. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see gtc_ulp template GLM_FUNC_DECL vec float_distance(vec const& x, vec const& y); /// Return the distance in the number of ULP between 2 double-precision floating-point scalars. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see gtc_ulp template GLM_FUNC_DECL vec float_distance(vec const& x, vec const& y); /// @} }//namespace glm #include "ulp.inl" ================================================ FILE: android/src/glm/gtc/ulp.inl ================================================ /// @ref gtc_ulp #include "../ext/scalar_ulp.hpp" namespace glm { template<> GLM_FUNC_QUALIFIER float next_float(float x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::max()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return detail::nextafterf(x, FLT_MAX); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafterf(x, FLT_MAX); # else return nextafterf(x, FLT_MAX); # endif } template<> GLM_FUNC_QUALIFIER double next_float(double x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::max()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return detail::nextafter(x, std::numeric_limits::max()); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafter(x, DBL_MAX); # else return nextafter(x, DBL_MAX); # endif } template GLM_FUNC_QUALIFIER T next_float(T x, int ULPs) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'next_float' only accept floating-point input"); assert(ULPs >= 0); T temp = x; for (int i = 0; i < ULPs; ++i) temp = next_float(temp); return temp; } GLM_FUNC_QUALIFIER float prev_float(float x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::min()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return detail::nextafterf(x, FLT_MIN); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafterf(x, FLT_MIN); # else return nextafterf(x, FLT_MIN); # endif } GLM_FUNC_QUALIFIER double prev_float(double x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::min()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return _nextafter(x, DBL_MIN); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafter(x, DBL_MIN); # else return nextafter(x, DBL_MIN); # endif } template GLM_FUNC_QUALIFIER T prev_float(T x, int ULPs) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'prev_float' only accept floating-point input"); assert(ULPs >= 0); T temp = x; for (int i = 0; i < ULPs; ++i) temp = prev_float(temp); return temp; } GLM_FUNC_QUALIFIER int float_distance(float x, float y) { detail::float_t const a(x); detail::float_t const b(y); return abs(a.i - b.i); } GLM_FUNC_QUALIFIER int64 float_distance(double x, double y) { detail::float_t const a(x); detail::float_t const b(y); return abs(a.i - b.i); } template GLM_FUNC_QUALIFIER vec next_float(vec const& x) { vec Result; for (length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = next_float(x[i]); return Result; } template GLM_FUNC_QUALIFIER vec next_float(vec const& x, int ULPs) { vec Result; for (length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = next_float(x[i], ULPs); return Result; } template GLM_FUNC_QUALIFIER vec next_float(vec const& x, vec const& ULPs) { vec Result; for (length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = next_float(x[i], ULPs[i]); return Result; } template GLM_FUNC_QUALIFIER vec prev_float(vec const& x) { vec Result; for (length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prev_float(x[i]); return Result; } template GLM_FUNC_QUALIFIER vec prev_float(vec const& x, int ULPs) { vec Result; for (length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prev_float(x[i], ULPs); return Result; } template GLM_FUNC_QUALIFIER vec prev_float(vec const& x, vec const& ULPs) { vec Result; for (length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prev_float(x[i], ULPs[i]); return Result; } template GLM_FUNC_QUALIFIER vec float_distance(vec const& x, vec const& y) { vec Result; for (length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = float_distance(x[i], y[i]); return Result; } template GLM_FUNC_QUALIFIER vec float_distance(vec const& x, vec const& y) { vec Result; for (length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = float_distance(x[i], y[i]); return Result; } }//namespace glm ================================================ FILE: android/src/glm/gtc/vec1.hpp ================================================ /// @ref gtc_vec1 /// @file glm/gtc/vec1.hpp /// /// @see core (dependence) /// /// @defgroup gtc_vec1 GLM_GTC_vec1 /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Add vec1, ivec1, uvec1 and bvec1 types. #pragma once // Dependency: #include "../ext/vector_bool1.hpp" #include "../ext/vector_bool1_precision.hpp" #include "../ext/vector_float1.hpp" #include "../ext/vector_float1_precision.hpp" #include "../ext/vector_double1.hpp" #include "../ext/vector_double1_precision.hpp" #include "../ext/vector_int1.hpp" #include "../ext/vector_int1_sized.hpp" #include "../ext/vector_uint1.hpp" #include "../ext/vector_uint1_sized.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_vec1 extension included") #endif ================================================ FILE: android/src/glm/gtx/associated_min_max.hpp ================================================ /// @ref gtx_associated_min_max /// @file glm/gtx/associated_min_max.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_associated_min_max GLM_GTX_associated_min_max /// @ingroup gtx /// /// Include to use the features of this extension. /// /// @brief Min and max functions that return associated values not the compared onces. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_associated_min_max is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_associated_min_max extension included") # endif #endif namespace glm { /// @addtogroup gtx_associated_min_max /// @{ /// Minimum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMin(T x, U a, T y, U b); /// Minimum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec<2, U, Q> associatedMin( vec const& x, vec const& a, vec const& y, vec const& b); /// Minimum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( T x, const vec& a, T y, const vec& b); /// Minimum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( vec const& x, U a, vec const& y, U b); /// Minimum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMin( T x, U a, T y, U b, T z, U c); /// Minimum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c); /// Minimum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMin( T x, U a, T y, U b, T z, U c, T w, U d); /// Minimum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c, vec const& w, vec const& d); /// Minimum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( T x, vec const& a, T y, vec const& b, T z, vec const& c, T w, vec const& d); /// Minimum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( vec const& x, U a, vec const& y, U b, vec const& z, U c, vec const& w, U d); /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMax(T x, U a, T y, U b); /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec<2, U, Q> associatedMax( vec const& x, vec const& a, vec const& y, vec const& b); /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( T x, vec const& a, T y, vec const& b); /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, U a, vec const& y, U b); /// Maximum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMax( T x, U a, T y, U b, T z, U c); /// Maximum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c); /// Maximum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( T x, vec const& a, T y, vec const& b, T z, vec const& c); /// Maximum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, U a, vec const& y, U b, vec const& z, U c); /// Maximum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMax( T x, U a, T y, U b, T z, U c, T w, U d); /// Maximum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c, vec const& w, vec const& d); /// Maximum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( T x, vec const& a, T y, vec const& b, T z, vec const& c, T w, vec const& d); /// Maximum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, U a, vec const& y, U b, vec const& z, U c, vec const& w, U d); /// @} } //namespace glm #include "associated_min_max.inl" ================================================ FILE: android/src/glm/gtx/associated_min_max.inl ================================================ /// @ref gtx_associated_min_max namespace glm{ // Min comparison between 2 variables template GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b) { return x < y ? a : b; } template GLM_FUNC_QUALIFIER vec<2, U, Q> associatedMin ( vec const& x, vec const& a, vec const& y, vec const& b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] < y[i] ? a[i] : b[i]; return Result; } template GLM_FUNC_QUALIFIER vec associatedMin ( T x, const vec& a, T y, const vec& b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x < y ? a[i] : b[i]; return Result; } template GLM_FUNC_QUALIFIER vec associatedMin ( vec const& x, U a, vec const& y, U b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] < y[i] ? a : b; return Result; } // Min comparison between 3 variables template GLM_FUNC_QUALIFIER U associatedMin ( T x, U a, T y, U b, T z, U c ) { U Result = x < y ? (x < z ? a : c) : (y < z ? b : c); return Result; } template GLM_FUNC_QUALIFIER vec associatedMin ( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]); return Result; } // Min comparison between 4 variables template GLM_FUNC_QUALIFIER U associatedMin ( T x, U a, T y, U b, T z, U c, T w, U d ) { T Test1 = min(x, y); T Test2 = min(z, w); U Result1 = x < y ? a : b; U Result2 = z < w ? c : d; U Result = Test1 < Test2 ? Result1 : Result2; return Result; } // Min comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMin ( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c, vec const& w, vec const& d ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = min(x[i], y[i]); T Test2 = min(z[i], w[i]); U Result1 = x[i] < y[i] ? a[i] : b[i]; U Result2 = z[i] < w[i] ? c[i] : d[i]; Result[i] = Test1 < Test2 ? Result1 : Result2; } return Result; } // Min comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMin ( T x, vec const& a, T y, vec const& b, T z, vec const& c, T w, vec const& d ) { T Test1 = min(x, y); T Test2 = min(z, w); vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { U Result1 = x < y ? a[i] : b[i]; U Result2 = z < w ? c[i] : d[i]; Result[i] = Test1 < Test2 ? Result1 : Result2; } return Result; } // Min comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMin ( vec const& x, U a, vec const& y, U b, vec const& z, U c, vec const& w, U d ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = min(x[i], y[i]); T Test2 = min(z[i], w[i]); U Result1 = x[i] < y[i] ? a : b; U Result2 = z[i] < w[i] ? c : d; Result[i] = Test1 < Test2 ? Result1 : Result2; } return Result; } // Max comparison between 2 variables template GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b) { return x > y ? a : b; } // Max comparison between 2 variables template GLM_FUNC_QUALIFIER vec<2, U, Q> associatedMax ( vec const& x, vec const& a, vec const& y, vec const& b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] > y[i] ? a[i] : b[i]; return Result; } // Max comparison between 2 variables template GLM_FUNC_QUALIFIER vec associatedMax ( T x, vec const& a, T y, vec const& b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x > y ? a[i] : b[i]; return Result; } // Max comparison between 2 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, U a, vec const& y, U b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] > y[i] ? a : b; return Result; } // Max comparison between 3 variables template GLM_FUNC_QUALIFIER U associatedMax ( T x, U a, T y, U b, T z, U c ) { U Result = x > y ? (x > z ? a : c) : (y > z ? b : c); return Result; } // Max comparison between 3 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]); return Result; } // Max comparison between 3 variables template GLM_FUNC_QUALIFIER vec associatedMax ( T x, vec const& a, T y, vec const& b, T z, vec const& c ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]); return Result; } // Max comparison between 3 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, U a, vec const& y, U b, vec const& z, U c ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c); return Result; } // Max comparison between 4 variables template GLM_FUNC_QUALIFIER U associatedMax ( T x, U a, T y, U b, T z, U c, T w, U d ) { T Test1 = max(x, y); T Test2 = max(z, w); U Result1 = x > y ? a : b; U Result2 = z > w ? c : d; U Result = Test1 > Test2 ? Result1 : Result2; return Result; } // Max comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c, vec const& w, vec const& d ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = max(x[i], y[i]); T Test2 = max(z[i], w[i]); U Result1 = x[i] > y[i] ? a[i] : b[i]; U Result2 = z[i] > w[i] ? c[i] : d[i]; Result[i] = Test1 > Test2 ? Result1 : Result2; } return Result; } // Max comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMax ( T x, vec const& a, T y, vec const& b, T z, vec const& c, T w, vec const& d ) { T Test1 = max(x, y); T Test2 = max(z, w); vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { U Result1 = x > y ? a[i] : b[i]; U Result2 = z > w ? c[i] : d[i]; Result[i] = Test1 > Test2 ? Result1 : Result2; } return Result; } // Max comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, U a, vec const& y, U b, vec const& z, U c, vec const& w, U d ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = max(x[i], y[i]); T Test2 = max(z[i], w[i]); U Result1 = x[i] > y[i] ? a : b; U Result2 = z[i] > w[i] ? c : d; Result[i] = Test1 > Test2 ? Result1 : Result2; } return Result; } }//namespace glm ================================================ FILE: android/src/glm/gtx/bit.hpp ================================================ /// @ref gtx_bit /// @file glm/gtx/bit.hpp /// /// @see core (dependence) /// /// @defgroup gtx_bit GLM_GTX_bit /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Allow to perform bit operations on integer values #pragma once // Dependencies #include "../gtc/bitfield.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_bit is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_bit extension included") # endif #endif namespace glm { /// @addtogroup gtx_bit /// @{ /// @see gtx_bit template GLM_FUNC_DECL genIUType highestBitValue(genIUType Value); /// @see gtx_bit template GLM_FUNC_DECL genIUType lowestBitValue(genIUType Value); /// Find the highest bit set to 1 in a integer variable and return its value. /// /// @see gtx_bit template GLM_FUNC_DECL vec highestBitValue(vec const& value); /// Return the power of two number which value is just higher the input value. /// Deprecated, use ceilPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove(genIUType Value); /// Return the power of two number which value is just higher the input value. /// Deprecated, use ceilPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL vec powerOfTwoAbove(vec const& value); /// Return the power of two number which value is just lower the input value. /// Deprecated, use floorPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow(genIUType Value); /// Return the power of two number which value is just lower the input value. /// Deprecated, use floorPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL vec powerOfTwoBelow(vec const& value); /// Return the power of two number which value is the closet to the input value. /// Deprecated, use roundPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest(genIUType Value); /// Return the power of two number which value is the closet to the input value. /// Deprecated, use roundPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL vec powerOfTwoNearest(vec const& value); /// @} } //namespace glm #include "bit.inl" ================================================ FILE: android/src/glm/gtx/bit.inl ================================================ /// @ref gtx_bit namespace glm { /////////////////// // highestBitValue template GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value) { genIUType tmp = Value; genIUType result = genIUType(0); while(tmp) { result = (tmp & (~tmp + 1)); // grab lowest bit tmp &= ~result; // clear lowest bit } return result; } template GLM_FUNC_QUALIFIER vec highestBitValue(vec const& v) { return detail::functor1::call(highestBitValue, v); } /////////////////// // lowestBitValue template GLM_FUNC_QUALIFIER genIUType lowestBitValue(genIUType Value) { return (Value & (~Value + 1)); } template GLM_FUNC_QUALIFIER vec lowestBitValue(vec const& v) { return detail::functor1::call(lowestBitValue, v); } /////////////////// // powerOfTwoAbove template GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType value) { return isPowerOfTwo(value) ? value : highestBitValue(value) << 1; } template GLM_FUNC_QUALIFIER vec powerOfTwoAbove(vec const& v) { return detail::functor1::call(powerOfTwoAbove, v); } /////////////////// // powerOfTwoBelow template GLM_FUNC_QUALIFIER genType powerOfTwoBelow(genType value) { return isPowerOfTwo(value) ? value : highestBitValue(value); } template GLM_FUNC_QUALIFIER vec powerOfTwoBelow(vec const& v) { return detail::functor1::call(powerOfTwoBelow, v); } ///////////////////// // powerOfTwoNearest template GLM_FUNC_QUALIFIER genType powerOfTwoNearest(genType value) { if(isPowerOfTwo(value)) return value; genType const prev = highestBitValue(value); genType const next = prev << 1; return (next - value) < (value - prev) ? next : prev; } template GLM_FUNC_QUALIFIER vec powerOfTwoNearest(vec const& v) { return detail::functor1::call(powerOfTwoNearest, v); } }//namespace glm ================================================ FILE: android/src/glm/gtx/closest_point.hpp ================================================ /// @ref gtx_closest_point /// @file glm/gtx/closest_point.hpp /// /// @see core (dependence) /// /// @defgroup gtx_closest_point GLM_GTX_closest_point /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Find the point on a straight line which is the closet of a point. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_closest_point extension included") # endif #endif namespace glm { /// @addtogroup gtx_closest_point /// @{ /// Find the point on a straight line which is the closet of a point. /// @see gtx_closest_point template GLM_FUNC_DECL vec<3, T, Q> closestPointOnLine( vec<3, T, Q> const& point, vec<3, T, Q> const& a, vec<3, T, Q> const& b); /// 2d lines work as well template GLM_FUNC_DECL vec<2, T, Q> closestPointOnLine( vec<2, T, Q> const& point, vec<2, T, Q> const& a, vec<2, T, Q> const& b); /// @} }// namespace glm #include "closest_point.inl" ================================================ FILE: android/src/glm/gtx/closest_point.inl ================================================ /// @ref gtx_closest_point namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> closestPointOnLine ( vec<3, T, Q> const& point, vec<3, T, Q> const& a, vec<3, T, Q> const& b ) { T LineLength = distance(a, b); vec<3, T, Q> Vector = point - a; vec<3, T, Q> LineDirection = (b - a) / LineLength; // Project Vector to LineDirection to get the distance of point from a T Distance = dot(Vector, LineDirection); if(Distance <= T(0)) return a; if(Distance >= LineLength) return b; return a + LineDirection * Distance; } template GLM_FUNC_QUALIFIER vec<2, T, Q> closestPointOnLine ( vec<2, T, Q> const& point, vec<2, T, Q> const& a, vec<2, T, Q> const& b ) { T LineLength = distance(a, b); vec<2, T, Q> Vector = point - a; vec<2, T, Q> LineDirection = (b - a) / LineLength; // Project Vector to LineDirection to get the distance of point from a T Distance = dot(Vector, LineDirection); if(Distance <= T(0)) return a; if(Distance >= LineLength) return b; return a + LineDirection * Distance; } }//namespace glm ================================================ FILE: android/src/glm/gtx/color_encoding.hpp ================================================ /// @ref gtx_color_encoding /// @file glm/gtx/color_encoding.hpp /// /// @see core (dependence) /// @see gtx_color_encoding (dependence) /// /// @defgroup gtx_color_encoding GLM_GTX_color_encoding /// @ingroup gtx /// /// Include to use the features of this extension. /// /// @brief Allow to perform bit operations on integer values #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../vec3.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTC_color_encoding is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTC_color_encoding extension included") # endif #endif namespace glm { /// @addtogroup gtx_color_encoding /// @{ /// Convert a linear sRGB color to D65 YUV. template GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB); /// Convert a linear sRGB color to D50 YUV. template GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB); /// Convert a D65 YUV color to linear sRGB. template GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ); /// Convert a D65 YUV color to D50 YUV. template GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ); /// @} } //namespace glm #include "color_encoding.inl" ================================================ FILE: android/src/glm/gtx/color_encoding.inl ================================================ /// @ref gtx_color_encoding namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB) { vec<3, T, Q> const M(0.490f, 0.17697f, 0.2f); vec<3, T, Q> const N(0.31f, 0.8124f, 0.01063f); vec<3, T, Q> const O(0.490f, 0.01f, 0.99f); return (M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB) * static_cast(5.650675255693055f); } template GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB) { vec<3, T, Q> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f); vec<3, T, Q> const N(0.385101860087134f, 0.716942745571917f, 0.097076381494207f); vec<3, T, Q> const O(0.143067806654203f, 0.060618777416563f, 0.713926257896652f); return M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB; } template GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ) { vec<3, T, Q> const M(0.41847f, -0.091169f, 0.0009209f); vec<3, T, Q> const N(-0.15866f, 0.25243f, 0.015708f); vec<3, T, Q> const O(0.0009209f, -0.0025498f, 0.1786f); return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; } template GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ) { vec<3, T, Q> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f); vec<3, T, Q> const N(+0.022898981050086f, +0.990508028941971f, +0.015072338237051f); vec<3, T, Q> const O(-0.050206647741605f, -0.017074711360960f, +0.751717835079977f); return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; } }//namespace glm ================================================ FILE: android/src/glm/gtx/color_space.hpp ================================================ /// @ref gtx_color_space /// @file glm/gtx/color_space.hpp /// /// @see core (dependence) /// /// @defgroup gtx_color_space GLM_GTX_color_space /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Related to RGB to HSV conversions and operations. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_color_space is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_color_space extension included") # endif #endif namespace glm { /// @addtogroup gtx_color_space /// @{ /// Converts a color from HSV color space to its color in RGB color space. /// @see gtx_color_space template GLM_FUNC_DECL vec<3, T, Q> rgbColor( vec<3, T, Q> const& hsvValue); /// Converts a color from RGB color space to its color in HSV color space. /// @see gtx_color_space template GLM_FUNC_DECL vec<3, T, Q> hsvColor( vec<3, T, Q> const& rgbValue); /// Build a saturation matrix. /// @see gtx_color_space template GLM_FUNC_DECL mat<4, 4, T, defaultp> saturation( T const s); /// Modify the saturation of a color. /// @see gtx_color_space template GLM_FUNC_DECL vec<3, T, Q> saturation( T const s, vec<3, T, Q> const& color); /// Modify the saturation of a color. /// @see gtx_color_space template GLM_FUNC_DECL vec<4, T, Q> saturation( T const s, vec<4, T, Q> const& color); /// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals. /// @see gtx_color_space template GLM_FUNC_DECL T luminosity( vec<3, T, Q> const& color); /// @} }//namespace glm #include "color_space.inl" ================================================ FILE: android/src/glm/gtx/color_space.inl ================================================ /// @ref gtx_color_space namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> rgbColor(const vec<3, T, Q>& hsvColor) { vec<3, T, Q> hsv = hsvColor; vec<3, T, Q> rgbColor; if(hsv.y == static_cast(0)) // achromatic (grey) rgbColor = vec<3, T, Q>(hsv.z); else { T sector = floor(hsv.x * (T(1) / T(60))); T frac = (hsv.x * (T(1) / T(60))) - sector; // factorial part of h T o = hsv.z * (T(1) - hsv.y); T p = hsv.z * (T(1) - hsv.y * frac); T q = hsv.z * (T(1) - hsv.y * (T(1) - frac)); switch(int(sector)) { default: case 0: rgbColor.r = hsv.z; rgbColor.g = q; rgbColor.b = o; break; case 1: rgbColor.r = p; rgbColor.g = hsv.z; rgbColor.b = o; break; case 2: rgbColor.r = o; rgbColor.g = hsv.z; rgbColor.b = q; break; case 3: rgbColor.r = o; rgbColor.g = p; rgbColor.b = hsv.z; break; case 4: rgbColor.r = q; rgbColor.g = o; rgbColor.b = hsv.z; break; case 5: rgbColor.r = hsv.z; rgbColor.g = o; rgbColor.b = p; break; } } return rgbColor; } template GLM_FUNC_QUALIFIER vec<3, T, Q> hsvColor(const vec<3, T, Q>& rgbColor) { vec<3, T, Q> hsv = rgbColor; float Min = min(min(rgbColor.r, rgbColor.g), rgbColor.b); float Max = max(max(rgbColor.r, rgbColor.g), rgbColor.b); float Delta = Max - Min; hsv.z = Max; if(Max != static_cast(0)) { hsv.y = Delta / hsv.z; T h = static_cast(0); if(rgbColor.r == Max) // between yellow & magenta h = static_cast(0) + T(60) * (rgbColor.g - rgbColor.b) / Delta; else if(rgbColor.g == Max) // between cyan & yellow h = static_cast(120) + T(60) * (rgbColor.b - rgbColor.r) / Delta; else // between magenta & cyan h = static_cast(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta; if(h < T(0)) hsv.x = h + T(360); else hsv.x = h; } else { // If r = g = b = 0 then s = 0, h is undefined hsv.y = static_cast(0); hsv.x = static_cast(0); } return hsv; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> saturation(T const s) { vec<3, T, defaultp> rgbw = vec<3, T, defaultp>(T(0.2126), T(0.7152), T(0.0722)); vec<3, T, defaultp> const col((T(1) - s) * rgbw); mat<4, 4, T, defaultp> result(T(1)); result[0][0] = col.x + s; result[0][1] = col.x; result[0][2] = col.x; result[1][0] = col.y; result[1][1] = col.y + s; result[1][2] = col.y; result[2][0] = col.z; result[2][1] = col.z; result[2][2] = col.z + s; return result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> saturation(const T s, const vec<3, T, Q>& color) { return vec<3, T, Q>(saturation(s) * vec<4, T, Q>(color, T(0))); } template GLM_FUNC_QUALIFIER vec<4, T, Q> saturation(const T s, const vec<4, T, Q>& color) { return saturation(s) * color; } template GLM_FUNC_QUALIFIER T luminosity(const vec<3, T, Q>& color) { const vec<3, T, Q> tmp = vec<3, T, Q>(0.33, 0.59, 0.11); return dot(color, tmp); } }//namespace glm ================================================ FILE: android/src/glm/gtx/color_space_YCoCg.hpp ================================================ /// @ref gtx_color_space_YCoCg /// @file glm/gtx/color_space_YCoCg.hpp /// /// @see core (dependence) /// /// @defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg /// @ingroup gtx /// /// Include to use the features of this extension. /// /// RGB to YCoCg conversions and operations #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_color_space_YCoCg is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_color_space_YCoCg extension included") # endif #endif namespace glm { /// @addtogroup gtx_color_space_YCoCg /// @{ /// Convert a color from RGB color space to YCoCg color space. /// @see gtx_color_space_YCoCg template GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCg( vec<3, T, Q> const& rgbColor); /// Convert a color from YCoCg color space to RGB color space. /// @see gtx_color_space_YCoCg template GLM_FUNC_DECL vec<3, T, Q> YCoCg2rgb( vec<3, T, Q> const& YCoCgColor); /// Convert a color from RGB color space to YCoCgR color space. /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" /// @see gtx_color_space_YCoCg template GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCgR( vec<3, T, Q> const& rgbColor); /// Convert a color from YCoCgR color space to RGB color space. /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" /// @see gtx_color_space_YCoCg template GLM_FUNC_DECL vec<3, T, Q> YCoCgR2rgb( vec<3, T, Q> const& YCoCgColor); /// @} }//namespace glm #include "color_space_YCoCg.inl" ================================================ FILE: android/src/glm/gtx/color_space_YCoCg.inl ================================================ /// @ref gtx_color_space_YCoCg namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCg ( vec<3, T, Q> const& rgbColor ) { vec<3, T, Q> result; result.x/*Y */ = rgbColor.r / T(4) + rgbColor.g / T(2) + rgbColor.b / T(4); result.y/*Co*/ = rgbColor.r / T(2) + rgbColor.g * T(0) - rgbColor.b / T(2); result.z/*Cg*/ = - rgbColor.r / T(4) + rgbColor.g / T(2) - rgbColor.b / T(4); return result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCg2rgb ( vec<3, T, Q> const& YCoCgColor ) { vec<3, T, Q> result; result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z; result.g = YCoCgColor.x + YCoCgColor.z; result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z; return result; } template class compute_YCoCgR { public: static GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCgR ( vec<3, T, Q> const& rgbColor ) { vec<3, T, Q> result; result.x/*Y */ = rgbColor.g * static_cast(0.5) + (rgbColor.r + rgbColor.b) * static_cast(0.25); result.y/*Co*/ = rgbColor.r - rgbColor.b; result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) * static_cast(0.5); return result; } static GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCgR2rgb ( vec<3, T, Q> const& YCoCgRColor ) { vec<3, T, Q> result; T tmp = YCoCgRColor.x - (YCoCgRColor.z * static_cast(0.5)); result.g = YCoCgRColor.z + tmp; result.b = tmp - (YCoCgRColor.y * static_cast(0.5)); result.r = result.b + YCoCgRColor.y; return result; } }; template class compute_YCoCgR { public: static GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCgR ( vec<3, T, Q> const& rgbColor ) { vec<3, T, Q> result; result.y/*Co*/ = rgbColor.r - rgbColor.b; T tmp = rgbColor.b + (result.y >> 1); result.z/*Cg*/ = rgbColor.g - tmp; result.x/*Y */ = tmp + (result.z >> 1); return result; } static GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCgR2rgb ( vec<3, T, Q> const& YCoCgRColor ) { vec<3, T, Q> result; T tmp = YCoCgRColor.x - (YCoCgRColor.z >> 1); result.g = YCoCgRColor.z + tmp; result.b = tmp - (YCoCgRColor.y >> 1); result.r = result.b + YCoCgRColor.y; return result; } }; template GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCgR ( vec<3, T, Q> const& rgbColor ) { return compute_YCoCgR::is_integer>::rgb2YCoCgR(rgbColor); } template GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCgR2rgb ( vec<3, T, Q> const& YCoCgRColor ) { return compute_YCoCgR::is_integer>::YCoCgR2rgb(YCoCgRColor); } }//namespace glm ================================================ FILE: android/src/glm/gtx/common.hpp ================================================ /// @ref gtx_common /// @file glm/gtx/common.hpp /// /// @see core (dependence) /// /// @defgroup gtx_common GLM_GTX_common /// @ingroup gtx /// /// Include to use the features of this extension. /// /// @brief Provide functions to increase the compatibility with Cg and HLSL languages #pragma once // Dependencies: #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../gtc/vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_common is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_common extension included") # endif #endif namespace glm { /// @addtogroup gtx_common /// @{ /// Returns true if x is a denormalized number /// Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format. /// This format is less precise but can represent values closer to zero. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL isnan man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const& x); /// Similar to 'mod' but with a different rounding and integer support. /// Returns 'x - y * trunc(x/y)' instead of 'x - y * floor(x/y)' /// /// @see GLSL mod vs HLSL fmod /// @see GLSL mod man page template GLM_FUNC_DECL vec fmod(vec const& v); /// Returns whether vector components values are within an interval. A open interval excludes its endpoints, and is denoted with square brackets. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_relational template GLM_FUNC_DECL vec openBounded(vec const& Value, vec const& Min, vec const& Max); /// Returns whether vector components values are within an interval. A closed interval includes its endpoints, and is denoted with square brackets. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_relational template GLM_FUNC_DECL vec closeBounded(vec const& Value, vec const& Min, vec const& Max); /// @} }//namespace glm #include "common.inl" ================================================ FILE: android/src/glm/gtx/common.inl ================================================ /// @ref gtx_common #include #include "../gtc/epsilon.hpp" #include "../gtc/constants.hpp" namespace glm{ namespace detail { template struct compute_fmod { GLM_FUNC_QUALIFIER static vec call(vec const& a, vec const& b) { return detail::functor2::call(std::fmod, a, b); } }; template struct compute_fmod { GLM_FUNC_QUALIFIER static vec call(vec const& a, vec const& b) { return a % b; } }; }//namespace detail template GLM_FUNC_QUALIFIER bool isdenormal(T const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); # if GLM_HAS_CXX11_STL return std::fpclassify(x) == FP_SUBNORMAL; # else return epsilonNotEqual(x, static_cast(0), epsilon()) && std::fabs(x) < std::numeric_limits::min(); # endif } template GLM_FUNC_QUALIFIER typename vec<1, T, Q>::bool_type isdenormal ( vec<1, T, Q> const& x ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); return typename vec<1, T, Q>::bool_type( isdenormal(x.x)); } template GLM_FUNC_QUALIFIER typename vec<2, T, Q>::bool_type isdenormal ( vec<2, T, Q> const& x ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); return typename vec<2, T, Q>::bool_type( isdenormal(x.x), isdenormal(x.y)); } template GLM_FUNC_QUALIFIER typename vec<3, T, Q>::bool_type isdenormal ( vec<3, T, Q> const& x ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); return typename vec<3, T, Q>::bool_type( isdenormal(x.x), isdenormal(x.y), isdenormal(x.z)); } template GLM_FUNC_QUALIFIER typename vec<4, T, Q>::bool_type isdenormal ( vec<4, T, Q> const& x ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); return typename vec<4, T, Q>::bool_type( isdenormal(x.x), isdenormal(x.y), isdenormal(x.z), isdenormal(x.w)); } // fmod template GLM_FUNC_QUALIFIER genType fmod(genType x, genType y) { return fmod(vec<1, genType>(x), y).x; } template GLM_FUNC_QUALIFIER vec fmod(vec const& x, T y) { return detail::compute_fmod::is_iec559>::call(x, vec(y)); } template GLM_FUNC_QUALIFIER vec fmod(vec const& x, vec const& y) { return detail::compute_fmod::is_iec559>::call(x, y); } template GLM_FUNC_QUALIFIER vec openBounded(vec const& Value, vec const& Min, vec const& Max) { return greaterThan(Value, Min) && lessThan(Value, Max); } template GLM_FUNC_QUALIFIER vec closeBounded(vec const& Value, vec const& Min, vec const& Max) { return greaterThanEqual(Value, Min) && lessThanEqual(Value, Max); } }//namespace glm ================================================ FILE: android/src/glm/gtx/compatibility.hpp ================================================ /// @ref gtx_compatibility /// @file glm/gtx/compatibility.hpp /// /// @see core (dependence) /// /// @defgroup gtx_compatibility GLM_GTX_compatibility /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Provide functions to increase the compatibility with Cg and HLSL languages #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/quaternion.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_compatibility is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_compatibility extension included") # endif #endif #if GLM_COMPILER & GLM_COMPILER_VC # include #elif GLM_COMPILER & GLM_COMPILER_GCC # include # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID) # undef isfinite # endif #endif//GLM_COMPILER namespace glm { /// @addtogroup gtx_compatibility /// @{ template GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);} //!< \brief 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]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<2, T, Q>& y, T a){return mix(x, y, a);} //!< \brief 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]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<3, T, Q>& y, T a){return mix(x, y, a);} //!< \brief 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]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<4, T, Q>& y, T a){return mix(x, y, a);} //!< \brief 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]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<2, T, Q>& y, const vec<2, T, Q>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<3, T, Q>& y, const vec<3, T, Q>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<4, T, Q>& y, const vec<4, T, Q>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<2, T, Q> saturate(const vec<2, T, Q>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<3, T, Q> saturate(const vec<3, T, Q>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<4, T, Q> saturate(const vec<4, T, Q>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<2, T, Q> atan2(const vec<2, T, Q>& x, const vec<2, T, Q>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<3, T, Q> atan2(const vec<3, T, Q>& x, const vec<3, T, Q>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<4, T, Q> atan2(const vec<4, T, Q>& x, const vec<4, T, Q>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) template GLM_FUNC_DECL bool isfinite(genType const& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template GLM_FUNC_DECL vec<1, bool, Q> isfinite(const vec<1, T, Q>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template GLM_FUNC_DECL vec<2, bool, Q> isfinite(const vec<2, T, Q>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template GLM_FUNC_DECL vec<3, bool, Q> isfinite(const vec<3, T, Q>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template GLM_FUNC_DECL vec<4, bool, Q> isfinite(const vec<4, T, Q>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension) typedef vec<2, bool, highp> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension) typedef vec<3, bool, highp> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension) typedef vec<4, bool, highp> bool4; //!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension) typedef bool bool1x1; //!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension) typedef mat<2, 2, bool, highp> bool2x2; //!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<2, 3, bool, highp> bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<2, 4, bool, highp> bool2x4; //!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<3, 2, bool, highp> bool3x2; //!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<3, 3, bool, highp> bool3x3; //!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<3, 4, bool, highp> bool3x4; //!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<4, 2, bool, highp> bool4x2; //!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<4, 3, bool, highp> bool4x3; //!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<4, 4, bool, highp> bool4x4; //!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) typedef int int1; //!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension) typedef vec<2, int, highp> int2; //!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension) typedef vec<3, int, highp> int3; //!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension) typedef vec<4, int, highp> int4; //!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension) typedef int int1x1; //!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension) typedef mat<2, 2, int, highp> int2x2; //!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<2, 3, int, highp> int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<2, 4, int, highp> int2x4; //!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<3, 2, int, highp> int3x2; //!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<3, 3, int, highp> int3x3; //!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<3, 4, int, highp> int3x4; //!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<4, 2, int, highp> int4x2; //!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<4, 3, int, highp> int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<4, 4, int, highp> int4x4; //!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) typedef float float1; //!< \brief single-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension) typedef vec<2, float, highp> float2; //!< \brief single-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension) typedef vec<3, float, highp> float3; //!< \brief single-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension) typedef vec<4, float, highp> float4; //!< \brief single-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension) typedef float float1x1; //!< \brief single-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) typedef mat<2, 2, float, highp> float2x2; //!< \brief single-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<2, 3, float, highp> float2x3; //!< \brief single-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<2, 4, float, highp> float2x4; //!< \brief single-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<3, 2, float, highp> float3x2; //!< \brief single-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<3, 3, float, highp> float3x3; //!< \brief single-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<3, 4, float, highp> float3x4; //!< \brief single-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<4, 2, float, highp> float4x2; //!< \brief single-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<4, 3, float, highp> float4x3; //!< \brief single-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<4, 4, float, highp> float4x4; //!< \brief single-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) typedef double double1; //!< \brief double-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension) typedef vec<2, double, highp> double2; //!< \brief double-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension) typedef vec<3, double, highp> double3; //!< \brief double-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension) typedef vec<4, double, highp> double4; //!< \brief double-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension) typedef double double1x1; //!< \brief double-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) typedef mat<2, 2, double, highp> double2x2; //!< \brief double-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<2, 3, double, highp> double2x3; //!< \brief double-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<2, 4, double, highp> double2x4; //!< \brief double-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<3, 2, double, highp> double3x2; //!< \brief double-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<3, 3, double, highp> double3x3; //!< \brief double-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<3, 4, double, highp> double3x4; //!< \brief double-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<4, 2, double, highp> double4x2; //!< \brief double-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<4, 3, double, highp> double4x3; //!< \brief double-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<4, 4, double, highp> double4x4; //!< \brief double-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) /// @} }//namespace glm #include "compatibility.inl" ================================================ FILE: android/src/glm/gtx/compatibility.inl ================================================ #include namespace glm { // isfinite template GLM_FUNC_QUALIFIER bool isfinite( genType const& x) { # if GLM_HAS_CXX11_STL return std::isfinite(x) != 0; # elif GLM_COMPILER & GLM_COMPILER_VC return _finite(x) != 0; # elif GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID return _isfinite(x) != 0; # else if (std::numeric_limits::is_integer || std::denorm_absent == std::numeric_limits::has_denorm) return std::numeric_limits::min() <= x && std::numeric_limits::max() >= x; else return -std::numeric_limits::max() <= x && std::numeric_limits::max() >= x; # endif } template GLM_FUNC_QUALIFIER vec<1, bool, Q> isfinite( vec<1, T, Q> const& x) { return vec<1, bool, Q>( isfinite(x.x)); } template GLM_FUNC_QUALIFIER vec<2, bool, Q> isfinite( vec<2, T, Q> const& x) { return vec<2, bool, Q>( isfinite(x.x), isfinite(x.y)); } template GLM_FUNC_QUALIFIER vec<3, bool, Q> isfinite( vec<3, T, Q> const& x) { return vec<3, bool, Q>( isfinite(x.x), isfinite(x.y), isfinite(x.z)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> isfinite( vec<4, T, Q> const& x) { return vec<4, bool, Q>( isfinite(x.x), isfinite(x.y), isfinite(x.z), isfinite(x.w)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/component_wise.hpp ================================================ /// @ref gtx_component_wise /// @file glm/gtx/component_wise.hpp /// @date 2007-05-21 / 2011-06-07 /// @author Christophe Riccio /// /// @see core (dependence) /// /// @defgroup gtx_component_wise GLM_GTX_component_wise /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Operations between components of a type #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_component_wise is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_component_wise extension included") # endif #endif namespace glm { /// @addtogroup gtx_component_wise /// @{ /// Convert an integer vector to a normalized float vector. /// If the parameter value type is already a floating qualifier type, the value is passed through. /// @see gtx_component_wise template GLM_FUNC_DECL vec compNormalize(vec const& v); /// Convert a normalized float vector to an integer vector. /// If the parameter value type is already a floating qualifier type, the value is passed through. /// @see gtx_component_wise template GLM_FUNC_DECL vec compScale(vec const& v); /// Add all vector components together. /// @see gtx_component_wise template GLM_FUNC_DECL typename genType::value_type compAdd(genType const& v); /// Multiply all vector components together. /// @see gtx_component_wise template GLM_FUNC_DECL typename genType::value_type compMul(genType const& v); /// Find the minimum value between single vector components. /// @see gtx_component_wise template GLM_FUNC_DECL typename genType::value_type compMin(genType const& v); /// Find the maximum value between single vector components. /// @see gtx_component_wise template GLM_FUNC_DECL typename genType::value_type compMax(genType const& v); /// @} }//namespace glm #include "component_wise.inl" ================================================ FILE: android/src/glm/gtx/component_wise.inl ================================================ /// @ref gtx_component_wise #include namespace glm{ namespace detail { template struct compute_compNormalize {}; template struct compute_compNormalize { GLM_FUNC_QUALIFIER static vec call(vec const& v) { floatType const Min = static_cast(std::numeric_limits::min()); floatType const Max = static_cast(std::numeric_limits::max()); return (vec(v) - Min) / (Max - Min) * static_cast(2) - static_cast(1); } }; template struct compute_compNormalize { GLM_FUNC_QUALIFIER static vec call(vec const& v) { return vec(v) / static_cast(std::numeric_limits::max()); } }; template struct compute_compNormalize { GLM_FUNC_QUALIFIER static vec call(vec const& v) { return v; } }; template struct compute_compScale {}; template struct compute_compScale { GLM_FUNC_QUALIFIER static vec call(vec const& v) { floatType const Max = static_cast(std::numeric_limits::max()) + static_cast(0.5); vec const Scaled(v * Max); vec const Result(Scaled - static_cast(0.5)); return Result; } }; template struct compute_compScale { GLM_FUNC_QUALIFIER static vec call(vec const& v) { return vec(vec(v) * static_cast(std::numeric_limits::max())); } }; template struct compute_compScale { GLM_FUNC_QUALIFIER static vec call(vec const& v) { return v; } }; }//namespace detail template GLM_FUNC_QUALIFIER vec compNormalize(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'compNormalize' accepts only floating-point types for 'floatType' template parameter"); return detail::compute_compNormalize::is_integer, std::numeric_limits::is_signed>::call(v); } template GLM_FUNC_QUALIFIER vec compScale(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'compScale' accepts only floating-point types for 'floatType' template parameter"); return detail::compute_compScale::is_integer, std::numeric_limits::is_signed>::call(v); } template GLM_FUNC_QUALIFIER T compAdd(vec const& v) { T Result(0); for(length_t i = 0, n = v.length(); i < n; ++i) Result += v[i]; return Result; } template GLM_FUNC_QUALIFIER T compMul(vec const& v) { T Result(1); for(length_t i = 0, n = v.length(); i < n; ++i) Result *= v[i]; return Result; } template GLM_FUNC_QUALIFIER T compMin(vec const& v) { T Result(v[0]); for(length_t i = 1, n = v.length(); i < n; ++i) Result = min(Result, v[i]); return Result; } template GLM_FUNC_QUALIFIER T compMax(vec const& v) { T Result(v[0]); for(length_t i = 1, n = v.length(); i < n; ++i) Result = max(Result, v[i]); return Result; } }//namespace glm ================================================ FILE: android/src/glm/gtx/dual_quaternion.hpp ================================================ /// @ref gtx_dual_quaternion /// @file glm/gtx/dual_quaternion.hpp /// @author Maksim Vorobiev (msomeone@gmail.com) /// /// @see core (dependence) /// @see gtc_constants (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_dual_quaternion GLM_GTX_dual_quaternion /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines a templated dual-quaternion type and several dual-quaternion operations. #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/constants.hpp" #include "../gtc/quaternion.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_dual_quaternion is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_dual_quaternion extension included") # endif #endif namespace glm { /// @addtogroup gtx_dual_quaternion /// @{ template struct tdualquat { // -- Implementation detail -- typedef T value_type; typedef qua part_type; // -- Data -- qua real, dual; // -- Component accesses -- typedef length_t length_type; /// Return the count of components of a dual quaternion GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;} GLM_FUNC_DECL part_type & operator[](length_type i); GLM_FUNC_DECL part_type const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR tdualquat() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat const& d) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat const& d); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(qua const& real); GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(qua const& orientation, vec<3, T, Q> const& translation); GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(qua const& real, qua const& dual); // -- Conversion constructors -- template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tdualquat(tdualquat const& q); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR tdualquat(mat<2, 4, T, Q> const& holder_mat); GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR tdualquat(mat<3, 4, T, Q> const& aug_mat); // -- Unary arithmetic operators -- GLM_FUNC_DECL tdualquat & operator=(tdualquat const& m) GLM_DEFAULT; template GLM_FUNC_DECL tdualquat & operator=(tdualquat const& m); template GLM_FUNC_DECL tdualquat & operator*=(U s); template GLM_FUNC_DECL tdualquat & operator/=(U s); }; // -- Unary bit operators -- template GLM_FUNC_DECL tdualquat operator+(tdualquat const& q); template GLM_FUNC_DECL tdualquat operator-(tdualquat const& q); // -- Binary operators -- template GLM_FUNC_DECL tdualquat operator+(tdualquat const& q, tdualquat const& p); template GLM_FUNC_DECL tdualquat operator*(tdualquat const& q, tdualquat const& p); template GLM_FUNC_DECL vec<3, T, Q> operator*(tdualquat const& q, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator*(vec<3, T, Q> const& v, tdualquat const& q); template GLM_FUNC_DECL vec<4, T, Q> operator*(tdualquat const& q, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator*(vec<4, T, Q> const& v, tdualquat const& q); template GLM_FUNC_DECL tdualquat operator*(tdualquat const& q, T const& s); template GLM_FUNC_DECL tdualquat operator*(T const& s, tdualquat const& q); template GLM_FUNC_DECL tdualquat operator/(tdualquat const& q, T const& s); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(tdualquat const& q1, tdualquat const& q2); template GLM_FUNC_DECL bool operator!=(tdualquat const& q1, tdualquat const& q2); /// Creates an identity dual quaternion. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat dual_quat_identity(); /// Returns the normalized quaternion. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat normalize(tdualquat const& q); /// Returns the linear interpolation of two dual quaternion. /// /// @see gtc_dual_quaternion template GLM_FUNC_DECL tdualquat lerp(tdualquat const& x, tdualquat const& y, T const& a); /// Returns the q inverse. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat inverse(tdualquat const& q); /// Converts a quaternion to a 2 * 4 matrix. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL mat<2, 4, T, Q> mat2x4_cast(tdualquat const& x); /// Converts a quaternion to a 3 * 4 matrix. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL mat<3, 4, T, Q> mat3x4_cast(tdualquat const& x); /// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat dualquat_cast(mat<2, 4, T, Q> const& x); /// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat dualquat_cast(mat<3, 4, T, Q> const& x); /// Dual-quaternion of low single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat lowp_dualquat; /// Dual-quaternion of medium single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat mediump_dualquat; /// Dual-quaternion of high single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat highp_dualquat; /// Dual-quaternion of low single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat lowp_fdualquat; /// Dual-quaternion of medium single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat mediump_fdualquat; /// Dual-quaternion of high single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat highp_fdualquat; /// Dual-quaternion of low double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat lowp_ddualquat; /// Dual-quaternion of medium double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat mediump_ddualquat; /// Dual-quaternion of high double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat highp_ddualquat; #if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) /// Dual-quaternion of floating-point numbers. /// /// @see gtx_dual_quaternion typedef highp_fdualquat dualquat; /// Dual-quaternion of single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef highp_fdualquat fdualquat; #elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) typedef highp_fdualquat dualquat; typedef highp_fdualquat fdualquat; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) typedef mediump_fdualquat dualquat; typedef mediump_fdualquat fdualquat; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT)) typedef lowp_fdualquat dualquat; typedef lowp_fdualquat fdualquat; #else # error "GLM error: multiple default precision requested for single-precision floating-point types" #endif #if(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) /// Dual-quaternion of default double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef highp_ddualquat ddualquat; #elif(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) typedef highp_ddualquat ddualquat; #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) typedef mediump_ddualquat ddualquat; #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE)) typedef lowp_ddualquat ddualquat; #else # error "GLM error: Multiple default precision requested for double-precision floating-point types" #endif /// @} } //namespace glm #include "dual_quaternion.inl" ================================================ FILE: android/src/glm/gtx/dual_quaternion.inl ================================================ /// @ref gtx_dual_quaternion #include "../geometric.hpp" #include namespace glm { // -- Component accesses -- template GLM_FUNC_QUALIFIER typename tdualquat::part_type & tdualquat::operator[](typename tdualquat::length_type i) { assert(i >= 0 && i < this->length()); return (&real)[i]; } template GLM_FUNC_QUALIFIER typename tdualquat::part_type const& tdualquat::operator[](typename tdualquat::length_type i) const { assert(i >= 0 && i < this->length()); return (&real)[i]; } // -- Implicit basic constructors -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat() # if GLM_CONFIG_DEFAULTED_FUNCTIONS != GLM_DISABLE : real(qua()) , dual(qua(0, 0, 0, 0)) # endif {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const& d) : real(d.real) , dual(d.dual) {} # endif template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const& d) : real(d.real) , dual(d.dual) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(qua const& r) : real(r), dual(qua(0, 0, 0, 0)) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(qua const& q, vec<3, T, Q> const& p) : real(q), dual( T(-0.5) * ( p.x*q.x + p.y*q.y + p.z*q.z), T(+0.5) * ( p.x*q.w + p.y*q.z - p.z*q.y), T(+0.5) * (-p.x*q.z + p.y*q.w + p.z*q.x), T(+0.5) * ( p.x*q.y - p.y*q.x + p.z*q.w)) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(qua const& r, qua const& d) : real(r), dual(d) {} // -- Conversion constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const& q) : real(q.real) , dual(q.dual) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(mat<2, 4, T, Q> const& m) { *this = dualquat_cast(m); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(mat<3, 4, T, Q> const& m) { *this = dualquat_cast(m); } // -- Unary arithmetic operators -- # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator=(tdualquat const& q) { this->real = q.real; this->dual = q.dual; return *this; } # endif template template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator=(tdualquat const& q) { this->real = q.real; this->dual = q.dual; return *this; } template template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator*=(U s) { this->real *= static_cast(s); this->dual *= static_cast(s); return *this; } template template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator/=(U s) { this->real /= static_cast(s); this->dual /= static_cast(s); return *this; } // -- Unary bit operators -- template GLM_FUNC_QUALIFIER tdualquat operator+(tdualquat const& q) { return q; } template GLM_FUNC_QUALIFIER tdualquat operator-(tdualquat const& q) { return tdualquat(-q.real, -q.dual); } // -- Binary operators -- template GLM_FUNC_QUALIFIER tdualquat operator+(tdualquat const& q, tdualquat const& p) { return tdualquat(q.real + p.real,q.dual + p.dual); } template GLM_FUNC_QUALIFIER tdualquat operator*(tdualquat const& p, tdualquat const& o) { return tdualquat(p.real * o.real,p.real * o.dual + p.dual * o.real); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(tdualquat const& q, vec<3, T, Q> const& v) { vec<3, T, Q> const real_v3(q.real.x,q.real.y,q.real.z); vec<3, T, Q> const dual_v3(q.dual.x,q.dual.y,q.dual.z); return (cross(real_v3, cross(real_v3,v) + v * q.real.w + dual_v3) + dual_v3 * q.real.w - real_v3 * q.dual.w) * T(2) + v; } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(vec<3, T, Q> const& v, tdualquat const& q) { return glm::inverse(q) * v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(tdualquat const& q, vec<4, T, Q> const& v) { return vec<4, T, Q>(q * vec<3, T, Q>(v), v.w); } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(vec<4, T, Q> const& v, tdualquat const& q) { return glm::inverse(q) * v; } template GLM_FUNC_QUALIFIER tdualquat operator*(tdualquat const& q, T const& s) { return tdualquat(q.real * s, q.dual * s); } template GLM_FUNC_QUALIFIER tdualquat operator*(T const& s, tdualquat const& q) { return q * s; } template GLM_FUNC_QUALIFIER tdualquat operator/(tdualquat const& q, T const& s) { return tdualquat(q.real / s, q.dual / s); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(tdualquat const& q1, tdualquat const& q2) { return (q1.real == q2.real) && (q1.dual == q2.dual); } template GLM_FUNC_QUALIFIER bool operator!=(tdualquat const& q1, tdualquat const& q2) { return (q1.real != q2.real) || (q1.dual != q2.dual); } // -- Operations -- template GLM_FUNC_QUALIFIER tdualquat dual_quat_identity() { return tdualquat( qua(static_cast(1), static_cast(0), static_cast(0), static_cast(0)), qua(static_cast(0), static_cast(0), static_cast(0), static_cast(0))); } template GLM_FUNC_QUALIFIER tdualquat normalize(tdualquat const& q) { return q / length(q.real); } template GLM_FUNC_QUALIFIER tdualquat lerp(tdualquat const& x, tdualquat const& y, T const& a) { // Dual Quaternion Linear blend aka DLB: // Lerp is only defined in [0, 1] assert(a >= static_cast(0)); assert(a <= static_cast(1)); T const k = dot(x.real,y.real) < static_cast(0) ? -a : a; T const one(1); return tdualquat(x * (one - a) + y * k); } template GLM_FUNC_QUALIFIER tdualquat inverse(tdualquat const& q) { const glm::qua real = conjugate(q.real); const glm::qua dual = conjugate(q.dual); return tdualquat(real, dual + (real * (-2.0f * dot(real,dual)))); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat2x4_cast(tdualquat const& x) { return mat<2, 4, T, Q>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w ); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat3x4_cast(tdualquat const& x) { qua r = x.real / length2(x.real); qua const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z); r *= static_cast(2); T const xy = r.x * x.real.y; T const xz = r.x * x.real.z; T const yz = r.y * x.real.z; T const wx = r.w * x.real.x; T const wy = r.w * x.real.y; T const wz = r.w * x.real.z; vec<4, T, Q> const a( rr.w + rr.x - rr.y - rr.z, xy - wz, xz + wy, -(x.dual.w * r.x - x.dual.x * r.w + x.dual.y * r.z - x.dual.z * r.y)); vec<4, T, Q> const b( xy + wz, rr.w + rr.y - rr.x - rr.z, yz - wx, -(x.dual.w * r.y - x.dual.x * r.z - x.dual.y * r.w + x.dual.z * r.x)); vec<4, T, Q> const c( xz - wy, yz + wx, rr.w + rr.z - rr.x - rr.y, -(x.dual.w * r.z + x.dual.x * r.y - x.dual.y * r.x - x.dual.z * r.w)); return mat<3, 4, T, Q>(a, b, c); } template GLM_FUNC_QUALIFIER tdualquat dualquat_cast(mat<2, 4, T, Q> const& x) { return tdualquat( qua( x[0].w, x[0].x, x[0].y, x[0].z ), qua( x[1].w, x[1].x, x[1].y, x[1].z )); } template GLM_FUNC_QUALIFIER tdualquat dualquat_cast(mat<3, 4, T, Q> const& x) { qua real; T const trace = x[0].x + x[1].y + x[2].z; if(trace > static_cast(0)) { T const r = sqrt(T(1) + trace); T const invr = static_cast(0.5) / r; real.w = static_cast(0.5) * r; real.x = (x[2].y - x[1].z) * invr; real.y = (x[0].z - x[2].x) * invr; real.z = (x[1].x - x[0].y) * invr; } else if(x[0].x > x[1].y && x[0].x > x[2].z) { T const r = sqrt(T(1) + x[0].x - x[1].y - x[2].z); T const invr = static_cast(0.5) / r; real.x = static_cast(0.5)*r; real.y = (x[1].x + x[0].y) * invr; real.z = (x[0].z + x[2].x) * invr; real.w = (x[2].y - x[1].z) * invr; } else if(x[1].y > x[2].z) { T const r = sqrt(T(1) + x[1].y - x[0].x - x[2].z); T const invr = static_cast(0.5) / r; real.x = (x[1].x + x[0].y) * invr; real.y = static_cast(0.5) * r; real.z = (x[2].y + x[1].z) * invr; real.w = (x[0].z - x[2].x) * invr; } else { T const r = sqrt(T(1) + x[2].z - x[0].x - x[1].y); T const invr = static_cast(0.5) / r; real.x = (x[0].z + x[2].x) * invr; real.y = (x[2].y + x[1].z) * invr; real.z = static_cast(0.5) * r; real.w = (x[1].x - x[0].y) * invr; } qua dual; dual.x = static_cast(0.5) * ( x[0].w * real.w + x[1].w * real.z - x[2].w * real.y); dual.y = static_cast(0.5) * (-x[0].w * real.z + x[1].w * real.w + x[2].w * real.x); dual.z = static_cast(0.5) * ( x[0].w * real.y - x[1].w * real.x + x[2].w * real.w); dual.w = -static_cast(0.5) * ( x[0].w * real.x + x[1].w * real.y + x[2].w * real.z); return tdualquat(real, dual); } }//namespace glm ================================================ FILE: android/src/glm/gtx/easing.hpp ================================================ /// @ref gtx_easing /// @file glm/gtx/easing.hpp /// @author Robert Chisholm /// /// @see core (dependence) /// /// @defgroup gtx_easing GLM_GTX_easing /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Easing functions for animations and transitons /// All functions take a parameter x in the range [0.0,1.0] /// /// Based on the AHEasing project of Warren Moore (https://github.com/warrenm/AHEasing) #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/constants.hpp" #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_easing is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_easing extension included") # endif #endif namespace glm{ /// @addtogroup gtx_easing /// @{ /// Modelled after the line y = x /// @see gtx_easing template GLM_FUNC_DECL genType linearInterpolation(genType const & a); /// Modelled after the parabola y = x^2 /// @see gtx_easing template GLM_FUNC_DECL genType quadraticEaseIn(genType const & a); /// Modelled after the parabola y = -x^2 + 2x /// @see gtx_easing template GLM_FUNC_DECL genType quadraticEaseOut(genType const & a); /// Modelled after the piecewise quadratic /// y = (1/2)((2x)^2) ; [0, 0.5) /// y = -(1/2)((2x-1)*(2x-3) - 1) ; [0.5, 1] /// @see gtx_easing template GLM_FUNC_DECL genType quadraticEaseInOut(genType const & a); /// Modelled after the cubic y = x^3 template GLM_FUNC_DECL genType cubicEaseIn(genType const & a); /// Modelled after the cubic y = (x - 1)^3 + 1 /// @see gtx_easing template GLM_FUNC_DECL genType cubicEaseOut(genType const & a); /// Modelled after the piecewise cubic /// y = (1/2)((2x)^3) ; [0, 0.5) /// y = (1/2)((2x-2)^3 + 2) ; [0.5, 1] /// @see gtx_easing template GLM_FUNC_DECL genType cubicEaseInOut(genType const & a); /// Modelled after the quartic x^4 /// @see gtx_easing template GLM_FUNC_DECL genType quarticEaseIn(genType const & a); /// Modelled after the quartic y = 1 - (x - 1)^4 /// @see gtx_easing template GLM_FUNC_DECL genType quarticEaseOut(genType const & a); /// Modelled after the piecewise quartic /// y = (1/2)((2x)^4) ; [0, 0.5) /// y = -(1/2)((2x-2)^4 - 2) ; [0.5, 1] /// @see gtx_easing template GLM_FUNC_DECL genType quarticEaseInOut(genType const & a); /// Modelled after the quintic y = x^5 /// @see gtx_easing template GLM_FUNC_DECL genType quinticEaseIn(genType const & a); /// Modelled after the quintic y = (x - 1)^5 + 1 /// @see gtx_easing template GLM_FUNC_DECL genType quinticEaseOut(genType const & a); /// Modelled after the piecewise quintic /// y = (1/2)((2x)^5) ; [0, 0.5) /// y = (1/2)((2x-2)^5 + 2) ; [0.5, 1] /// @see gtx_easing template GLM_FUNC_DECL genType quinticEaseInOut(genType const & a); /// Modelled after quarter-cycle of sine wave /// @see gtx_easing template GLM_FUNC_DECL genType sineEaseIn(genType const & a); /// Modelled after quarter-cycle of sine wave (different phase) /// @see gtx_easing template GLM_FUNC_DECL genType sineEaseOut(genType const & a); /// Modelled after half sine wave /// @see gtx_easing template GLM_FUNC_DECL genType sineEaseInOut(genType const & a); /// Modelled after shifted quadrant IV of unit circle /// @see gtx_easing template GLM_FUNC_DECL genType circularEaseIn(genType const & a); /// Modelled after shifted quadrant II of unit circle /// @see gtx_easing template GLM_FUNC_DECL genType circularEaseOut(genType const & a); /// Modelled after the piecewise circular function /// y = (1/2)(1 - sqrt(1 - 4x^2)) ; [0, 0.5) /// y = (1/2)(sqrt(-(2x - 3)*(2x - 1)) + 1) ; [0.5, 1] /// @see gtx_easing template GLM_FUNC_DECL genType circularEaseInOut(genType const & a); /// Modelled after the exponential function y = 2^(10(x - 1)) /// @see gtx_easing template GLM_FUNC_DECL genType exponentialEaseIn(genType const & a); /// Modelled after the exponential function y = -2^(-10x) + 1 /// @see gtx_easing template GLM_FUNC_DECL genType exponentialEaseOut(genType const & a); /// Modelled after the piecewise exponential /// y = (1/2)2^(10(2x - 1)) ; [0,0.5) /// y = -(1/2)*2^(-10(2x - 1))) + 1 ; [0.5,1] /// @see gtx_easing template GLM_FUNC_DECL genType exponentialEaseInOut(genType const & a); /// Modelled after the damped sine wave y = sin(13pi/2*x)*pow(2, 10 * (x - 1)) /// @see gtx_easing template GLM_FUNC_DECL genType elasticEaseIn(genType const & a); /// Modelled after the damped sine wave y = sin(-13pi/2*(x + 1))*pow(2, -10x) + 1 /// @see gtx_easing template GLM_FUNC_DECL genType elasticEaseOut(genType const & a); /// Modelled after the piecewise exponentially-damped sine wave: /// y = (1/2)*sin(13pi/2*(2*x))*pow(2, 10 * ((2*x) - 1)) ; [0,0.5) /// y = (1/2)*(sin(-13pi/2*((2x-1)+1))*pow(2,-10(2*x-1)) + 2) ; [0.5, 1] /// @see gtx_easing template GLM_FUNC_DECL genType elasticEaseInOut(genType const & a); /// @see gtx_easing template GLM_FUNC_DECL genType backEaseIn(genType const& a); /// @see gtx_easing template GLM_FUNC_DECL genType backEaseOut(genType const& a); /// @see gtx_easing template GLM_FUNC_DECL genType backEaseInOut(genType const& a); /// @param a parameter /// @param o Optional overshoot modifier /// @see gtx_easing template GLM_FUNC_DECL genType backEaseIn(genType const& a, genType const& o); /// @param a parameter /// @param o Optional overshoot modifier /// @see gtx_easing template GLM_FUNC_DECL genType backEaseOut(genType const& a, genType const& o); /// @param a parameter /// @param o Optional overshoot modifier /// @see gtx_easing template GLM_FUNC_DECL genType backEaseInOut(genType const& a, genType const& o); /// @see gtx_easing template GLM_FUNC_DECL genType bounceEaseIn(genType const& a); /// @see gtx_easing template GLM_FUNC_DECL genType bounceEaseOut(genType const& a); /// @see gtx_easing template GLM_FUNC_DECL genType bounceEaseInOut(genType const& a); /// @} }//namespace glm #include "easing.inl" ================================================ FILE: android/src/glm/gtx/easing.inl ================================================ /// @ref gtx_easing #include namespace glm{ template GLM_FUNC_QUALIFIER genType linearInterpolation(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return a; } template GLM_FUNC_QUALIFIER genType quadraticEaseIn(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return a * a; } template GLM_FUNC_QUALIFIER genType quadraticEaseOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return -(a * (a - static_cast(2))); } template GLM_FUNC_QUALIFIER genType quadraticEaseInOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a < static_cast(0.5)) { return static_cast(2) * a * a; } else { return (-static_cast(2) * a * a) + (4 * a) - one(); } } template GLM_FUNC_QUALIFIER genType cubicEaseIn(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return a * a * a; } template GLM_FUNC_QUALIFIER genType cubicEaseOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); genType const f = a - one(); return f * f * f + one(); } template GLM_FUNC_QUALIFIER genType cubicEaseInOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if (a < static_cast(0.5)) { return static_cast(4) * a * a * a; } else { genType const f = ((static_cast(2) * a) - static_cast(2)); return static_cast(0.5) * f * f * f + one(); } } template GLM_FUNC_QUALIFIER genType quarticEaseIn(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return a * a * a * a; } template GLM_FUNC_QUALIFIER genType quarticEaseOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); genType const f = (a - one()); return f * f * f * (one() - a) + one(); } template GLM_FUNC_QUALIFIER genType quarticEaseInOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a < static_cast(0.5)) { return static_cast(8) * a * a * a * a; } else { genType const f = (a - one()); return -static_cast(8) * f * f * f * f + one(); } } template GLM_FUNC_QUALIFIER genType quinticEaseIn(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return a * a * a * a * a; } template GLM_FUNC_QUALIFIER genType quinticEaseOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); genType const f = (a - one()); return f * f * f * f * f + one(); } template GLM_FUNC_QUALIFIER genType quinticEaseInOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a < static_cast(0.5)) { return static_cast(16) * a * a * a * a * a; } else { genType const f = ((static_cast(2) * a) - static_cast(2)); return static_cast(0.5) * f * f * f * f * f + one(); } } template GLM_FUNC_QUALIFIER genType sineEaseIn(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return sin((a - one()) * half_pi()) + one(); } template GLM_FUNC_QUALIFIER genType sineEaseOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return sin(a * half_pi()); } template GLM_FUNC_QUALIFIER genType sineEaseInOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return static_cast(0.5) * (one() - cos(a * pi())); } template GLM_FUNC_QUALIFIER genType circularEaseIn(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return one() - sqrt(one() - (a * a)); } template GLM_FUNC_QUALIFIER genType circularEaseOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return sqrt((static_cast(2) - a) * a); } template GLM_FUNC_QUALIFIER genType circularEaseInOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a < static_cast(0.5)) { return static_cast(0.5) * (one() - std::sqrt(one() - static_cast(4) * (a * a))); } else { return static_cast(0.5) * (std::sqrt(-((static_cast(2) * a) - static_cast(3)) * ((static_cast(2) * a) - one())) + one()); } } template GLM_FUNC_QUALIFIER genType exponentialEaseIn(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a <= zero()) return a; else { genType const Complementary = a - one(); genType const Two = static_cast(2); return glm::pow(Two, Complementary * static_cast(10)); } } template GLM_FUNC_QUALIFIER genType exponentialEaseOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a >= one()) return a; else { return one() - glm::pow(static_cast(2), -static_cast(10) * a); } } template GLM_FUNC_QUALIFIER genType exponentialEaseInOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a < static_cast(0.5)) return static_cast(0.5) * glm::pow(static_cast(2), (static_cast(20) * a) - static_cast(10)); else return -static_cast(0.5) * glm::pow(static_cast(2), (-static_cast(20) * a) + static_cast(10)) + one(); } template GLM_FUNC_QUALIFIER genType elasticEaseIn(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return std::sin(static_cast(13) * half_pi() * a) * glm::pow(static_cast(2), static_cast(10) * (a - one())); } template GLM_FUNC_QUALIFIER genType elasticEaseOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return std::sin(-static_cast(13) * half_pi() * (a + one())) * glm::pow(static_cast(2), -static_cast(10) * a) + one(); } template GLM_FUNC_QUALIFIER genType elasticEaseInOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a < static_cast(0.5)) return static_cast(0.5) * std::sin(static_cast(13) * half_pi() * (static_cast(2) * a)) * glm::pow(static_cast(2), static_cast(10) * ((static_cast(2) * a) - one())); else return static_cast(0.5) * (std::sin(-static_cast(13) * half_pi() * ((static_cast(2) * a - one()) + one())) * glm::pow(static_cast(2), -static_cast(10) * (static_cast(2) * a - one())) + static_cast(2)); } template GLM_FUNC_QUALIFIER genType backEaseIn(genType const& a, genType const& o) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); genType z = ((o + one()) * a) - o; return (a * a * z); } template GLM_FUNC_QUALIFIER genType backEaseOut(genType const& a, genType const& o) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); genType n = a - one(); genType z = ((o + one()) * n) + o; return (n * n * z) + one(); } template GLM_FUNC_QUALIFIER genType backEaseInOut(genType const& a, genType const& o) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); genType s = o * static_cast(1.525); genType x = static_cast(0.5); genType n = a / static_cast(0.5); if (n < static_cast(1)) { genType z = ((s + static_cast(1)) * n) - s; genType m = n * n * z; return x * m; } else { n -= static_cast(2); genType z = ((s + static_cast(1)) * n) + s; genType m = (n*n*z) + static_cast(2); return x * m; } } template GLM_FUNC_QUALIFIER genType backEaseIn(genType const& a) { return backEaseIn(a, static_cast(1.70158)); } template GLM_FUNC_QUALIFIER genType backEaseOut(genType const& a) { return backEaseOut(a, static_cast(1.70158)); } template GLM_FUNC_QUALIFIER genType backEaseInOut(genType const& a) { return backEaseInOut(a, static_cast(1.70158)); } template GLM_FUNC_QUALIFIER genType bounceEaseOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a < static_cast(4.0 / 11.0)) { return (static_cast(121) * a * a) / static_cast(16); } else if(a < static_cast(8.0 / 11.0)) { return (static_cast(363.0 / 40.0) * a * a) - (static_cast(99.0 / 10.0) * a) + static_cast(17.0 / 5.0); } else if(a < static_cast(9.0 / 10.0)) { return (static_cast(4356.0 / 361.0) * a * a) - (static_cast(35442.0 / 1805.0) * a) + static_cast(16061.0 / 1805.0); } else { return (static_cast(54.0 / 5.0) * a * a) - (static_cast(513.0 / 25.0) * a) + static_cast(268.0 / 25.0); } } template GLM_FUNC_QUALIFIER genType bounceEaseIn(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); return one() - bounceEaseOut(one() - a); } template GLM_FUNC_QUALIFIER genType bounceEaseInOut(genType const& a) { // Only defined in [0, 1] assert(a >= zero()); assert(a <= one()); if(a < static_cast(0.5)) { return static_cast(0.5) * (one() - bounceEaseOut(a * static_cast(2))); } else { return static_cast(0.5) * bounceEaseOut(a * static_cast(2) - one()) + static_cast(0.5); } } }//namespace glm ================================================ FILE: android/src/glm/gtx/euler_angles.hpp ================================================ /// @ref gtx_euler_angles /// @file glm/gtx/euler_angles.hpp /// /// @see core (dependence) /// /// @defgroup gtx_euler_angles GLM_GTX_euler_angles /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Build matrices from Euler angles. /// /// Extraction of Euler angles from rotation matrix. /// Based on the original paper 2014 Mike Day - Extracting Euler Angles from a Rotation Matrix. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_euler_angles is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_euler_angles extension included") # endif #endif namespace glm { /// @addtogroup gtx_euler_angles /// @{ /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleX( T const& angleX); /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleY( T const& angleY); /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZ( T const& angleZ); /// Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about X-axis. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleX( T const & angleX, T const & angularVelocityX); /// Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Y-axis. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleY( T const & angleY, T const & angularVelocityY); /// Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Z-axis. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleZ( T const & angleZ, T const & angularVelocityZ); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXY( T const& angleX, T const& angleY); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYX( T const& angleY, T const& angleX); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZ( T const& angleX, T const& angleZ); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZX( T const& angle, T const& angleX); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZ( T const& angleY, T const& angleZ); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZY( T const& angleZ, T const& angleY); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYZ( T const& t1, T const& t2, T const& t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXZ( T const& yaw, T const& pitch, T const& roll); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * X). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZX( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * X). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYX( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Y). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXY( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * Y). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZY( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZYZ( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZXZ( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * Y). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZY( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * X). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZX( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * X). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZYX( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Y). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZXY( T const & t1, T const & t2, T const & t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> yawPitchRoll( T const& yaw, T const& pitch, T const& roll); /// Creates a 2D 2 * 2 rotation matrix from an euler angle. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<2, 2, T, defaultp> orientate2(T const& angle); /// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<3, 3, T, defaultp> orientate3(T const& angle); /// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<3, 3, T, Q> orientate3(vec<3, T, Q> const& angles); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, Q> orientate4(vec<3, T, Q> const& angles); /// Extracts the (X * Y * Z) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const& M, T & t1, T & t2, T & t3); /// Extracts the (Y * X * Z) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleYXZ(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (X * Z * X) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleXZX(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (X * Y * X) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleXYX(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (Y * X * Y) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleYXY(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (Y * Z * Y) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleYZY(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (Z * Y * Z) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleZYZ(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (Z * X * Z) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleZXZ(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (X * Z * Y) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleXZY(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (Y * Z * X) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleYZX(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (Z * Y * X) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleZYX(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// Extracts the (Z * X * Y) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleZXY(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3); /// @} }//namespace glm #include "euler_angles.inl" ================================================ FILE: android/src/glm/gtx/euler_angles.inl ================================================ /// @ref gtx_euler_angles #include "compatibility.hpp" // glm::atan2 namespace glm { template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleX ( T const& angleX ) { T cosX = glm::cos(angleX); T sinX = glm::sin(angleX); return mat<4, 4, T, defaultp>( T(1), T(0), T(0), T(0), T(0), cosX, sinX, T(0), T(0),-sinX, cosX, T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleY ( T const& angleY ) { T cosY = glm::cos(angleY); T sinY = glm::sin(angleY); return mat<4, 4, T, defaultp>( cosY, T(0), -sinY, T(0), T(0), T(1), T(0), T(0), sinY, T(0), cosY, T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZ ( T const& angleZ ) { T cosZ = glm::cos(angleZ); T sinZ = glm::sin(angleZ); return mat<4, 4, T, defaultp>( cosZ, sinZ, T(0), T(0), -sinZ, cosZ, T(0), T(0), T(0), T(0), T(1), T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> derivedEulerAngleX ( T const & angleX, T const & angularVelocityX ) { T cosX = glm::cos(angleX) * angularVelocityX; T sinX = glm::sin(angleX) * angularVelocityX; return mat<4, 4, T, defaultp>( T(0), T(0), T(0), T(0), T(0),-sinX, cosX, T(0), T(0),-cosX,-sinX, T(0), T(0), T(0), T(0), T(0)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> derivedEulerAngleY ( T const & angleY, T const & angularVelocityY ) { T cosY = glm::cos(angleY) * angularVelocityY; T sinY = glm::sin(angleY) * angularVelocityY; return mat<4, 4, T, defaultp>( -sinY, T(0), -cosY, T(0), T(0), T(0), T(0), T(0), cosY, T(0), -sinY, T(0), T(0), T(0), T(0), T(0)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> derivedEulerAngleZ ( T const & angleZ, T const & angularVelocityZ ) { T cosZ = glm::cos(angleZ) * angularVelocityZ; T sinZ = glm::sin(angleZ) * angularVelocityZ; return mat<4, 4, T, defaultp>( -sinZ, cosZ, T(0), T(0), -cosZ, -sinZ, T(0), T(0), T(0), T(0), T(0), T(0), T(0), T(0), T(0), T(0)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXY ( T const& angleX, T const& angleY ) { T cosX = glm::cos(angleX); T sinX = glm::sin(angleX); T cosY = glm::cos(angleY); T sinY = glm::sin(angleY); return mat<4, 4, T, defaultp>( cosY, -sinX * -sinY, cosX * -sinY, T(0), T(0), cosX, sinX, T(0), sinY, -sinX * cosY, cosX * cosY, T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYX ( T const& angleY, T const& angleX ) { T cosX = glm::cos(angleX); T sinX = glm::sin(angleX); T cosY = glm::cos(angleY); T sinY = glm::sin(angleY); return mat<4, 4, T, defaultp>( cosY, 0, -sinY, T(0), sinY * sinX, cosX, cosY * sinX, T(0), sinY * cosX, -sinX, cosY * cosX, T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZ ( T const& angleX, T const& angleZ ) { return eulerAngleX(angleX) * eulerAngleZ(angleZ); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZX ( T const& angleZ, T const& angleX ) { return eulerAngleZ(angleZ) * eulerAngleX(angleX); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZ ( T const& angleY, T const& angleZ ) { return eulerAngleY(angleY) * eulerAngleZ(angleZ); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZY ( T const& angleZ, T const& angleY ) { return eulerAngleZ(angleZ) * eulerAngleY(angleY); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXYZ ( T const& t1, T const& t2, T const& t3 ) { T c1 = glm::cos(-t1); T c2 = glm::cos(-t2); T c3 = glm::cos(-t3); T s1 = glm::sin(-t1); T s2 = glm::sin(-t2); T s3 = glm::sin(-t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c2 * c3; Result[0][1] =-c1 * s3 + s1 * s2 * c3; Result[0][2] = s1 * s3 + c1 * s2 * c3; Result[0][3] = static_cast(0); Result[1][0] = c2 * s3; Result[1][1] = c1 * c3 + s1 * s2 * s3; Result[1][2] =-s1 * c3 + c1 * s2 * s3; Result[1][3] = static_cast(0); Result[2][0] =-s2; Result[2][1] = s1 * c2; Result[2][2] = c1 * c2; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYXZ ( T const& yaw, T const& pitch, T const& roll ) { T tmp_ch = glm::cos(yaw); T tmp_sh = glm::sin(yaw); T tmp_cp = glm::cos(pitch); T tmp_sp = glm::sin(pitch); T tmp_cb = glm::cos(roll); T tmp_sb = glm::sin(roll); mat<4, 4, T, defaultp> Result; Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb; Result[0][1] = tmp_sb * tmp_cp; Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb; Result[0][3] = static_cast(0); Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb; Result[1][1] = tmp_cb * tmp_cp; Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb; Result[1][3] = static_cast(0); Result[2][0] = tmp_sh * tmp_cp; Result[2][1] = -tmp_sp; Result[2][2] = tmp_ch * tmp_cp; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZX ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c2; Result[0][1] = c1 * s2; Result[0][2] = s1 * s2; Result[0][3] = static_cast(0); Result[1][0] =-c3 * s2; Result[1][1] = c1 * c2 * c3 - s1 * s3; Result[1][2] = c1 * s3 + c2 * c3 * s1; Result[1][3] = static_cast(0); Result[2][0] = s2 * s3; Result[2][1] =-c3 * s1 - c1 * c2 * s3; Result[2][2] = c1 * c3 - c2 * s1 * s3; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXYX ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c2; Result[0][1] = s1 * s2; Result[0][2] =-c1 * s2; Result[0][3] = static_cast(0); Result[1][0] = s2 * s3; Result[1][1] = c1 * c3 - c2 * s1 * s3; Result[1][2] = c3 * s1 + c1 * c2 * s3; Result[1][3] = static_cast(0); Result[2][0] = c3 * s2; Result[2][1] =-c1 * s3 - c2 * c3 * s1; Result[2][2] = c1 * c2 * c3 - s1 * s3; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYXY ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c1 * c3 - c2 * s1 * s3; Result[0][1] = s2* s3; Result[0][2] =-c3 * s1 - c1 * c2 * s3; Result[0][3] = static_cast(0); Result[1][0] = s1 * s2; Result[1][1] = c2; Result[1][2] = c1 * s2; Result[1][3] = static_cast(0); Result[2][0] = c1 * s3 + c2 * c3 * s1; Result[2][1] =-c3 * s2; Result[2][2] = c1 * c2 * c3 - s1 * s3; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZY ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c1 * c2 * c3 - s1 * s3; Result[0][1] = c3 * s2; Result[0][2] =-c1 * s3 - c2 * c3 * s1; Result[0][3] = static_cast(0); Result[1][0] =-c1 * s2; Result[1][1] = c2; Result[1][2] = s1 * s2; Result[1][3] = static_cast(0); Result[2][0] = c3 * s1 + c1 * c2 * s3; Result[2][1] = s2 * s3; Result[2][2] = c1 * c3 - c2 * s1 * s3; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZYZ ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c1 * c2 * c3 - s1 * s3; Result[0][1] = c1 * s3 + c2 * c3 * s1; Result[0][2] =-c3 * s2; Result[0][3] = static_cast(0); Result[1][0] =-c3 * s1 - c1 * c2 * s3; Result[1][1] = c1 * c3 - c2 * s1 * s3; Result[1][2] = s2 * s3; Result[1][3] = static_cast(0); Result[2][0] = c1 * s2; Result[2][1] = s1 * s2; Result[2][2] = c2; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZXZ ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c1 * c3 - c2 * s1 * s3; Result[0][1] = c3 * s1 + c1 * c2 * s3; Result[0][2] = s2 *s3; Result[0][3] = static_cast(0); Result[1][0] =-c1 * s3 - c2 * c3 * s1; Result[1][1] = c1 * c2 * c3 - s1 * s3; Result[1][2] = c3 * s2; Result[1][3] = static_cast(0); Result[2][0] = s1 * s2; Result[2][1] =-c1 * s2; Result[2][2] = c2; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZY ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c2 * c3; Result[0][1] = s1 * s3 + c1 * c3 * s2; Result[0][2] = c3 * s1 * s2 - c1 * s3; Result[0][3] = static_cast(0); Result[1][0] =-s2; Result[1][1] = c1 * c2; Result[1][2] = c2 * s1; Result[1][3] = static_cast(0); Result[2][0] = c2 * s3; Result[2][1] = c1 * s2 * s3 - c3 * s1; Result[2][2] = c1 * c3 + s1 * s2 *s3; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZX ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c1 * c2; Result[0][1] = s2; Result[0][2] =-c2 * s1; Result[0][3] = static_cast(0); Result[1][0] = s1 * s3 - c1 * c3 * s2; Result[1][1] = c2 * c3; Result[1][2] = c1 * s3 + c3 * s1 * s2; Result[1][3] = static_cast(0); Result[2][0] = c3 * s1 + c1 * s2 * s3; Result[2][1] =-c2 * s3; Result[2][2] = c1 * c3 - s1 * s2 * s3; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZYX ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c1 * c2; Result[0][1] = c2 * s1; Result[0][2] =-s2; Result[0][3] = static_cast(0); Result[1][0] = c1 * s2 * s3 - c3 * s1; Result[1][1] = c1 * c3 + s1 * s2 * s3; Result[1][2] = c2 * s3; Result[1][3] = static_cast(0); Result[2][0] = s1 * s3 + c1 * c3 * s2; Result[2][1] = c3 * s1 * s2 - c1 * s3; Result[2][2] = c2 * c3; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZXY ( T const & t1, T const & t2, T const & t3 ) { T c1 = glm::cos(t1); T s1 = glm::sin(t1); T c2 = glm::cos(t2); T s2 = glm::sin(t2); T c3 = glm::cos(t3); T s3 = glm::sin(t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c1 * c3 - s1 * s2 * s3; Result[0][1] = c3 * s1 + c1 * s2 * s3; Result[0][2] =-c2 * s3; Result[0][3] = static_cast(0); Result[1][0] =-c2 * s1; Result[1][1] = c1 * c2; Result[1][2] = s2; Result[1][3] = static_cast(0); Result[2][0] = c1 * s3 + c3 * s1 * s2; Result[2][1] = s1 * s3 - c1 * c3 * s2; Result[2][2] = c2 * c3; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> yawPitchRoll ( T const& yaw, T const& pitch, T const& roll ) { T tmp_ch = glm::cos(yaw); T tmp_sh = glm::sin(yaw); T tmp_cp = glm::cos(pitch); T tmp_sp = glm::sin(pitch); T tmp_cb = glm::cos(roll); T tmp_sb = glm::sin(roll); mat<4, 4, T, defaultp> Result; Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb; Result[0][1] = tmp_sb * tmp_cp; Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb; Result[0][3] = static_cast(0); Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb; Result[1][1] = tmp_cb * tmp_cp; Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb; Result[1][3] = static_cast(0); Result[2][0] = tmp_sh * tmp_cp; Result[2][1] = -tmp_sp; Result[2][2] = tmp_ch * tmp_cp; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> orientate2 ( T const& angle ) { T c = glm::cos(angle); T s = glm::sin(angle); mat<2, 2, T, defaultp> Result; Result[0][0] = c; Result[0][1] = s; Result[1][0] = -s; Result[1][1] = c; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> orientate3 ( T const& angle ) { T c = glm::cos(angle); T s = glm::sin(angle); mat<3, 3, T, defaultp> Result; Result[0][0] = c; Result[0][1] = s; Result[0][2] = 0.0f; Result[1][0] = -s; Result[1][1] = c; Result[1][2] = 0.0f; Result[2][0] = 0.0f; Result[2][1] = 0.0f; Result[2][2] = 1.0f; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orientate3 ( vec<3, T, Q> const& angles ) { return mat<3, 3, T, Q>(yawPitchRoll(angles.z, angles.x, angles.y)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> orientate4 ( vec<3, T, Q> const& angles ) { return yawPitchRoll(angles.z, angles.x, angles.y); } template GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const& M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[2][1], M[2][2]); T C2 = glm::sqrt(M[0][0]*M[0][0] + M[1][0]*M[1][0]); T T2 = glm::atan2(-M[2][0], C2); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(S1*M[0][2] - C1*M[0][1], C1*M[1][1] - S1*M[1][2 ]); t1 = -T1; t2 = -T2; t3 = -T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleYXZ(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[2][0], M[2][2]); T C2 = glm::sqrt(M[0][1]*M[0][1] + M[1][1]*M[1][1]); T T2 = glm::atan2(-M[2][1], C2); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(S1*M[1][2] - C1*M[1][0], C1*M[0][0] - S1*M[0][2]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleXZX(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[0][2], M[0][1]); T S2 = glm::sqrt(M[1][0]*M[1][0] + M[2][0]*M[2][0]); T T2 = glm::atan2(S2, M[0][0]); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(C1*M[1][2] - S1*M[1][1], C1*M[2][2] - S1*M[2][1]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleXYX(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[0][1], -M[0][2]); T S2 = glm::sqrt(M[1][0]*M[1][0] + M[2][0]*M[2][0]); T T2 = glm::atan2(S2, M[0][0]); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(-C1*M[2][1] - S1*M[2][2], C1*M[1][1] + S1*M[1][2]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleYXY(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[1][0], M[1][2]); T S2 = glm::sqrt(M[0][1]*M[0][1] + M[2][1]*M[2][1]); T T2 = glm::atan2(S2, M[1][1]); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(C1*M[2][0] - S1*M[2][2], C1*M[0][0] - S1*M[0][2]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleYZY(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[1][2], -M[1][0]); T S2 = glm::sqrt(M[0][1]*M[0][1] + M[2][1]*M[2][1]); T T2 = glm::atan2(S2, M[1][1]); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(-S1*M[0][0] - C1*M[0][2], S1*M[2][0] + C1*M[2][2]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleZYZ(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[2][1], M[2][0]); T S2 = glm::sqrt(M[0][2]*M[0][2] + M[1][2]*M[1][2]); T T2 = glm::atan2(S2, M[2][2]); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(C1*M[0][1] - S1*M[0][0], C1*M[1][1] - S1*M[1][0]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleZXZ(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[2][0], -M[2][1]); T S2 = glm::sqrt(M[0][2]*M[0][2] + M[1][2]*M[1][2]); T T2 = glm::atan2(S2, M[2][2]); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(-C1*M[1][0] - S1*M[1][1], C1*M[0][0] + S1*M[0][1]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleXZY(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[1][2], M[1][1]); T C2 = glm::sqrt(M[0][0]*M[0][0] + M[2][0]*M[2][0]); T T2 = glm::atan2(-M[1][0], C2); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(S1*M[0][1] - C1*M[0][2], C1*M[2][2] - S1*M[2][1]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleYZX(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(-M[0][2], M[0][0]); T C2 = glm::sqrt(M[1][1]*M[1][1] + M[2][1]*M[2][1]); T T2 = glm::atan2(M[0][1], C2); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(S1*M[1][0] + C1*M[1][2], S1*M[2][0] + C1*M[2][2]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleZYX(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(M[0][1], M[0][0]); T C2 = glm::sqrt(M[1][2]*M[1][2] + M[2][2]*M[2][2]); T T2 = glm::atan2(-M[0][2], C2); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(S1*M[2][0] - C1*M[2][1], C1*M[1][1] - S1*M[1][0]); t1 = T1; t2 = T2; t3 = T3; } template GLM_FUNC_QUALIFIER void extractEulerAngleZXY(mat<4, 4, T, defaultp> const & M, T & t1, T & t2, T & t3) { T T1 = glm::atan2(-M[1][0], M[1][1]); T C2 = glm::sqrt(M[0][2]*M[0][2] + M[2][2]*M[2][2]); T T2 = glm::atan2(M[1][2], C2); T S1 = glm::sin(T1); T C1 = glm::cos(T1); T T3 = glm::atan2(C1*M[2][0] + S1*M[2][1], C1*M[0][0] + S1*M[0][1]); t1 = T1; t2 = T2; t3 = T3; } }//namespace glm ================================================ FILE: android/src/glm/gtx/extend.hpp ================================================ /// @ref gtx_extend /// @file glm/gtx/extend.hpp /// /// @see core (dependence) /// /// @defgroup gtx_extend GLM_GTX_extend /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Extend a position from a source to a position at a defined length. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_extend extension included") # endif #endif namespace glm { /// @addtogroup gtx_extend /// @{ /// Extends of Length the Origin position using the (Source - Origin) direction. /// @see gtx_extend template GLM_FUNC_DECL genType extend( genType const& Origin, genType const& Source, typename genType::value_type const Length); /// @} }//namespace glm #include "extend.inl" ================================================ FILE: android/src/glm/gtx/extend.inl ================================================ /// @ref gtx_extend namespace glm { template GLM_FUNC_QUALIFIER genType extend ( genType const& Origin, genType const& Source, genType const& Distance ) { return Origin + (Source - Origin) * Distance; } template GLM_FUNC_QUALIFIER vec<2, T, Q> extend ( vec<2, T, Q> const& Origin, vec<2, T, Q> const& Source, T const& Distance ) { return Origin + (Source - Origin) * Distance; } template GLM_FUNC_QUALIFIER vec<3, T, Q> extend ( vec<3, T, Q> const& Origin, vec<3, T, Q> const& Source, T const& Distance ) { return Origin + (Source - Origin) * Distance; } template GLM_FUNC_QUALIFIER vec<4, T, Q> extend ( vec<4, T, Q> const& Origin, vec<4, T, Q> const& Source, T const& Distance ) { return Origin + (Source - Origin) * Distance; } }//namespace glm ================================================ FILE: android/src/glm/gtx/extended_min_max.hpp ================================================ /// @ref gtx_extended_min_max /// @file glm/gtx/extended_min_max.hpp /// /// @see core (dependence) /// /// @defgroup gtx_extended_min_max GLM_GTX_extented_min_max /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Min and max functions for 3 to 4 parameters. #pragma once // Dependency: #include "../glm.hpp" #include "../ext/vector_common.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_extented_min_max is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_extented_min_max extension included") # endif #endif namespace glm { /// @addtogroup gtx_extended_min_max /// @{ /// Return the minimum component-wise values of 3 inputs /// @see gtx_extented_min_max template GLM_FUNC_DECL T min( T const& x, T const& y, T const& z); /// Return the minimum component-wise values of 3 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C min( C const& x, typename C::T const& y, typename C::T const& z); /// Return the minimum component-wise values of 3 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C min( C const& x, C const& y, C const& z); /// Return the minimum component-wise values of 4 inputs /// @see gtx_extented_min_max template GLM_FUNC_DECL T min( T const& x, T const& y, T const& z, T const& w); /// Return the minimum component-wise values of 4 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C min( C const& x, typename C::T const& y, typename C::T const& z, typename C::T const& w); /// Return the minimum component-wise values of 4 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C min( C const& x, C const& y, C const& z, C const& w); /// Return the maximum component-wise values of 3 inputs /// @see gtx_extented_min_max template GLM_FUNC_DECL T max( T const& x, T const& y, T const& z); /// Return the maximum component-wise values of 3 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C max( C const& x, typename C::T const& y, typename C::T const& z); /// Return the maximum component-wise values of 3 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C max( C const& x, C const& y, C const& z); /// Return the maximum component-wise values of 4 inputs /// @see gtx_extented_min_max template GLM_FUNC_DECL T max( T const& x, T const& y, T const& z, T const& w); /// Return the maximum component-wise values of 4 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C max( C const& x, typename C::T const& y, typename C::T const& z, typename C::T const& w); /// Return the maximum component-wise values of 4 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C max( C const& x, C const& y, C const& z, C const& w); /// @} }//namespace glm #include "extended_min_max.inl" ================================================ FILE: android/src/glm/gtx/extended_min_max.inl ================================================ /// @ref gtx_extended_min_max namespace glm { template GLM_FUNC_QUALIFIER T min( T const& x, T const& y, T const& z) { return glm::min(glm::min(x, y), z); } template class C> GLM_FUNC_QUALIFIER C min ( C const& x, typename C::T const& y, typename C::T const& z ) { return glm::min(glm::min(x, y), z); } template class C> GLM_FUNC_QUALIFIER C min ( C const& x, C const& y, C const& z ) { return glm::min(glm::min(x, y), z); } template GLM_FUNC_QUALIFIER T min ( T const& x, T const& y, T const& z, T const& w ) { return glm::min(glm::min(x, y), glm::min(z, w)); } template class C> GLM_FUNC_QUALIFIER C min ( C const& x, typename C::T const& y, typename C::T const& z, typename C::T const& w ) { return glm::min(glm::min(x, y), glm::min(z, w)); } template class C> GLM_FUNC_QUALIFIER C min ( C const& x, C const& y, C const& z, C const& w ) { return glm::min(glm::min(x, y), glm::min(z, w)); } template GLM_FUNC_QUALIFIER T max( T const& x, T const& y, T const& z) { return glm::max(glm::max(x, y), z); } template class C> GLM_FUNC_QUALIFIER C max ( C const& x, typename C::T const& y, typename C::T const& z ) { return glm::max(glm::max(x, y), z); } template class C> GLM_FUNC_QUALIFIER C max ( C const& x, C const& y, C const& z ) { return glm::max(glm::max(x, y), z); } template GLM_FUNC_QUALIFIER T max ( T const& x, T const& y, T const& z, T const& w ) { return glm::max(glm::max(x, y), glm::max(z, w)); } template class C> GLM_FUNC_QUALIFIER C max ( C const& x, typename C::T const& y, typename C::T const& z, typename C::T const& w ) { return glm::max(glm::max(x, y), glm::max(z, w)); } template class C> GLM_FUNC_QUALIFIER C max ( C const& x, C const& y, C const& z, C const& w ) { return glm::max(glm::max(x, y), glm::max(z, w)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/exterior_product.hpp ================================================ /// @ref gtx_exterior_product /// @file glm/gtx/exterior_product.hpp /// /// @see core (dependence) /// @see gtx_exterior_product (dependence) /// /// @defgroup gtx_exterior_product GLM_GTX_exterior_product /// @ingroup gtx /// /// Include to use the features of this extension. /// /// @brief Allow to perform bit operations on integer values #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_exterior_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_exterior_product extension included") # endif #endif namespace glm { /// @addtogroup gtx_exterior_product /// @{ /// Returns the cross product of x and y. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see Exterior product template GLM_FUNC_DECL T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u); /// @} } //namespace glm #include "exterior_product.inl" ================================================ FILE: android/src/glm/gtx/exterior_product.inl ================================================ /// @ref gtx_exterior_product #include namespace glm { namespace detail { template struct compute_cross_vec2 { GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); return v.x * u.y - u.x * v.y; } }; }//namespace detail template GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y) { return detail::compute_cross_vec2::value>::call(x, y); } }//namespace glm ================================================ FILE: android/src/glm/gtx/fast_exponential.hpp ================================================ /// @ref gtx_fast_exponential /// @file glm/gtx/fast_exponential.hpp /// /// @see core (dependence) /// @see gtx_half_float (dependence) /// /// @defgroup gtx_fast_exponential GLM_GTX_fast_exponential /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Fast but less accurate implementations of exponential based functions. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_fast_exponential is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_fast_exponential extension included") # endif #endif namespace glm { /// @addtogroup gtx_fast_exponential /// @{ /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL genType fastPow(genType x, genType y); /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastPow(vec const& x, vec const& y); /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL genTypeT fastPow(genTypeT x, genTypeU y); /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastPow(vec const& x); /// Faster than the common exp function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL T fastExp(T x); /// Faster than the common exp function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastExp(vec const& x); /// Faster than the common log function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL T fastLog(T x); /// Faster than the common exp2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastLog(vec const& x); /// Faster than the common exp2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL T fastExp2(T x); /// Faster than the common exp2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastExp2(vec const& x); /// Faster than the common log2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL T fastLog2(T x); /// Faster than the common log2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastLog2(vec const& x); /// @} }//namespace glm #include "fast_exponential.inl" ================================================ FILE: android/src/glm/gtx/fast_exponential.inl ================================================ /// @ref gtx_fast_exponential namespace glm { // fastPow: template GLM_FUNC_QUALIFIER genType fastPow(genType x, genType y) { return exp(y * log(x)); } template GLM_FUNC_QUALIFIER vec fastPow(vec const& x, vec const& y) { return exp(y * log(x)); } template GLM_FUNC_QUALIFIER T fastPow(T x, int y) { T f = static_cast(1); for(int i = 0; i < y; ++i) f *= x; return f; } template GLM_FUNC_QUALIFIER vec fastPow(vec const& x, vec const& y) { vec Result; for(length_t i = 0, n = x.length(); i < n; ++i) Result[i] = fastPow(x[i], y[i]); return Result; } // fastExp // Note: This function provides accurate results only for value between -1 and 1, else avoid it. template GLM_FUNC_QUALIFIER T fastExp(T x) { // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower. // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f)))); T x2 = x * x; T x3 = x2 * x; T x4 = x3 * x; T x5 = x4 * x; return T(1) + x + (x2 * T(0.5)) + (x3 * T(0.1666666667)) + (x4 * T(0.041666667)) + (x5 * T(0.008333333333)); } /* // Try to handle all values of float... but often shower than std::exp, glm::floor and the loop kill the performance GLM_FUNC_QUALIFIER float fastExp(float x) { const float e = 2.718281828f; const float IntegerPart = floor(x); const float FloatPart = x - IntegerPart; float z = 1.f; for(int i = 0; i < int(IntegerPart); ++i) z *= e; const float x2 = FloatPart * FloatPart; const float x3 = x2 * FloatPart; const float x4 = x3 * FloatPart; const float x5 = x4 * FloatPart; return z * (1.0f + FloatPart + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)); } // Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers GLM_FUNC_QUALIFIER float fastExp(float x) { // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower. // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f)))); float x2 = x * x; float x3 = x2 * x; float x4 = x3 * x; float x5 = x4 * x; float x6 = x5 * x; float x7 = x6 * x; float x8 = x7 * x; return 1.0f + x + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)+ (x6 * 0.00138888888888f) + (x7 * 0.000198412698f) + (x8 * 0.0000248015873f);; } */ template GLM_FUNC_QUALIFIER vec fastExp(vec const& x) { return detail::functor1::call(fastExp, x); } // fastLog template GLM_FUNC_QUALIFIER genType fastLog(genType x) { return std::log(x); } /* Slower than the VC7.1 function... GLM_FUNC_QUALIFIER float fastLog(float x) { float y1 = (x - 1.0f) / (x + 1.0f); float y2 = y1 * y1; return 2.0f * y1 * (1.0f + y2 * (0.3333333333f + y2 * (0.2f + y2 * 0.1428571429f))); } */ template GLM_FUNC_QUALIFIER vec fastLog(vec const& x) { return detail::functor1::call(fastLog, x); } //fastExp2, ln2 = 0.69314718055994530941723212145818f template GLM_FUNC_QUALIFIER genType fastExp2(genType x) { return fastExp(0.69314718055994530941723212145818f * x); } template GLM_FUNC_QUALIFIER vec fastExp2(vec const& x) { return detail::functor1::call(fastExp2, x); } // fastLog2, ln2 = 0.69314718055994530941723212145818f template GLM_FUNC_QUALIFIER genType fastLog2(genType x) { return fastLog(x) / 0.69314718055994530941723212145818f; } template GLM_FUNC_QUALIFIER vec fastLog2(vec const& x) { return detail::functor1::call(fastLog2, x); } }//namespace glm ================================================ FILE: android/src/glm/gtx/fast_square_root.hpp ================================================ /// @ref gtx_fast_square_root /// @file glm/gtx/fast_square_root.hpp /// /// @see core (dependence) /// /// @defgroup gtx_fast_square_root GLM_GTX_fast_square_root /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Fast but less accurate implementations of square root based functions. /// - Sqrt optimisation based on Newton's method, /// www.gamedev.net/community/forums/topic.asp?topic id=139956 #pragma once // Dependency: #include "../common.hpp" #include "../exponential.hpp" #include "../geometric.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_fast_square_root is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_fast_square_root extension included") # endif #endif namespace glm { /// @addtogroup gtx_fast_square_root /// @{ /// Faster than the common sqrt function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastSqrt(genType x); /// Faster than the common sqrt function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL vec fastSqrt(vec const& x); /// Faster than the common inversesqrt function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastInverseSqrt(genType x); /// Faster than the common inversesqrt function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL vec fastInverseSqrt(vec const& x); /// Faster than the common length function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastLength(genType x); /// Faster than the common length function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL T fastLength(vec const& x); /// Faster than the common distance function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastDistance(genType x, genType y); /// Faster than the common distance function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL T fastDistance(vec const& x, vec const& y); /// Faster than the common normalize function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastNormalize(genType const& x); /// @} }// namespace glm #include "fast_square_root.inl" ================================================ FILE: android/src/glm/gtx/fast_square_root.inl ================================================ /// @ref gtx_fast_square_root namespace glm { // fastSqrt template GLM_FUNC_QUALIFIER genType fastSqrt(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastSqrt' only accept floating-point input"); return genType(1) / fastInverseSqrt(x); } template GLM_FUNC_QUALIFIER vec fastSqrt(vec const& x) { return detail::functor1::call(fastSqrt, x); } // fastInversesqrt template GLM_FUNC_QUALIFIER genType fastInverseSqrt(genType x) { return detail::compute_inversesqrt<1, genType, lowp, detail::is_aligned::value>::call(vec<1, genType, lowp>(x)).x; } template GLM_FUNC_QUALIFIER vec fastInverseSqrt(vec const& x) { return detail::compute_inversesqrt::value>::call(x); } // fastLength template GLM_FUNC_QUALIFIER genType fastLength(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastLength' only accept floating-point inputs"); return abs(x); } template GLM_FUNC_QUALIFIER T fastLength(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastLength' only accept floating-point inputs"); return fastSqrt(dot(x, x)); } // fastDistance template GLM_FUNC_QUALIFIER genType fastDistance(genType x, genType y) { return fastLength(y - x); } template GLM_FUNC_QUALIFIER T fastDistance(vec const& x, vec const& y) { return fastLength(y - x); } // fastNormalize template GLM_FUNC_QUALIFIER genType fastNormalize(genType x) { return x > genType(0) ? genType(1) : -genType(1); } template GLM_FUNC_QUALIFIER vec fastNormalize(vec const& x) { return x * fastInverseSqrt(dot(x, x)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/fast_trigonometry.hpp ================================================ /// @ref gtx_fast_trigonometry /// @file glm/gtx/fast_trigonometry.hpp /// /// @see core (dependence) /// /// @defgroup gtx_fast_trigonometry GLM_GTX_fast_trigonometry /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Fast but less accurate implementations of trigonometric functions. #pragma once // Dependency: #include "../gtc/constants.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_fast_trigonometry is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_fast_trigonometry extension included") # endif #endif namespace glm { /// @addtogroup gtx_fast_trigonometry /// @{ /// Wrap an angle to [0 2pi[ /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T wrapAngle(T angle); /// Faster than the common sin function but less accurate. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastSin(T angle); /// Faster than the common cos function but less accurate. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastCos(T angle); /// Faster than the common tan function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastTan(T angle); /// Faster than the common asin function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastAsin(T angle); /// Faster than the common acos function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastAcos(T angle); /// Faster than the common atan function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastAtan(T y, T x); /// Faster than the common atan function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastAtan(T angle); /// @} }//namespace glm #include "fast_trigonometry.inl" ================================================ FILE: android/src/glm/gtx/fast_trigonometry.inl ================================================ /// @ref gtx_fast_trigonometry namespace glm{ namespace detail { template GLM_FUNC_QUALIFIER vec taylorCos(vec const& x) { return static_cast(1) - (x * x) * (1.f / 2.f) + ((x * x) * (x * x)) * (1.f / 24.f) - (((x * x) * (x * x)) * (x * x)) * (1.f / 720.f) + (((x * x) * (x * x)) * ((x * x) * (x * x))) * (1.f / 40320.f); } template GLM_FUNC_QUALIFIER T cos_52s(T x) { T const xx(x * x); return (T(0.9999932946) + xx * (T(-0.4999124376) + xx * (T(0.0414877472) + xx * T(-0.0012712095)))); } template GLM_FUNC_QUALIFIER vec cos_52s(vec const& x) { return detail::functor1::call(cos_52s, x); } }//namespace detail // wrapAngle template GLM_FUNC_QUALIFIER T wrapAngle(T angle) { return abs(mod(angle, two_pi())); } template GLM_FUNC_QUALIFIER vec wrapAngle(vec const& x) { return detail::functor1::call(wrapAngle, x); } // cos template GLM_FUNC_QUALIFIER T fastCos(T x) { T const angle(wrapAngle(x)); if(angle < half_pi()) return detail::cos_52s(angle); if(angle < pi()) return -detail::cos_52s(pi() - angle); if(angle < (T(3) * half_pi())) return -detail::cos_52s(angle - pi()); return detail::cos_52s(two_pi() - angle); } template GLM_FUNC_QUALIFIER vec fastCos(vec const& x) { return detail::functor1::call(fastCos, x); } // sin template GLM_FUNC_QUALIFIER T fastSin(T x) { return fastCos(half_pi() - x); } template GLM_FUNC_QUALIFIER vec fastSin(vec const& x) { return detail::functor1::call(fastSin, x); } // tan template GLM_FUNC_QUALIFIER T fastTan(T x) { return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539)); } template GLM_FUNC_QUALIFIER vec fastTan(vec const& x) { return detail::functor1::call(fastTan, x); } // asin template GLM_FUNC_QUALIFIER T fastAsin(T x) { return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159)); } template GLM_FUNC_QUALIFIER vec fastAsin(vec const& x) { return detail::functor1::call(fastAsin, x); } // acos template GLM_FUNC_QUALIFIER T fastAcos(T x) { return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2) } template GLM_FUNC_QUALIFIER vec fastAcos(vec const& x) { return detail::functor1::call(fastAcos, x); } // atan template GLM_FUNC_QUALIFIER T fastAtan(T y, T x) { T sgn = sign(y) * sign(x); return abs(fastAtan(y / x)) * sgn; } template GLM_FUNC_QUALIFIER vec fastAtan(vec const& y, vec const& x) { return detail::functor2::call(fastAtan, y, x); } template GLM_FUNC_QUALIFIER T fastAtan(T x) { return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909)); } template GLM_FUNC_QUALIFIER vec fastAtan(vec const& x) { return detail::functor1::call(fastAtan, x); } }//namespace glm ================================================ FILE: android/src/glm/gtx/float_notmalize.inl ================================================ /// @ref gtx_float_normalize #include namespace glm { template GLM_FUNC_QUALIFIER vec floatNormalize(vec const& v) { return vec(v) / static_cast(std::numeric_limits::max()); } }//namespace glm ================================================ FILE: android/src/glm/gtx/functions.hpp ================================================ /// @ref gtx_functions /// @file glm/gtx/functions.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_functions GLM_GTX_functions /// @ingroup gtx /// /// Include to use the features of this extension. /// /// List of useful common functions. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/type_vec2.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_functions is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_functions extension included") # endif #endif namespace glm { /// @addtogroup gtx_functions /// @{ /// 1D gauss function /// /// @see gtc_epsilon template GLM_FUNC_DECL T gauss( T x, T ExpectedValue, T StandardDeviation); /// 2D gauss function /// /// @see gtc_epsilon template GLM_FUNC_DECL T gauss( vec<2, T, Q> const& Coord, vec<2, T, Q> const& ExpectedValue, vec<2, T, Q> const& StandardDeviation); /// @} }//namespace glm #include "functions.inl" ================================================ FILE: android/src/glm/gtx/functions.inl ================================================ /// @ref gtx_functions #include "../exponential.hpp" namespace glm { template GLM_FUNC_QUALIFIER T gauss ( T x, T ExpectedValue, T StandardDeviation ) { return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); } template GLM_FUNC_QUALIFIER T gauss ( vec<2, T, Q> const& Coord, vec<2, T, Q> const& ExpectedValue, vec<2, T, Q> const& StandardDeviation ) { vec<2, T, Q> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation); return exp(-(Squared.x + Squared.y)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/gradient_paint.hpp ================================================ /// @ref gtx_gradient_paint /// @file glm/gtx/gradient_paint.hpp /// /// @see core (dependence) /// @see gtx_optimum_pow (dependence) /// /// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Functions that return the color of procedural gradient for specific coordinates. #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/optimum_pow.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_gradient_paint is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_gradient_paint extension included") # endif #endif namespace glm { /// @addtogroup gtx_gradient_paint /// @{ /// Return a color from a radial gradient. /// @see - gtx_gradient_paint template GLM_FUNC_DECL T radialGradient( vec<2, T, Q> const& Center, T const& Radius, vec<2, T, Q> const& Focal, vec<2, T, Q> const& Position); /// Return a color from a linear gradient. /// @see - gtx_gradient_paint template GLM_FUNC_DECL T linearGradient( vec<2, T, Q> const& Point0, vec<2, T, Q> const& Point1, vec<2, T, Q> const& Position); /// @} }// namespace glm #include "gradient_paint.inl" ================================================ FILE: android/src/glm/gtx/gradient_paint.inl ================================================ /// @ref gtx_gradient_paint namespace glm { template GLM_FUNC_QUALIFIER T radialGradient ( vec<2, T, Q> const& Center, T const& Radius, vec<2, T, Q> const& Focal, vec<2, T, Q> const& Position ) { vec<2, T, Q> F = Focal - Center; vec<2, T, Q> D = Position - Focal; T Radius2 = pow2(Radius); T Fx2 = pow2(F.x); T Fy2 = pow2(F.y); T Numerator = (D.x * F.x + D.y * F.y) + sqrt(Radius2 * (pow2(D.x) + pow2(D.y)) - pow2(D.x * F.y - D.y * F.x)); T Denominator = Radius2 - (Fx2 + Fy2); return Numerator / Denominator; } template GLM_FUNC_QUALIFIER T linearGradient ( vec<2, T, Q> const& Point0, vec<2, T, Q> const& Point1, vec<2, T, Q> const& Position ) { vec<2, T, Q> Dist = Point1 - Point0; return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist); } }//namespace glm ================================================ FILE: android/src/glm/gtx/handed_coordinate_space.hpp ================================================ /// @ref gtx_handed_coordinate_space /// @file glm/gtx/handed_coordinate_space.hpp /// /// @see core (dependence) /// /// @defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space /// @ingroup gtx /// /// Include to use the features of this extension. /// /// To know if a set of three basis vectors defines a right or left-handed coordinate system. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_handed_coordinate_space is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_handed_coordinate_space extension included") # endif #endif namespace glm { /// @addtogroup gtx_handed_coordinate_space /// @{ //! Return if a trihedron right handed or not. //! From GLM_GTX_handed_coordinate_space extension. template GLM_FUNC_DECL bool rightHanded( vec<3, T, Q> const& tangent, vec<3, T, Q> const& binormal, vec<3, T, Q> const& normal); //! Return if a trihedron left handed or not. //! From GLM_GTX_handed_coordinate_space extension. template GLM_FUNC_DECL bool leftHanded( vec<3, T, Q> const& tangent, vec<3, T, Q> const& binormal, vec<3, T, Q> const& normal); /// @} }// namespace glm #include "handed_coordinate_space.inl" ================================================ FILE: android/src/glm/gtx/handed_coordinate_space.inl ================================================ /// @ref gtx_handed_coordinate_space namespace glm { template GLM_FUNC_QUALIFIER bool rightHanded ( vec<3, T, Q> const& tangent, vec<3, T, Q> const& binormal, vec<3, T, Q> const& normal ) { return dot(cross(normal, tangent), binormal) > T(0); } template GLM_FUNC_QUALIFIER bool leftHanded ( vec<3, T, Q> const& tangent, vec<3, T, Q> const& binormal, vec<3, T, Q> const& normal ) { return dot(cross(normal, tangent), binormal) < T(0); } }//namespace glm ================================================ FILE: android/src/glm/gtx/hash.hpp ================================================ /// @ref gtx_hash /// @file glm/gtx/hash.hpp /// /// @see core (dependence) /// /// @defgroup gtx_hash GLM_GTX_hash /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add std::hash support for glm types #pragma once #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_hash is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_hash extension included") # endif #endif #include #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../gtc/vec1.hpp" #include "../gtc/quaternion.hpp" #include "../gtx/dual_quaternion.hpp" #include "../mat2x2.hpp" #include "../mat2x3.hpp" #include "../mat2x4.hpp" #include "../mat3x2.hpp" #include "../mat3x3.hpp" #include "../mat3x4.hpp" #include "../mat4x2.hpp" #include "../mat4x3.hpp" #include "../mat4x4.hpp" #if !GLM_HAS_CXX11_STL # error "GLM_GTX_hash requires C++11 standard library support" #endif namespace std { template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<1, T, Q> const& v) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<2, T, Q> const& v) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<3, T, Q> const& v) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<4, T, Q> const& v) const; }; template struct hash> { GLM_FUNC_DECL size_t operator()(glm::qua const& q) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::tdualquat const& q) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<2, 2, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<2, 3, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<2, 4, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<3, 2, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<3, 3, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<3, 4, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<4, 2, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<4, 3, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<4, 4, T,Q> const& m) const; }; } // namespace std #include "hash.inl" ================================================ FILE: android/src/glm/gtx/hash.inl ================================================ /// @ref gtx_hash /// /// @see core (dependence) /// /// @defgroup gtx_hash GLM_GTX_hash /// @ingroup gtx /// /// @brief Add std::hash support for glm types /// /// need to be included to use the features of this extension. namespace glm { namespace detail { GLM_INLINE void hash_combine(size_t &seed, size_t hash) { hash += 0x9e3779b9 + (seed << 6) + (seed >> 2); seed ^= hash; } }} namespace std { template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<1, T, Q> const& v) const { hash hasher; return hasher(v.x); } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<2, T, Q> const& v) const { size_t seed = 0; hash hasher; glm::detail::hash_combine(seed, hasher(v.x)); glm::detail::hash_combine(seed, hasher(v.y)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<3, T, Q> const& v) const { size_t seed = 0; hash hasher; glm::detail::hash_combine(seed, hasher(v.x)); glm::detail::hash_combine(seed, hasher(v.y)); glm::detail::hash_combine(seed, hasher(v.z)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<4, T, Q> const& v) const { size_t seed = 0; hash hasher; glm::detail::hash_combine(seed, hasher(v.x)); glm::detail::hash_combine(seed, hasher(v.y)); glm::detail::hash_combine(seed, hasher(v.z)); glm::detail::hash_combine(seed, hasher(v.w)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::qua const& q) const { size_t seed = 0; hash hasher; glm::detail::hash_combine(seed, hasher(q.x)); glm::detail::hash_combine(seed, hasher(q.y)); glm::detail::hash_combine(seed, hasher(q.z)); glm::detail::hash_combine(seed, hasher(q.w)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tdualquat const& q) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(q.real)); glm::detail::hash_combine(seed, hasher(q.dual)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<2, 2, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<2, 3, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<2, 4, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<3, 2, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<3, 3, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<3, 4, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<4, 2, T,Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); glm::detail::hash_combine(seed, hasher(m[3])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<4, 3, T,Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); glm::detail::hash_combine(seed, hasher(m[3])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<4, 4, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); glm::detail::hash_combine(seed, hasher(m[3])); return seed; } } ================================================ FILE: android/src/glm/gtx/integer.hpp ================================================ /// @ref gtx_integer /// @file glm/gtx/integer.hpp /// /// @see core (dependence) /// /// @defgroup gtx_integer GLM_GTX_integer /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add support for integer for core functions #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/integer.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_integer is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_integer extension included") # endif #endif namespace glm { /// @addtogroup gtx_integer /// @{ //! Returns x raised to the y power. //! From GLM_GTX_integer extension. GLM_FUNC_DECL int pow(int x, uint y); //! Returns the positive square root of x. //! From GLM_GTX_integer extension. GLM_FUNC_DECL int sqrt(int x); //! Returns the floor log2 of x. //! From GLM_GTX_integer extension. GLM_FUNC_DECL unsigned int floor_log2(unsigned int x); //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. //! From GLM_GTX_integer extension. GLM_FUNC_DECL int mod(int x, int y); //! Return the factorial value of a number (!12 max, integer only) //! From GLM_GTX_integer extension. template GLM_FUNC_DECL genType factorial(genType const& x); //! 32bit signed integer. //! From GLM_GTX_integer extension. typedef signed int sint; //! Returns x raised to the y power. //! From GLM_GTX_integer extension. GLM_FUNC_DECL uint pow(uint x, uint y); //! Returns the positive square root of x. //! From GLM_GTX_integer extension. GLM_FUNC_DECL uint sqrt(uint x); //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. //! From GLM_GTX_integer extension. GLM_FUNC_DECL uint mod(uint x, uint y); //! Returns the number of leading zeros. //! From GLM_GTX_integer extension. GLM_FUNC_DECL uint nlz(uint x); /// @} }//namespace glm #include "integer.inl" ================================================ FILE: android/src/glm/gtx/integer.inl ================================================ /// @ref gtx_integer namespace glm { // pow GLM_FUNC_QUALIFIER int pow(int x, uint y) { if(y == 0) return x >= 0 ? 1 : -1; int result = x; for(uint i = 1; i < y; ++i) result *= x; return result; } // sqrt: From Christopher J. Musial, An integer square root, Graphics Gems, 1990, page 387 GLM_FUNC_QUALIFIER int sqrt(int x) { if(x <= 1) return x; int NextTrial = x >> 1; int CurrentAnswer; do { CurrentAnswer = NextTrial; NextTrial = (NextTrial + x / NextTrial) >> 1; } while(NextTrial < CurrentAnswer); return CurrentAnswer; } // Henry Gordon Dietz: http://aggregate.org/MAGIC/ namespace detail { GLM_FUNC_QUALIFIER unsigned int ones32(unsigned int x) { /* 32-bit recursive reduction using SWAR... but first step is mapping 2-bit values into sum of 2 1-bit values in sneaky way */ x -= ((x >> 1) & 0x55555555); x = (((x >> 2) & 0x33333333) + (x & 0x33333333)); x = (((x >> 4) + x) & 0x0f0f0f0f); x += (x >> 8); x += (x >> 16); return(x & 0x0000003f); } }//namespace detail // Henry Gordon Dietz: http://aggregate.org/MAGIC/ /* GLM_FUNC_QUALIFIER unsigned int floor_log2(unsigned int x) { x |= (x >> 1); x |= (x >> 2); x |= (x >> 4); x |= (x >> 8); x |= (x >> 16); return _detail::ones32(x) >> 1; } */ // mod GLM_FUNC_QUALIFIER int mod(int x, int y) { return ((x % y) + y) % y; } // factorial (!12 max, integer only) template GLM_FUNC_QUALIFIER genType factorial(genType const& x) { genType Temp = x; genType Result; for(Result = 1; Temp > 1; --Temp) Result *= Temp; return Result; } template GLM_FUNC_QUALIFIER vec<2, T, Q> factorial( vec<2, T, Q> const& x) { return vec<2, T, Q>( factorial(x.x), factorial(x.y)); } template GLM_FUNC_QUALIFIER vec<3, T, Q> factorial( vec<3, T, Q> const& x) { return vec<3, T, Q>( factorial(x.x), factorial(x.y), factorial(x.z)); } template GLM_FUNC_QUALIFIER vec<4, T, Q> factorial( vec<4, T, Q> const& x) { return vec<4, T, Q>( factorial(x.x), factorial(x.y), factorial(x.z), factorial(x.w)); } GLM_FUNC_QUALIFIER uint pow(uint x, uint y) { if (y == 0) return 1u; uint result = x; for(uint i = 1; i < y; ++i) result *= x; return result; } GLM_FUNC_QUALIFIER uint sqrt(uint x) { if(x <= 1) return x; uint NextTrial = x >> 1; uint CurrentAnswer; do { CurrentAnswer = NextTrial; NextTrial = (NextTrial + x / NextTrial) >> 1; } while(NextTrial < CurrentAnswer); return CurrentAnswer; } GLM_FUNC_QUALIFIER uint mod(uint x, uint y) { return x - y * (x / y); } #if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC)) GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) { return 31u - findMSB(x); } #else // Hackers Delight: http://www.hackersdelight.org/HDcode/nlz.c.txt GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) { int y, m, n; y = -int(x >> 16); // If left half of x is 0, m = (y >> 16) & 16; // set n = 16. If left half n = 16 - m; // is nonzero, set n = 0 and x = x >> m; // shift x right 16. // Now x is of the form 0000xxxx. y = x - 0x100; // If positions 8-15 are 0, m = (y >> 16) & 8; // add 8 to n and shift x left 8. n = n + m; x = x << m; y = x - 0x1000; // If positions 12-15 are 0, m = (y >> 16) & 4; // add 4 to n and shift x left 4. n = n + m; x = x << m; y = x - 0x4000; // If positions 14-15 are 0, m = (y >> 16) & 2; // add 2 to n and shift x left 2. n = n + m; x = x << m; y = x >> 14; // Set y = 0, 1, 2, or 3. m = y & ~(y >> 1); // Set m = 0, 1, 2, or 2 resp. return unsigned(n + 2 - m); } #endif//(GLM_COMPILER) }//namespace glm ================================================ FILE: android/src/glm/gtx/intersect.hpp ================================================ /// @ref gtx_intersect /// @file glm/gtx/intersect.hpp /// /// @see core (dependence) /// @see gtx_closest_point (dependence) /// /// @defgroup gtx_intersect GLM_GTX_intersect /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add intersection functions #pragma once // Dependency: #include #include #include "../glm.hpp" #include "../geometric.hpp" #include "../gtx/closest_point.hpp" #include "../gtx/vector_query.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_closest_point extension included") # endif #endif namespace glm { /// @addtogroup gtx_intersect /// @{ //! Compute the intersection of a ray and a plane. //! Ray direction and plane normal must be unit length. //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectRayPlane( genType const& orig, genType const& dir, genType const& planeOrig, genType const& planeNormal, typename genType::value_type & intersectionDistance); //! Compute the intersection of a ray and a triangle. /// Based om Tomas Möller implementation http://fileadmin.cs.lth.se/cs/Personal/Tomas_Akenine-Moller/raytri/ //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectRayTriangle( vec<3, T, Q> const& orig, vec<3, T, Q> const& dir, vec<3, T, Q> const& v0, vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<2, T, Q>& baryPosition, T& distance); //! Compute the intersection of a line and a triangle. //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectLineTriangle( genType const& orig, genType const& dir, genType const& vert0, genType const& vert1, genType const& vert2, genType & position); //! Compute the intersection distance of a ray and a sphere. //! The ray direction vector is unit length. //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectRaySphere( genType const& rayStarting, genType const& rayNormalizedDirection, genType const& sphereCenter, typename genType::value_type const sphereRadiusSquered, typename genType::value_type & intersectionDistance); //! Compute the intersection of a ray and a sphere. //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectRaySphere( genType const& rayStarting, genType const& rayNormalizedDirection, genType const& sphereCenter, const typename genType::value_type sphereRadius, genType & intersectionPosition, genType & intersectionNormal); //! Compute the intersection of a line and a sphere. //! From GLM_GTX_intersect extension template GLM_FUNC_DECL bool intersectLineSphere( genType const& point0, genType const& point1, genType const& sphereCenter, typename genType::value_type sphereRadius, genType & intersectionPosition1, genType & intersectionNormal1, genType & intersectionPosition2 = genType(), genType & intersectionNormal2 = genType()); /// @} }//namespace glm #include "intersect.inl" ================================================ FILE: android/src/glm/gtx/intersect.inl ================================================ /// @ref gtx_intersect namespace glm { template GLM_FUNC_QUALIFIER bool intersectRayPlane ( genType const& orig, genType const& dir, genType const& planeOrig, genType const& planeNormal, typename genType::value_type & intersectionDistance ) { typename genType::value_type d = glm::dot(dir, planeNormal); typename genType::value_type Epsilon = std::numeric_limits::epsilon(); if(glm::abs(d) > Epsilon) // if dir and planeNormal are not perpendicular { typename genType::value_type const tmp_intersectionDistance = glm::dot(planeOrig - orig, planeNormal) / d; if (tmp_intersectionDistance > static_cast(0)) { // allow only intersections intersectionDistance = tmp_intersectionDistance; return true; } } return false; } template GLM_FUNC_QUALIFIER bool intersectRayTriangle ( vec<3, T, Q> const& orig, vec<3, T, Q> const& dir, vec<3, T, Q> const& vert0, vec<3, T, Q> const& vert1, vec<3, T, Q> const& vert2, vec<2, T, Q>& baryPosition, T& distance ) { // find vectors for two edges sharing vert0 vec<3, T, Q> const edge1 = vert1 - vert0; vec<3, T, Q> const edge2 = vert2 - vert0; // begin calculating determinant - also used to calculate U parameter vec<3, T, Q> const p = glm::cross(dir, edge2); // if determinant is near zero, ray lies in plane of triangle T const det = glm::dot(edge1, p); vec<3, T, Q> Perpendicular(0); if(det > std::numeric_limits::epsilon()) { // calculate distance from vert0 to ray origin vec<3, T, Q> const dist = orig - vert0; // calculate U parameter and test bounds baryPosition.x = glm::dot(dist, p); if(baryPosition.x < static_cast(0) || baryPosition.x > det) return false; // prepare to test V parameter Perpendicular = glm::cross(dist, edge1); // calculate V parameter and test bounds baryPosition.y = glm::dot(dir, Perpendicular); if((baryPosition.y < static_cast(0)) || ((baryPosition.x + baryPosition.y) > det)) return false; } else if(det < -std::numeric_limits::epsilon()) { // calculate distance from vert0 to ray origin vec<3, T, Q> const dist = orig - vert0; // calculate U parameter and test bounds baryPosition.x = glm::dot(dist, p); if((baryPosition.x > static_cast(0)) || (baryPosition.x < det)) return false; // prepare to test V parameter Perpendicular = glm::cross(dist, edge1); // calculate V parameter and test bounds baryPosition.y = glm::dot(dir, Perpendicular); if((baryPosition.y > static_cast(0)) || (baryPosition.x + baryPosition.y < det)) return false; } else return false; // ray is parallel to the plane of the triangle T inv_det = static_cast(1) / det; // calculate distance, ray intersects triangle distance = glm::dot(edge2, Perpendicular) * inv_det; baryPosition *= inv_det; return true; } template GLM_FUNC_QUALIFIER bool intersectLineTriangle ( genType const& orig, genType const& dir, genType const& vert0, genType const& vert1, genType const& vert2, genType & position ) { typename genType::value_type Epsilon = std::numeric_limits::epsilon(); genType edge1 = vert1 - vert0; genType edge2 = vert2 - vert0; genType Perpendicular = cross(dir, edge2); float det = dot(edge1, Perpendicular); if (det > -Epsilon && det < Epsilon) return false; typename genType::value_type inv_det = typename genType::value_type(1) / det; genType Tengant = orig - vert0; position.y = dot(Tengant, Perpendicular) * inv_det; if (position.y < typename genType::value_type(0) || position.y > typename genType::value_type(1)) return false; genType Cotengant = cross(Tengant, edge1); position.z = dot(dir, Cotengant) * inv_det; if (position.z < typename genType::value_type(0) || position.y + position.z > typename genType::value_type(1)) return false; position.x = dot(edge2, Cotengant) * inv_det; return true; } template GLM_FUNC_QUALIFIER bool intersectRaySphere ( genType const& rayStarting, genType const& rayNormalizedDirection, genType const& sphereCenter, const typename genType::value_type sphereRadiusSquered, typename genType::value_type & intersectionDistance ) { typename genType::value_type Epsilon = std::numeric_limits::epsilon(); genType diff = sphereCenter - rayStarting; typename genType::value_type t0 = dot(diff, rayNormalizedDirection); typename genType::value_type dSquared = dot(diff, diff) - t0 * t0; if( dSquared > sphereRadiusSquered ) { return false; } typename genType::value_type t1 = sqrt( sphereRadiusSquered - dSquared ); intersectionDistance = t0 > t1 + Epsilon ? t0 - t1 : t0 + t1; return intersectionDistance > Epsilon; } template GLM_FUNC_QUALIFIER bool intersectRaySphere ( genType const& rayStarting, genType const& rayNormalizedDirection, genType const& sphereCenter, const typename genType::value_type sphereRadius, genType & intersectionPosition, genType & intersectionNormal ) { typename genType::value_type distance; if( intersectRaySphere( rayStarting, rayNormalizedDirection, sphereCenter, sphereRadius * sphereRadius, distance ) ) { intersectionPosition = rayStarting + rayNormalizedDirection * distance; intersectionNormal = (intersectionPosition - sphereCenter) / sphereRadius; return true; } return false; } template GLM_FUNC_QUALIFIER bool intersectLineSphere ( genType const& point0, genType const& point1, genType const& sphereCenter, typename genType::value_type sphereRadius, genType & intersectionPoint1, genType & intersectionNormal1, genType & intersectionPoint2, genType & intersectionNormal2 ) { typename genType::value_type Epsilon = std::numeric_limits::epsilon(); genType dir = normalize(point1 - point0); genType diff = sphereCenter - point0; typename genType::value_type t0 = dot(diff, dir); typename genType::value_type dSquared = dot(diff, diff) - t0 * t0; if( dSquared > sphereRadius * sphereRadius ) { return false; } typename genType::value_type t1 = sqrt( sphereRadius * sphereRadius - dSquared ); if( t0 < t1 + Epsilon ) t1 = -t1; intersectionPoint1 = point0 + dir * (t0 - t1); intersectionNormal1 = (intersectionPoint1 - sphereCenter) / sphereRadius; intersectionPoint2 = point0 + dir * (t0 + t1); intersectionNormal2 = (intersectionPoint2 - sphereCenter) / sphereRadius; return true; } }//namespace glm ================================================ FILE: android/src/glm/gtx/io.hpp ================================================ /// @ref gtx_io /// @file glm/gtx/io.hpp /// @author Jan P Springer (regnirpsj@gmail.com) /// /// @see core (dependence) /// @see gtc_matrix_access (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_io GLM_GTX_io /// @ingroup gtx /// /// Include to use the features of this extension. /// /// std::[w]ostream support for glm types /// /// std::[w]ostream support for glm types + qualifier/width/etc. manipulators /// based on howard hinnant's std::chrono io proposal /// [http://home.roadrunner.com/~hinnant/bloomington/chrono_io.html] #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/quaternion.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_io is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_io extension included") # endif #endif #include // std::basic_ostream<> (fwd) #include // std::locale, std::locale::facet, std::locale::id #include // std::pair<> namespace glm { /// @addtogroup gtx_io /// @{ namespace io { enum order_type { column_major, row_major}; template class format_punct : public std::locale::facet { typedef CTy char_type; public: static std::locale::id id; bool formatted; unsigned precision; unsigned width; char_type separator; char_type delim_left; char_type delim_right; char_type space; char_type newline; order_type order; GLM_FUNC_DECL explicit format_punct(size_t a = 0); GLM_FUNC_DECL explicit format_punct(format_punct const&); }; template > class basic_state_saver { public: GLM_FUNC_DECL explicit basic_state_saver(std::basic_ios&); GLM_FUNC_DECL ~basic_state_saver(); private: typedef ::std::basic_ios state_type; typedef typename state_type::char_type char_type; typedef ::std::ios_base::fmtflags flags_type; typedef ::std::streamsize streamsize_type; typedef ::std::locale const locale_type; state_type& state_; flags_type flags_; streamsize_type precision_; streamsize_type width_; char_type fill_; locale_type locale_; GLM_FUNC_DECL basic_state_saver& operator=(basic_state_saver const&); }; typedef basic_state_saver state_saver; typedef basic_state_saver wstate_saver; template > class basic_format_saver { public: GLM_FUNC_DECL explicit basic_format_saver(std::basic_ios&); GLM_FUNC_DECL ~basic_format_saver(); private: basic_state_saver const bss_; GLM_FUNC_DECL basic_format_saver& operator=(basic_format_saver const&); }; typedef basic_format_saver format_saver; typedef basic_format_saver wformat_saver; struct precision { unsigned value; GLM_FUNC_DECL explicit precision(unsigned); }; struct width { unsigned value; GLM_FUNC_DECL explicit width(unsigned); }; template struct delimeter { CTy value[3]; GLM_FUNC_DECL explicit delimeter(CTy /* left */, CTy /* right */, CTy /* separator */ = ','); }; struct order { order_type value; GLM_FUNC_DECL explicit order(order_type); }; // functions, inlined (inline) template FTy const& get_facet(std::basic_ios&); template std::basic_ios& formatted(std::basic_ios&); template std::basic_ios& unformattet(std::basic_ios&); template std::basic_ostream& operator<<(std::basic_ostream&, precision const&); template std::basic_ostream& operator<<(std::basic_ostream&, width const&); template std::basic_ostream& operator<<(std::basic_ostream&, delimeter const&); template std::basic_ostream& operator<<(std::basic_ostream&, order const&); }//namespace io template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, qua const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<1, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<2, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<3, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<4, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<2, 2, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<2, 3, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<2, 4, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<3, 2, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<3, 3, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<3, 4, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<4, 2, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<4, 3, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<4, 4, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream & operator<<(std::basic_ostream &, std::pair const, mat<4, 4, T, Q> const> const&); /// @} }//namespace glm #include "io.inl" ================================================ FILE: android/src/glm/gtx/io.inl ================================================ /// @ref gtx_io /// @author Jan P Springer (regnirpsj@gmail.com) #include // std::fixed, std::setfill<>, std::setprecision, std::right, std::setw #include // std::basic_ostream<> #include "../gtc/matrix_access.hpp" // glm::col, glm::row #include "../gtx/type_trait.hpp" // glm::type<> namespace glm{ namespace io { template GLM_FUNC_QUALIFIER format_punct::format_punct(size_t a) : std::locale::facet(a) , formatted(true) , precision(3) , width(1 + 4 + 1 + precision) , separator(',') , delim_left('[') , delim_right(']') , space(' ') , newline('\n') , order(column_major) {} template GLM_FUNC_QUALIFIER format_punct::format_punct(format_punct const& a) : std::locale::facet(0) , formatted(a.formatted) , precision(a.precision) , width(a.width) , separator(a.separator) , delim_left(a.delim_left) , delim_right(a.delim_right) , space(a.space) , newline(a.newline) , order(a.order) {} template std::locale::id format_punct::id; template GLM_FUNC_QUALIFIER basic_state_saver::basic_state_saver(std::basic_ios& a) : state_(a) , flags_(a.flags()) , precision_(a.precision()) , width_(a.width()) , fill_(a.fill()) , locale_(a.getloc()) {} template GLM_FUNC_QUALIFIER basic_state_saver::~basic_state_saver() { state_.imbue(locale_); state_.fill(fill_); state_.width(width_); state_.precision(precision_); state_.flags(flags_); } template GLM_FUNC_QUALIFIER basic_format_saver::basic_format_saver(std::basic_ios& a) : bss_(a) { a.imbue(std::locale(a.getloc(), new format_punct(get_facet >(a)))); } template GLM_FUNC_QUALIFIER basic_format_saver::~basic_format_saver() {} GLM_FUNC_QUALIFIER precision::precision(unsigned a) : value(a) {} GLM_FUNC_QUALIFIER width::width(unsigned a) : value(a) {} template GLM_FUNC_QUALIFIER delimeter::delimeter(CTy a, CTy b, CTy c) : value() { value[0] = a; value[1] = b; value[2] = c; } GLM_FUNC_QUALIFIER order::order(order_type a) : value(a) {} template GLM_FUNC_QUALIFIER FTy const& get_facet(std::basic_ios& ios) { if(!std::has_facet(ios.getloc())) ios.imbue(std::locale(ios.getloc(), new FTy)); return std::use_facet(ios.getloc()); } template GLM_FUNC_QUALIFIER std::basic_ios& formatted(std::basic_ios& ios) { const_cast&>(get_facet >(ios)).formatted = true; return ios; } template GLM_FUNC_QUALIFIER std::basic_ios& unformatted(std::basic_ios& ios) { const_cast&>(get_facet >(ios)).formatted = false; return ios; } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, precision const& a) { const_cast&>(get_facet >(os)).precision = a.value; return os; } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, width const& a) { const_cast&>(get_facet >(os)).width = a.value; return os; } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, delimeter const& a) { format_punct & fmt(const_cast&>(get_facet >(os))); fmt.delim_left = a.value[0]; fmt.delim_right = a.value[1]; fmt.separator = a.value[2]; return os; } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, order const& a) { const_cast&>(get_facet >(os)).order = a.value; return os; } } // namespace io namespace detail { template GLM_FUNC_QUALIFIER std::basic_ostream& print_vector_on(std::basic_ostream& os, V const& a) { typename std::basic_ostream::sentry const cerberus(os); if(cerberus) { io::format_punct const& fmt(io::get_facet >(os)); length_t const& components(type::components); if(fmt.formatted) { io::basic_state_saver const bss(os); os << std::fixed << std::right << std::setprecision(fmt.precision) << std::setfill(fmt.space) << fmt.delim_left; for(length_t i(0); i < components; ++i) { os << std::setw(fmt.width) << a[i]; if(components-1 != i) os << fmt.separator; } os << fmt.delim_right; } else { for(length_t i(0); i < components; ++i) { os << a[i]; if(components-1 != i) os << fmt.space; } } } return os; } }//namespace detail template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, qua const& a) { return detail::print_vector_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<1, T, Q> const& a) { return detail::print_vector_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<2, T, Q> const& a) { return detail::print_vector_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<3, T, Q> const& a) { return detail::print_vector_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<4, T, Q> const& a) { return detail::print_vector_on(os, a); } namespace detail { template class M, length_t C, length_t R, typename T, qualifier Q> GLM_FUNC_QUALIFIER std::basic_ostream& print_matrix_on(std::basic_ostream& os, M const& a) { typename std::basic_ostream::sentry const cerberus(os); if(cerberus) { io::format_punct const& fmt(io::get_facet >(os)); length_t const& cols(type >::cols); length_t const& rows(type >::rows); if(fmt.formatted) { os << fmt.newline << fmt.delim_left; switch(fmt.order) { case io::column_major: { for(length_t i(0); i < rows; ++i) { if (0 != i) os << fmt.space; os << row(a, i); if(rows-1 != i) os << fmt.newline; } } break; case io::row_major: { for(length_t i(0); i < cols; ++i) { if(0 != i) os << fmt.space; os << column(a, i); if(cols-1 != i) os << fmt.newline; } } break; } os << fmt.delim_right; } else { switch (fmt.order) { case io::column_major: { for(length_t i(0); i < cols; ++i) { os << column(a, i); if(cols - 1 != i) os << fmt.space; } } break; case io::row_major: { for (length_t i(0); i < rows; ++i) { os << row(a, i); if (rows-1 != i) os << fmt.space; } } break; } } } return os; } }//namespace detail template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<2, 2, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<2, 3, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<2, 4, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<3, 2, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<3, 3, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<3, 4, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<4, 2, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<4, 3, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<4, 4, T, Q> const& a) { return detail::print_matrix_on(os, a); } namespace detail { template class M, length_t C, length_t R, typename T, qualifier Q> GLM_FUNC_QUALIFIER std::basic_ostream& print_matrix_pair_on(std::basic_ostream& os, std::pair const, M const> const& a) { typename std::basic_ostream::sentry const cerberus(os); if(cerberus) { io::format_punct const& fmt(io::get_facet >(os)); M const& ml(a.first); M const& mr(a.second); length_t const& cols(type >::cols); length_t const& rows(type >::rows); if(fmt.formatted) { os << fmt.newline << fmt.delim_left; switch(fmt.order) { case io::column_major: { for(length_t i(0); i < rows; ++i) { if(0 != i) os << fmt.space; os << row(ml, i) << ((rows-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << row(mr, i); if(rows-1 != i) os << fmt.newline; } } break; case io::row_major: { for(length_t i(0); i < cols; ++i) { if(0 != i) os << fmt.space; os << column(ml, i) << ((cols-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << column(mr, i); if(cols-1 != i) os << fmt.newline; } } break; } os << fmt.delim_right; } else { os << ml << fmt.space << mr; } } return os; } }//namespace detail template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<( std::basic_ostream & os, std::pair const, mat<4, 4, T, Q> const> const& a) { return detail::print_matrix_pair_on(os, a); } }//namespace glm ================================================ FILE: android/src/glm/gtx/log_base.hpp ================================================ /// @ref gtx_log_base /// @file glm/gtx/log_base.hpp /// /// @see core (dependence) /// /// @defgroup gtx_log_base GLM_GTX_log_base /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Logarithm for any base. base can be a vector or a scalar. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_log_base is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_log_base extension included") # endif #endif namespace glm { /// @addtogroup gtx_log_base /// @{ /// Logarithm for any base. /// From GLM_GTX_log_base. template GLM_FUNC_DECL genType log( genType const& x, genType const& base); /// Logarithm for any base. /// From GLM_GTX_log_base. template GLM_FUNC_DECL vec sign( vec const& x, vec const& base); /// @} }//namespace glm #include "log_base.inl" ================================================ FILE: android/src/glm/gtx/log_base.inl ================================================ /// @ref gtx_log_base namespace glm { template GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base) { return glm::log(x) / glm::log(base); } template GLM_FUNC_QUALIFIER vec log(vec const& x, vec const& base) { return glm::log(x) / glm::log(base); } }//namespace glm ================================================ FILE: android/src/glm/gtx/matrix_cross_product.hpp ================================================ /// @ref gtx_matrix_cross_product /// @file glm/gtx/matrix_cross_product.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Build cross product matrices #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_matrix_cross_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_matrix_cross_product extension included") # endif #endif namespace glm { /// @addtogroup gtx_matrix_cross_product /// @{ //! Build a cross product matrix. //! From GLM_GTX_matrix_cross_product extension. template GLM_FUNC_DECL mat<3, 3, T, Q> matrixCross3( vec<3, T, Q> const& x); //! Build a cross product matrix. //! From GLM_GTX_matrix_cross_product extension. template GLM_FUNC_DECL mat<4, 4, T, Q> matrixCross4( vec<3, T, Q> const& x); /// @} }//namespace glm #include "matrix_cross_product.inl" ================================================ FILE: android/src/glm/gtx/matrix_cross_product.inl ================================================ /// @ref gtx_matrix_cross_product namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> matrixCross3 ( vec<3, T, Q> const& x ) { mat<3, 3, T, Q> Result(T(0)); Result[0][1] = x.z; Result[1][0] = -x.z; Result[0][2] = -x.y; Result[2][0] = x.y; Result[1][2] = x.x; Result[2][1] = -x.x; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> matrixCross4 ( vec<3, T, Q> const& x ) { mat<4, 4, T, Q> Result(T(0)); Result[0][1] = x.z; Result[1][0] = -x.z; Result[0][2] = -x.y; Result[2][0] = x.y; Result[1][2] = x.x; Result[2][1] = -x.x; return Result; } }//namespace glm ================================================ FILE: android/src/glm/gtx/matrix_decompose.hpp ================================================ /// @ref gtx_matrix_decompose /// @file glm/gtx/matrix_decompose.hpp /// /// @see core (dependence) /// /// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Decomposes a model matrix to translations, rotation and scale components #pragma once // Dependencies #include "../mat4x4.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../geometric.hpp" #include "../gtc/quaternion.hpp" #include "../gtc/matrix_transform.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_matrix_decompose is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_matrix_decompose extension included") # endif #endif namespace glm { /// @addtogroup gtx_matrix_decompose /// @{ /// Decomposes a model matrix to translations, rotation and scale components /// @see gtx_matrix_decompose template GLM_FUNC_DECL bool decompose( mat<4, 4, T, Q> const& modelMatrix, vec<3, T, Q> & scale, qua & orientation, vec<3, T, Q> & translation, vec<3, T, Q> & skew, vec<4, T, Q> & perspective); /// @} }//namespace glm #include "matrix_decompose.inl" ================================================ FILE: android/src/glm/gtx/matrix_decompose.inl ================================================ /// @ref gtx_matrix_decompose #include "../gtc/constants.hpp" #include "../gtc/epsilon.hpp" namespace glm{ namespace detail { /// Make a linear combination of two vectors and return the result. // result = (a * ascl) + (b * bscl) template GLM_FUNC_QUALIFIER vec<3, T, Q> combine( vec<3, T, Q> const& a, vec<3, T, Q> const& b, T ascl, T bscl) { return (a * ascl) + (b * bscl); } template GLM_FUNC_QUALIFIER vec<3, T, Q> scale(vec<3, T, Q> const& v, T desiredLength) { return v * desiredLength / length(v); } }//namespace detail // Matrix decompose // http://www.opensource.apple.com/source/WebCore/WebCore-514/platform/graphics/transforms/TransformationMatrix.cpp // Decomposes the mode matrix to translations,rotation scale components template GLM_FUNC_QUALIFIER bool decompose(mat<4, 4, T, Q> const& ModelMatrix, vec<3, T, Q> & Scale, qua & Orientation, vec<3, T, Q> & Translation, vec<3, T, Q> & Skew, vec<4, T, Q> & Perspective) { mat<4, 4, T, Q> LocalMatrix(ModelMatrix); // Normalize the matrix. if(epsilonEqual(LocalMatrix[3][3], static_cast(0), epsilon())) return false; for(length_t i = 0; i < 4; ++i) for(length_t j = 0; j < 4; ++j) LocalMatrix[i][j] /= LocalMatrix[3][3]; // perspectiveMatrix is used to solve for perspective, but it also provides // an easy way to test for singularity of the upper 3x3 component. mat<4, 4, T, Q> PerspectiveMatrix(LocalMatrix); for(length_t i = 0; i < 3; i++) PerspectiveMatrix[i][3] = static_cast(0); PerspectiveMatrix[3][3] = static_cast(1); /// TODO: Fixme! if(epsilonEqual(determinant(PerspectiveMatrix), static_cast(0), epsilon())) return false; // First, isolate perspective. This is the messiest. if( epsilonNotEqual(LocalMatrix[0][3], static_cast(0), epsilon()) || epsilonNotEqual(LocalMatrix[1][3], static_cast(0), epsilon()) || epsilonNotEqual(LocalMatrix[2][3], static_cast(0), epsilon())) { // rightHandSide is the right hand side of the equation. vec<4, T, Q> RightHandSide; RightHandSide[0] = LocalMatrix[0][3]; RightHandSide[1] = LocalMatrix[1][3]; RightHandSide[2] = LocalMatrix[2][3]; RightHandSide[3] = LocalMatrix[3][3]; // Solve the equation by inverting PerspectiveMatrix and multiplying // rightHandSide by the inverse. (This is the easiest way, not // necessarily the best.) mat<4, 4, T, Q> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);// inverse(PerspectiveMatrix, inversePerspectiveMatrix); mat<4, 4, T, Q> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);// transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix); Perspective = TransposedInversePerspectiveMatrix * RightHandSide; // v4MulPointByMatrix(rightHandSide, transposedInversePerspectiveMatrix, perspectivePoint); // Clear the perspective partition LocalMatrix[0][3] = LocalMatrix[1][3] = LocalMatrix[2][3] = static_cast(0); LocalMatrix[3][3] = static_cast(1); } else { // No perspective. Perspective = vec<4, T, Q>(0, 0, 0, 1); } // Next take care of translation (easy). Translation = vec<3, T, Q>(LocalMatrix[3]); LocalMatrix[3] = vec<4, T, Q>(0, 0, 0, LocalMatrix[3].w); vec<3, T, Q> Row[3], Pdum3; // Now get scale and shear. for(length_t i = 0; i < 3; ++i) for(length_t j = 0; j < 3; ++j) Row[i][j] = LocalMatrix[i][j]; // Compute X scale factor and normalize first row. Scale.x = length(Row[0]);// v3Length(Row[0]); Row[0] = detail::scale(Row[0], static_cast(1)); // Compute XY shear factor and make 2nd row orthogonal to 1st. Skew.z = dot(Row[0], Row[1]); Row[1] = detail::combine(Row[1], Row[0], static_cast(1), -Skew.z); // Now, compute Y scale and normalize 2nd row. Scale.y = length(Row[1]); Row[1] = detail::scale(Row[1], static_cast(1)); Skew.z /= Scale.y; // Compute XZ and YZ shears, orthogonalize 3rd row. Skew.y = glm::dot(Row[0], Row[2]); Row[2] = detail::combine(Row[2], Row[0], static_cast(1), -Skew.y); Skew.x = glm::dot(Row[1], Row[2]); Row[2] = detail::combine(Row[2], Row[1], static_cast(1), -Skew.x); // Next, get Z scale and normalize 3rd row. Scale.z = length(Row[2]); Row[2] = detail::scale(Row[2], static_cast(1)); Skew.y /= Scale.z; Skew.x /= Scale.z; // At this point, the matrix (in rows[]) is orthonormal. // Check for a coordinate system flip. If the determinant // is -1, then negate the matrix and the scaling factors. Pdum3 = cross(Row[1], Row[2]); // v3Cross(row[1], row[2], Pdum3); if(dot(Row[0], Pdum3) < 0) { for(length_t i = 0; i < 3; i++) { Scale[i] *= static_cast(-1); Row[i] *= static_cast(-1); } } // Now, get the rotations out, as described in the gem. // FIXME - Add the ability to return either quaternions (which are // easier to recompose with) or Euler angles (rx, ry, rz), which // are easier for authors to deal with. The latter will only be useful // when we fix https://bugs.webkit.org/show_bug.cgi?id=23799, so I // will leave the Euler angle code here for now. // ret.rotateY = asin(-Row[0][2]); // if (cos(ret.rotateY) != 0) { // ret.rotateX = atan2(Row[1][2], Row[2][2]); // ret.rotateZ = atan2(Row[0][1], Row[0][0]); // } else { // ret.rotateX = atan2(-Row[2][0], Row[1][1]); // ret.rotateZ = 0; // } int i, j, k = 0; T root, trace = Row[0].x + Row[1].y + Row[2].z; if(trace > static_cast(0)) { root = sqrt(trace + static_cast(1.0)); Orientation.w = static_cast(0.5) * root; root = static_cast(0.5) / root; Orientation.x = root * (Row[1].z - Row[2].y); Orientation.y = root * (Row[2].x - Row[0].z); Orientation.z = root * (Row[0].y - Row[1].x); } // End if > 0 else { static int Next[3] = {1, 2, 0}; i = 0; if(Row[1].y > Row[0].x) i = 1; if(Row[2].z > Row[i][i]) i = 2; j = Next[i]; k = Next[j]; root = sqrt(Row[i][i] - Row[j][j] - Row[k][k] + static_cast(1.0)); Orientation[i] = static_cast(0.5) * root; root = static_cast(0.5) / root; Orientation[j] = root * (Row[i][j] + Row[j][i]); Orientation[k] = root * (Row[i][k] + Row[k][i]); Orientation.w = root * (Row[j][k] - Row[k][j]); } // End if <= 0 return true; } }//namespace glm ================================================ FILE: android/src/glm/gtx/matrix_factorisation.hpp ================================================ /// @ref gtx_matrix_factorisation /// @file glm/gtx/matrix_factorisation.hpp /// /// @see core (dependence) /// /// @defgroup gtx_matrix_factorisation GLM_GTX_matrix_factorisation /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Functions to factor matrices in various forms #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_matrix_factorisation is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_matrix_factorisation extension included") # endif #endif /* Suggestions: - Move helper functions flipud and fliplr to another file: They may be helpful in more general circumstances. - Implement other types of matrix factorisation, such as: QL and LQ, L(D)U, eigendecompositions, etc... */ namespace glm { /// @addtogroup gtx_matrix_factorisation /// @{ /// Flips the matrix rows up and down. /// /// From GLM_GTX_matrix_factorisation extension. template GLM_FUNC_DECL mat flipud(mat const& in); /// Flips the matrix columns right and left. /// /// From GLM_GTX_matrix_factorisation extension. template GLM_FUNC_DECL mat fliplr(mat const& in); /// Performs QR factorisation of a matrix. /// Returns 2 matrices, q and r, such that the columns of q are orthonormal and span the same subspace than those of the input matrix, r is an upper triangular matrix, and q*r=in. /// Given an n-by-m input matrix, q has dimensions min(n,m)-by-m, and r has dimensions n-by-min(n,m). /// /// From GLM_GTX_matrix_factorisation extension. template GLM_FUNC_DECL void qr_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& q, mat& r); /// Performs RQ factorisation of a matrix. /// Returns 2 matrices, r and q, such that r is an upper triangular matrix, the rows of q are orthonormal and span the same subspace than those of the input matrix, and r*q=in. /// Note that in the context of RQ factorisation, the diagonal is seen as starting in the lower-right corner of the matrix, instead of the usual upper-left. /// Given an n-by-m input matrix, r has dimensions min(n,m)-by-m, and q has dimensions n-by-min(n,m). /// /// From GLM_GTX_matrix_factorisation extension. template GLM_FUNC_DECL void rq_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& r, mat& q); /// @} } #include "matrix_factorisation.inl" ================================================ FILE: android/src/glm/gtx/matrix_factorisation.inl ================================================ /// @ref gtx_matrix_factorisation namespace glm { template GLM_FUNC_QUALIFIER mat flipud(mat const& in) { mat tin = transpose(in); tin = fliplr(tin); mat out = transpose(tin); return out; } template GLM_FUNC_QUALIFIER mat fliplr(mat const& in) { mat out; for (length_t i = 0; i < C; i++) { out[i] = in[(C - i) - 1]; } return out; } template GLM_FUNC_QUALIFIER void qr_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& q, mat& r) { // Uses modified Gram-Schmidt method // Source: https://en.wikipedia.org/wiki/GramSchmidt_process // And https://en.wikipedia.org/wiki/QR_decomposition //For all the linearly independs columns of the input... // (there can be no more linearly independents columns than there are rows.) for (length_t i = 0; i < (C < R ? C : R); i++) { //Copy in Q the input's i-th column. q[i] = in[i]; //j = [0,i[ // Make that column orthogonal to all the previous ones by substracting to it the non-orthogonal projection of all the previous columns. // Also: Fill the zero elements of R for (length_t j = 0; j < i; j++) { q[i] -= dot(q[i], q[j])*q[j]; r[j][i] = 0; } //Now, Q i-th column is orthogonal to all the previous columns. Normalize it. q[i] = normalize(q[i]); //j = [i,C[ //Finally, compute the corresponding coefficients of R by computing the projection of the resulting column on the other columns of the input. for (length_t j = i; j < C; j++) { r[j][i] = dot(in[j], q[i]); } } } template GLM_FUNC_QUALIFIER void rq_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& r, mat& q) { // From https://en.wikipedia.org/wiki/QR_decomposition: // The RQ decomposition transforms a matrix A into the product of an upper triangular matrix R (also known as right-triangular) and an orthogonal matrix Q. The only difference from QR decomposition is the order of these matrices. // QR decomposition is GramSchmidt orthogonalization of columns of A, started from the first column. // RQ decomposition is GramSchmidt orthogonalization of rows of A, started from the last row. mat tin = transpose(in); tin = fliplr(tin); mat tr; mat<(C < R ? C : R), C, T, Q> tq; qr_decompose(tin, tq, tr); tr = fliplr(tr); r = transpose(tr); r = fliplr(r); tq = fliplr(tq); q = transpose(tq); } } //namespace glm ================================================ FILE: android/src/glm/gtx/matrix_interpolation.hpp ================================================ /// @ref gtx_matrix_interpolation /// @file glm/gtx/matrix_interpolation.hpp /// @author Ghenadii Ursachi (the.asteroth@gmail.com) /// /// @see core (dependence) /// /// @defgroup gtx_matrix_interpolation GLM_GTX_matrix_interpolation /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Allows to directly interpolate two matrices. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_matrix_interpolation is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_matrix_interpolation extension included") # endif #endif namespace glm { /// @addtogroup gtx_matrix_interpolation /// @{ /// Get the axis and angle of the rotation from a matrix. /// From GLM_GTX_matrix_interpolation extension. template GLM_FUNC_DECL void axisAngle( mat<4, 4, T, Q> const& Mat, vec<3, T, Q> & Axis, T & Angle); /// Build a matrix from axis and angle. /// From GLM_GTX_matrix_interpolation extension. template GLM_FUNC_DECL mat<4, 4, T, Q> axisAngleMatrix( vec<3, T, Q> const& Axis, T const Angle); /// Extracts the rotation part of a matrix. /// From GLM_GTX_matrix_interpolation extension. template GLM_FUNC_DECL mat<4, 4, T, Q> extractMatrixRotation( mat<4, 4, T, Q> const& Mat); /// Build a interpolation of 4 * 4 matrixes. /// From GLM_GTX_matrix_interpolation extension. /// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results. template GLM_FUNC_DECL mat<4, 4, T, Q> interpolate( mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2, T const Delta); /// @} }//namespace glm #include "matrix_interpolation.inl" ================================================ FILE: android/src/glm/gtx/matrix_interpolation.inl ================================================ /// @ref gtx_matrix_interpolation #include "../gtc/constants.hpp" namespace glm { template GLM_FUNC_QUALIFIER void axisAngle(mat<4, 4, T, Q> const& m, vec<3, T, Q> & axis, T& angle) { T epsilon = static_cast(0.01); T epsilon2 = static_cast(0.1); if((abs(m[1][0] - m[0][1]) < epsilon) && (abs(m[2][0] - m[0][2]) < epsilon) && (abs(m[2][1] - m[1][2]) < epsilon)) { if ((abs(m[1][0] + m[0][1]) < epsilon2) && (abs(m[2][0] + m[0][2]) < epsilon2) && (abs(m[2][1] + m[1][2]) < epsilon2) && (abs(m[0][0] + m[1][1] + m[2][2] - static_cast(3.0)) < epsilon2)) { angle = static_cast(0.0); axis.x = static_cast(1.0); axis.y = static_cast(0.0); axis.z = static_cast(0.0); return; } angle = static_cast(3.1415926535897932384626433832795); T xx = (m[0][0] + static_cast(1.0)) * static_cast(0.5); T yy = (m[1][1] + static_cast(1.0)) * static_cast(0.5); T zz = (m[2][2] + static_cast(1.0)) * static_cast(0.5); T xy = (m[1][0] + m[0][1]) * static_cast(0.25); T xz = (m[2][0] + m[0][2]) * static_cast(0.25); T yz = (m[2][1] + m[1][2]) * static_cast(0.25); if((xx > yy) && (xx > zz)) { if(xx < epsilon) { axis.x = static_cast(0.0); axis.y = static_cast(0.7071); axis.z = static_cast(0.7071); } else { axis.x = sqrt(xx); axis.y = xy / axis.x; axis.z = xz / axis.x; } } else if (yy > zz) { if(yy < epsilon) { axis.x = static_cast(0.7071); axis.y = static_cast(0.0); axis.z = static_cast(0.7071); } else { axis.y = sqrt(yy); axis.x = xy / axis.y; axis.z = yz / axis.y; } } else { if (zz < epsilon) { axis.x = static_cast(0.7071); axis.y = static_cast(0.7071); axis.z = static_cast(0.0); } else { axis.z = sqrt(zz); axis.x = xz / axis.z; axis.y = yz / axis.z; } } return; } T s = sqrt((m[2][1] - m[1][2]) * (m[2][1] - m[1][2]) + (m[2][0] - m[0][2]) * (m[2][0] - m[0][2]) + (m[1][0] - m[0][1]) * (m[1][0] - m[0][1])); if (glm::abs(s) < T(0.001)) s = static_cast(1); T const angleCos = (m[0][0] + m[1][1] + m[2][2] - static_cast(1)) * static_cast(0.5); if(angleCos - static_cast(1) < epsilon) angle = pi() * static_cast(0.25); else angle = acos(angleCos); axis.x = (m[1][2] - m[2][1]) / s; axis.y = (m[2][0] - m[0][2]) / s; axis.z = (m[0][1] - m[1][0]) / s; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> axisAngleMatrix(vec<3, T, Q> const& axis, T const angle) { T c = cos(angle); T s = sin(angle); T t = static_cast(1) - c; vec<3, T, Q> n = normalize(axis); return mat<4, 4, T, Q>( t * n.x * n.x + c, t * n.x * n.y + n.z * s, t * n.x * n.z - n.y * s, static_cast(0.0), t * n.x * n.y - n.z * s, t * n.y * n.y + c, t * n.y * n.z + n.x * s, static_cast(0.0), t * n.x * n.z + n.y * s, t * n.y * n.z - n.x * s, t * n.z * n.z + c, static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(1.0)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> extractMatrixRotation(mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( m[0][0], m[0][1], m[0][2], static_cast(0.0), m[1][0], m[1][1], m[1][2], static_cast(0.0), m[2][0], m[2][1], m[2][2], static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(1.0)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> interpolate(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2, T const delta) { mat<4, 4, T, Q> m1rot = extractMatrixRotation(m1); mat<4, 4, T, Q> dltRotation = m2 * transpose(m1rot); vec<3, T, Q> dltAxis; T dltAngle; axisAngle(dltRotation, dltAxis, dltAngle); mat<4, 4, T, Q> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot; out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]); out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]); out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]); return out; } }//namespace glm ================================================ FILE: android/src/glm/gtx/matrix_major_storage.hpp ================================================ /// @ref gtx_matrix_major_storage /// @file glm/gtx/matrix_major_storage.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_matrix_major_storage GLM_GTX_matrix_major_storage /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Build matrices with specific matrix order, row or column #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_matrix_major_storage is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_matrix_major_storage extension included") # endif #endif namespace glm { /// @addtogroup gtx_matrix_major_storage /// @{ //! Build a row major matrix from row vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<2, 2, T, Q> rowMajor2( vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); //! Build a row major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<2, 2, T, Q> rowMajor2( mat<2, 2, T, Q> const& m); //! Build a row major matrix from row vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<3, 3, T, Q> rowMajor3( vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<3, T, Q> const& v3); //! Build a row major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<3, 3, T, Q> rowMajor3( mat<3, 3, T, Q> const& m); //! Build a row major matrix from row vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<4, 4, T, Q> rowMajor4( vec<4, T, Q> const& v1, vec<4, T, Q> const& v2, vec<4, T, Q> const& v3, vec<4, T, Q> const& v4); //! Build a row major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<4, 4, T, Q> rowMajor4( mat<4, 4, T, Q> const& m); //! Build a column major matrix from column vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<2, 2, T, Q> colMajor2( vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); //! Build a column major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<2, 2, T, Q> colMajor2( mat<2, 2, T, Q> const& m); //! Build a column major matrix from column vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<3, 3, T, Q> colMajor3( vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<3, T, Q> const& v3); //! Build a column major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<3, 3, T, Q> colMajor3( mat<3, 3, T, Q> const& m); //! Build a column major matrix from column vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<4, 4, T, Q> colMajor4( vec<4, T, Q> const& v1, vec<4, T, Q> const& v2, vec<4, T, Q> const& v3, vec<4, T, Q> const& v4); //! Build a column major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<4, 4, T, Q> colMajor4( mat<4, 4, T, Q> const& m); /// @} }//namespace glm #include "matrix_major_storage.inl" ================================================ FILE: android/src/glm/gtx/matrix_major_storage.inl ================================================ /// @ref gtx_matrix_major_storage namespace glm { template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> rowMajor2 ( vec<2, T, Q> const& v1, vec<2, T, Q> const& v2 ) { mat<2, 2, T, Q> Result; Result[0][0] = v1.x; Result[1][0] = v1.y; Result[0][1] = v2.x; Result[1][1] = v2.y; return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> rowMajor2( const mat<2, 2, T, Q>& m) { mat<2, 2, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rowMajor3( const vec<3, T, Q>& v1, const vec<3, T, Q>& v2, const vec<3, T, Q>& v3) { mat<3, 3, T, Q> Result; Result[0][0] = v1.x; Result[1][0] = v1.y; Result[2][0] = v1.z; Result[0][1] = v2.x; Result[1][1] = v2.y; Result[2][1] = v2.z; Result[0][2] = v3.x; Result[1][2] = v3.y; Result[2][2] = v3.z; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rowMajor3( const mat<3, 3, T, Q>& m) { mat<3, 3, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rowMajor4( const vec<4, T, Q>& v1, const vec<4, T, Q>& v2, const vec<4, T, Q>& v3, const vec<4, T, Q>& v4) { mat<4, 4, T, Q> Result; Result[0][0] = v1.x; Result[1][0] = v1.y; Result[2][0] = v1.z; Result[3][0] = v1.w; Result[0][1] = v2.x; Result[1][1] = v2.y; Result[2][1] = v2.z; Result[3][1] = v2.w; Result[0][2] = v3.x; Result[1][2] = v3.y; Result[2][2] = v3.z; Result[3][2] = v3.w; Result[0][3] = v4.x; Result[1][3] = v4.y; Result[2][3] = v4.z; Result[3][3] = v4.w; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rowMajor4( const mat<4, 4, T, Q>& m) { mat<4, 4, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[0][3] = m[3][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[1][3] = m[3][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; Result[2][3] = m[3][2]; Result[3][0] = m[0][3]; Result[3][1] = m[1][3]; Result[3][2] = m[2][3]; Result[3][3] = m[3][3]; return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> colMajor2( const vec<2, T, Q>& v1, const vec<2, T, Q>& v2) { return mat<2, 2, T, Q>(v1, v2); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> colMajor2( const mat<2, 2, T, Q>& m) { return mat<2, 2, T, Q>(m); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> colMajor3( const vec<3, T, Q>& v1, const vec<3, T, Q>& v2, const vec<3, T, Q>& v3) { return mat<3, 3, T, Q>(v1, v2, v3); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> colMajor3( const mat<3, 3, T, Q>& m) { return mat<3, 3, T, Q>(m); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> colMajor4( const vec<4, T, Q>& v1, const vec<4, T, Q>& v2, const vec<4, T, Q>& v3, const vec<4, T, Q>& v4) { return mat<4, 4, T, Q>(v1, v2, v3, v4); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> colMajor4( const mat<4, 4, T, Q>& m) { return mat<4, 4, T, Q>(m); } }//namespace glm ================================================ FILE: android/src/glm/gtx/matrix_operation.hpp ================================================ /// @ref gtx_matrix_operation /// @file glm/gtx/matrix_operation.hpp /// /// @see core (dependence) /// /// @defgroup gtx_matrix_operation GLM_GTX_matrix_operation /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Build diagonal matrices from vectors. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_matrix_operation is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_matrix_operation extension included") # endif #endif namespace glm { /// @addtogroup gtx_matrix_operation /// @{ //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<2, 2, T, Q> diagonal2x2( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<2, 3, T, Q> diagonal2x3( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<2, 4, T, Q> diagonal2x4( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<3, 2, T, Q> diagonal3x2( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<3, 3, T, Q> diagonal3x3( vec<3, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<3, 4, T, Q> diagonal3x4( vec<3, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<4, 2, T, Q> diagonal4x2( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<4, 3, T, Q> diagonal4x3( vec<3, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<4, 4, T, Q> diagonal4x4( vec<4, T, Q> const& v); /// Build an adjugate matrix. /// From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<2, 2, T, Q> adjugate(mat<2, 2, T, Q> const& m); /// Build an adjugate matrix. /// From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<3, 3, T, Q> adjugate(mat<3, 3, T, Q> const& m); /// Build an adjugate matrix. /// From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<4, 4, T, Q> adjugate(mat<4, 4, T, Q> const& m); /// @} }//namespace glm #include "matrix_operation.inl" ================================================ FILE: android/src/glm/gtx/matrix_operation.inl ================================================ /// @ref gtx_matrix_operation namespace glm { template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> diagonal2x2 ( vec<2, T, Q> const& v ) { mat<2, 2, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> diagonal2x3 ( vec<2, T, Q> const& v ) { mat<2, 3, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> diagonal2x4 ( vec<2, T, Q> const& v ) { mat<2, 4, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> diagonal3x2 ( vec<2, T, Q> const& v ) { mat<3, 2, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> diagonal3x3 ( vec<3, T, Q> const& v ) { mat<3, 3, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; Result[2][2] = v[2]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> diagonal3x4 ( vec<3, T, Q> const& v ) { mat<3, 4, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; Result[2][2] = v[2]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> diagonal4x4 ( vec<4, T, Q> const& v ) { mat<4, 4, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; Result[2][2] = v[2]; Result[3][3] = v[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> diagonal4x3 ( vec<3, T, Q> const& v ) { mat<4, 3, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; Result[2][2] = v[2]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> diagonal4x2 ( vec<2, T, Q> const& v ) { mat<4, 2, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> adjugate(mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( +m[1][1], -m[1][0], -m[0][1], +m[0][0]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> adjugate(mat<3, 3, T, Q> const& m) { T const m00 = determinant(mat<2, 2, T, Q>(m[1][1], m[2][1], m[1][2], m[2][2])); T const m01 = determinant(mat<2, 2, T, Q>(m[0][1], m[2][1], m[0][2], m[2][2])); T const m02 = determinant(mat<2, 2, T, Q>(m[0][1], m[1][1], m[0][2], m[1][2])); T const m10 = determinant(mat<2, 2, T, Q>(m[1][0], m[2][0], m[1][2], m[2][2])); T const m11 = determinant(mat<2, 2, T, Q>(m[0][0], m[2][0], m[0][2], m[2][2])); T const m12 = determinant(mat<2, 2, T, Q>(m[0][0], m[1][0], m[0][2], m[1][2])); T const m20 = determinant(mat<2, 2, T, Q>(m[1][0], m[2][0], m[1][1], m[2][1])); T const m21 = determinant(mat<2, 2, T, Q>(m[0][0], m[2][0], m[0][1], m[2][1])); T const m22 = determinant(mat<2, 2, T, Q>(m[0][0], m[1][0], m[0][1], m[1][1])); return mat<3, 3, T, Q>( +m00, -m01, +m02, -m10, +m11, -m12, +m20, -m21, +m22); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> adjugate(mat<4, 4, T, Q> const& m) { T const m00 = determinant(mat<3, 3, T, Q>(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3])); T const m01 = determinant(mat<3, 3, T, Q>(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3])); T const m02 = determinant(mat<3, 3, T, Q>(m[1][0], m[1][1], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][1], m[3][3])); T const m03 = determinant(mat<3, 3, T, Q>(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2])); T const m10 = determinant(mat<3, 3, T, Q>(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3])); T const m11 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3])); T const m12 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3])); T const m13 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2])); T const m20 = determinant(mat<3, 3, T, Q>(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3])); T const m21 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3])); T const m22 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3])); T const m23 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2])); T const m30 = determinant(mat<3, 3, T, Q>(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3])); T const m31 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3])); T const m32 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3])); T const m33 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2])); return mat<4, 4, T, Q>( +m00, -m01, +m02, -m03, -m10, +m11, -m12, +m13, +m20, -m21, +m22, -m23, -m30, +m31, -m32, +m33); } }//namespace glm ================================================ FILE: android/src/glm/gtx/matrix_query.hpp ================================================ /// @ref gtx_matrix_query /// @file glm/gtx/matrix_query.hpp /// /// @see core (dependence) /// @see gtx_vector_query (dependence) /// /// @defgroup gtx_matrix_query GLM_GTX_matrix_query /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Query to evaluate matrix properties #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/vector_query.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_matrix_query is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_matrix_query extension included") # endif #endif namespace glm { /// @addtogroup gtx_matrix_query /// @{ /// Return whether a matrix a null matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNull(mat<2, 2, T, Q> const& m, T const& epsilon); /// Return whether a matrix a null matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNull(mat<3, 3, T, Q> const& m, T const& epsilon); /// Return whether a matrix is a null matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNull(mat<4, 4, T, Q> const& m, T const& epsilon); /// Return whether a matrix is an identity matrix. /// From GLM_GTX_matrix_query extension. template class matType> GLM_FUNC_DECL bool isIdentity(matType const& m, T const& epsilon); /// Return whether a matrix is a normalized matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNormalized(mat<2, 2, T, Q> const& m, T const& epsilon); /// Return whether a matrix is a normalized matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNormalized(mat<3, 3, T, Q> const& m, T const& epsilon); /// Return whether a matrix is a normalized matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNormalized(mat<4, 4, T, Q> const& m, T const& epsilon); /// Return whether a matrix is an orthonormalized matrix. /// From GLM_GTX_matrix_query extension. template class matType> GLM_FUNC_DECL bool isOrthogonal(matType const& m, T const& epsilon); /// @} }//namespace glm #include "matrix_query.inl" ================================================ FILE: android/src/glm/gtx/matrix_query.inl ================================================ /// @ref gtx_matrix_query namespace glm { template GLM_FUNC_QUALIFIER bool isNull(mat<2, 2, T, Q> const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m.length() ; ++i) result = isNull(m[i], epsilon); return result; } template GLM_FUNC_QUALIFIER bool isNull(mat<3, 3, T, Q> const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m.length() ; ++i) result = isNull(m[i], epsilon); return result; } template GLM_FUNC_QUALIFIER bool isNull(mat<4, 4, T, Q> const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m.length() ; ++i) result = isNull(m[i], epsilon); return result; } template GLM_FUNC_QUALIFIER bool isIdentity(mat const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m[0].length() ; ++i) { for(length_t j = 0; result && j < i ; ++j) result = abs(m[i][j]) <= epsilon; if(result) result = abs(m[i][i] - 1) <= epsilon; for(length_t j = i + 1; result && j < m.length(); ++j) result = abs(m[i][j]) <= epsilon; } return result; } template GLM_FUNC_QUALIFIER bool isNormalized(mat<2, 2, T, Q> const& m, T const& epsilon) { bool result(true); for(length_t i = 0; result && i < m.length(); ++i) result = isNormalized(m[i], epsilon); for(length_t i = 0; result && i < m.length(); ++i) { typename mat<2, 2, T, Q>::col_type v; for(length_t j = 0; j < m.length(); ++j) v[j] = m[j][i]; result = isNormalized(v, epsilon); } return result; } template GLM_FUNC_QUALIFIER bool isNormalized(mat<3, 3, T, Q> const& m, T const& epsilon) { bool result(true); for(length_t i = 0; result && i < m.length(); ++i) result = isNormalized(m[i], epsilon); for(length_t i = 0; result && i < m.length(); ++i) { typename mat<3, 3, T, Q>::col_type v; for(length_t j = 0; j < m.length(); ++j) v[j] = m[j][i]; result = isNormalized(v, epsilon); } return result; } template GLM_FUNC_QUALIFIER bool isNormalized(mat<4, 4, T, Q> const& m, T const& epsilon) { bool result(true); for(length_t i = 0; result && i < m.length(); ++i) result = isNormalized(m[i], epsilon); for(length_t i = 0; result && i < m.length(); ++i) { typename mat<4, 4, T, Q>::col_type v; for(length_t j = 0; j < m.length(); ++j) v[j] = m[j][i]; result = isNormalized(v, epsilon); } return result; } template GLM_FUNC_QUALIFIER bool isOrthogonal(mat const& m, T const& epsilon) { bool result = true; for(length_t i(0); result && i < m.length() - 1; ++i) for(length_t j(i + 1); result && j < m.length(); ++j) result = areOrthogonal(m[i], m[j], epsilon); if(result) { mat tmp = transpose(m); for(length_t i(0); result && i < m.length() - 1 ; ++i) for(length_t j(i + 1); result && j < m.length(); ++j) result = areOrthogonal(tmp[i], tmp[j], epsilon); } return result; } }//namespace glm ================================================ FILE: android/src/glm/gtx/matrix_transform_2d.hpp ================================================ /// @ref gtx_matrix_transform_2d /// @file glm/gtx/matrix_transform_2d.hpp /// @author Miguel Ángel Pérez Martínez /// /// @see core (dependence) /// /// @defgroup gtx_matrix_transform_2d GLM_GTX_matrix_transform_2d /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines functions that generate common 2d transformation matrices. #pragma once // Dependency: #include "../mat3x3.hpp" #include "../vec2.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_matrix_transform_2d is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_matrix_transform_2d extension included") # endif #endif namespace glm { /// @addtogroup gtx_matrix_transform_2d /// @{ /// Builds a translation 3 * 3 matrix created from a vector of 2 components. /// /// @param m Input matrix multiplied by this translation matrix. /// @param v Coordinates of a translation vector. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate( mat<3, 3, T, Q> const& m, vec<2, T, Q> const& v); /// Builds a rotation 3 * 3 matrix created from an angle. /// /// @param m Input matrix multiplied by this translation matrix. /// @param angle Rotation angle expressed in radians. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate( mat<3, 3, T, Q> const& m, T angle); /// Builds a scale 3 * 3 matrix created from a vector of 2 components. /// /// @param m Input matrix multiplied by this translation matrix. /// @param v Coordinates of a scale vector. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale( mat<3, 3, T, Q> const& m, vec<2, T, Q> const& v); /// Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix. /// /// @param m Input matrix multiplied by this translation matrix. /// @param y Shear factor. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX( mat<3, 3, T, Q> const& m, T y); /// Builds a vertical (parallel to the y axis) shear 3 * 3 matrix. /// /// @param m Input matrix multiplied by this translation matrix. /// @param x Shear factor. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY( mat<3, 3, T, Q> const& m, T x); /// @} }//namespace glm #include "matrix_transform_2d.inl" ================================================ FILE: android/src/glm/gtx/matrix_transform_2d.inl ================================================ /// @ref gtx_matrix_transform_2d /// @author Miguel Ángel Pérez Martínez #include "../trigonometric.hpp" namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate( mat<3, 3, T, Q> const& m, vec<2, T, Q> const& v) { mat<3, 3, T, Q> Result(m); Result[2] = m[0] * v[0] + m[1] * v[1] + m[2]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate( mat<3, 3, T, Q> const& m, T angle) { T const a = angle; T const c = cos(a); T const s = sin(a); mat<3, 3, T, Q> Result; Result[0] = m[0] * c + m[1] * s; Result[1] = m[0] * -s + m[1] * c; Result[2] = m[2]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale( mat<3, 3, T, Q> const& m, vec<2, T, Q> const& v) { mat<3, 3, T, Q> Result; Result[0] = m[0] * v[0]; Result[1] = m[1] * v[1]; Result[2] = m[2]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX( mat<3, 3, T, Q> const& m, T y) { mat<3, 3, T, Q> Result(1); Result[0][1] = y; return m * Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY( mat<3, 3, T, Q> const& m, T x) { mat<3, 3, T, Q> Result(1); Result[1][0] = x; return m * Result; } }//namespace glm ================================================ FILE: android/src/glm/gtx/mixed_product.hpp ================================================ /// @ref gtx_mixed_product /// @file glm/gtx/mixed_product.hpp /// /// @see core (dependence) /// /// @defgroup gtx_mixed_product GLM_GTX_mixed_producte /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Mixed product of 3 vectors. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_mixed_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_mixed_product extension included") # endif #endif namespace glm { /// @addtogroup gtx_mixed_product /// @{ /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) template GLM_FUNC_DECL T mixedProduct( vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<3, T, Q> const& v3); /// @} }// namespace glm #include "mixed_product.inl" ================================================ FILE: android/src/glm/gtx/mixed_product.inl ================================================ /// @ref gtx_mixed_product namespace glm { template GLM_FUNC_QUALIFIER T mixedProduct ( vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<3, T, Q> const& v3 ) { return dot(cross(v1, v2), v3); } }//namespace glm ================================================ FILE: android/src/glm/gtx/norm.hpp ================================================ /// @ref gtx_norm /// @file glm/gtx/norm.hpp /// /// @see core (dependence) /// @see gtx_quaternion (dependence) /// @see gtx_component_wise (dependence) /// /// @defgroup gtx_norm GLM_GTX_norm /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Various ways to compute vector norms. #pragma once // Dependency: #include "../geometric.hpp" #include "../gtx/quaternion.hpp" #include "../gtx/component_wise.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_norm is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_norm extension included") # endif #endif namespace glm { /// @addtogroup gtx_norm /// @{ /// Returns the squared length of x. /// From GLM_GTX_norm extension. template GLM_FUNC_DECL T length2(vec const& x); /// Returns the squared distance between p0 and p1, i.e., length2(p0 - p1). /// From GLM_GTX_norm extension. template GLM_FUNC_DECL T distance2(vec const& p0, vec const& p1); //! Returns the L1 norm between x and y. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T l1Norm(vec<3, T, Q> const& x, vec<3, T, Q> const& y); //! Returns the L1 norm of v. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T l1Norm(vec<3, T, Q> const& v); //! Returns the L2 norm between x and y. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T l2Norm(vec<3, T, Q> const& x, vec<3, T, Q> const& y); //! Returns the L2 norm of v. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T l2Norm(vec<3, T, Q> const& x); //! Returns the L norm between x and y. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T lxNorm(vec<3, T, Q> const& x, vec<3, T, Q> const& y, unsigned int Depth); //! Returns the L norm of v. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T lxNorm(vec<3, T, Q> const& x, unsigned int Depth); //! Returns the LMax norm between x and y. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T lMaxNorm(vec<3, T, Q> const& x, vec<3, T, Q> const& y); //! Returns the LMax norm of v. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T lMaxNorm(vec<3, T, Q> const& x); /// @} }//namespace glm #include "norm.inl" ================================================ FILE: android/src/glm/gtx/norm.inl ================================================ /// @ref gtx_norm #include "../detail/qualifier.hpp" namespace glm{ namespace detail { template struct compute_length2 { GLM_FUNC_QUALIFIER static T call(vec const& v) { return dot(v, v); } }; }//namespace detail template GLM_FUNC_QUALIFIER genType length2(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length2' accepts only floating-point inputs"); return x * x; } template GLM_FUNC_QUALIFIER T length2(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length2' accepts only floating-point inputs"); return detail::compute_length2::value>::call(v); } template GLM_FUNC_QUALIFIER T distance2(T p0, T p1) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance2' accepts only floating-point inputs"); return length2(p1 - p0); } template GLM_FUNC_QUALIFIER T distance2(vec const& p0, vec const& p1) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance2' accepts only floating-point inputs"); return length2(p1 - p0); } template GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, Q> const& a, vec<3, T, Q> const& b) { return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z); } template GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, Q> const& v) { return abs(v.x) + abs(v.y) + abs(v.z); } template GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, Q> const& a, vec<3, T, Q> const& b ) { return length(b - a); } template GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, Q> const& v) { return length(v); } template GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, Q> const& x, vec<3, T, Q> const& y, unsigned int Depth) { return pow(pow(abs(y.x - x.x), T(Depth)) + pow(abs(y.y - x.y), T(Depth)) + pow(abs(y.z - x.z), T(Depth)), T(1) / T(Depth)); } template GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, Q> const& v, unsigned int Depth) { return pow(pow(abs(v.x), T(Depth)) + pow(abs(v.y), T(Depth)) + pow(abs(v.z), T(Depth)), T(1) / T(Depth)); } template GLM_FUNC_QUALIFIER T lMaxNorm(vec<3, T, Q> const& a, vec<3, T, Q> const& b) { return compMax(abs(b - a)); } template GLM_FUNC_QUALIFIER T lMaxNorm(vec<3, T, Q> const& v) { return compMax(abs(v)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/normal.hpp ================================================ /// @ref gtx_normal /// @file glm/gtx/normal.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_normal GLM_GTX_normal /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Compute the normal of a triangle. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_normal is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_normal extension included") # endif #endif namespace glm { /// @addtogroup gtx_normal /// @{ /// Computes triangle normal from triangle points. /// /// @see gtx_normal template GLM_FUNC_DECL vec<3, T, Q> triangleNormal(vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3); /// @} }//namespace glm #include "normal.inl" ================================================ FILE: android/src/glm/gtx/normal.inl ================================================ /// @ref gtx_normal namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> triangleNormal ( vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3 ) { return normalize(cross(p1 - p2, p1 - p3)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/normalize_dot.hpp ================================================ /// @ref gtx_normalize_dot /// @file glm/gtx/normalize_dot.hpp /// /// @see core (dependence) /// @see gtx_fast_square_root (dependence) /// /// @defgroup gtx_normalize_dot GLM_GTX_normalize_dot /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Dot product of vectors that need to be normalize with a single square root. #pragma once // Dependency: #include "../gtx/fast_square_root.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_normalize_dot is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_normalize_dot extension included") # endif #endif namespace glm { /// @addtogroup gtx_normalize_dot /// @{ /// Normalize parameters and returns the dot product of x and y. /// It's faster that dot(normalize(x), normalize(y)). /// /// @see gtx_normalize_dot extension. template GLM_FUNC_DECL T normalizeDot(vec const& x, vec const& y); /// Normalize parameters and returns the dot product of x and y. /// Faster that dot(fastNormalize(x), fastNormalize(y)). /// /// @see gtx_normalize_dot extension. template GLM_FUNC_DECL T fastNormalizeDot(vec const& x, vec const& y); /// @} }//namespace glm #include "normalize_dot.inl" ================================================ FILE: android/src/glm/gtx/normalize_dot.inl ================================================ /// @ref gtx_normalize_dot namespace glm { template GLM_FUNC_QUALIFIER T normalizeDot(vec const& x, vec const& y) { return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); } template GLM_FUNC_QUALIFIER T fastNormalizeDot(vec const& x, vec const& y) { return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/number_precision.hpp ================================================ /// @ref gtx_number_precision /// @file glm/gtx/number_precision.hpp /// /// @see core (dependence) /// @see gtc_type_precision (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_number_precision GLM_GTX_number_precision /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defined size types. #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/type_precision.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_number_precision is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_number_precision extension included") # endif #endif namespace glm{ namespace gtx { ///////////////////////////// // Unsigned int vector types /// @addtogroup gtx_number_precision /// @{ typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension) typedef u16 u16vec1; //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension) typedef u32 u32vec1; //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension) typedef u64 u64vec1; //!< \brief 64bit unsigned integer scalar. (from GLM_GTX_number_precision extension) ////////////////////// // Float vector types typedef f32 f32vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) typedef f64 f64vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) ////////////////////// // Float matrix types typedef f32 f32mat1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) typedef f32 f32mat1x1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) typedef f64 f64mat1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) typedef f64 f64mat1x1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) /// @} }//namespace gtx }//namespace glm #include "number_precision.inl" ================================================ FILE: android/src/glm/gtx/number_precision.inl ================================================ /// @ref gtx_number_precision namespace glm { } ================================================ FILE: android/src/glm/gtx/optimum_pow.hpp ================================================ /// @ref gtx_optimum_pow /// @file glm/gtx/optimum_pow.hpp /// /// @see core (dependence) /// /// @defgroup gtx_optimum_pow GLM_GTX_optimum_pow /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Integer exponentiation of power functions. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_optimum_pow is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_optimum_pow extension included") # endif #endif namespace glm{ namespace gtx { /// @addtogroup gtx_optimum_pow /// @{ /// Returns x raised to the power of 2. /// /// @see gtx_optimum_pow template GLM_FUNC_DECL genType pow2(genType const& x); /// Returns x raised to the power of 3. /// /// @see gtx_optimum_pow template GLM_FUNC_DECL genType pow3(genType const& x); /// Returns x raised to the power of 4. /// /// @see gtx_optimum_pow template GLM_FUNC_DECL genType pow4(genType const& x); /// @} }//namespace gtx }//namespace glm #include "optimum_pow.inl" ================================================ FILE: android/src/glm/gtx/optimum_pow.inl ================================================ /// @ref gtx_optimum_pow namespace glm { template GLM_FUNC_QUALIFIER genType pow2(genType const& x) { return x * x; } template GLM_FUNC_QUALIFIER genType pow3(genType const& x) { return x * x * x; } template GLM_FUNC_QUALIFIER genType pow4(genType const& x) { return (x * x) * (x * x); } }//namespace glm ================================================ FILE: android/src/glm/gtx/orthonormalize.hpp ================================================ /// @ref gtx_orthonormalize /// @file glm/gtx/orthonormalize.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_orthonormalize GLM_GTX_orthonormalize /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Orthonormalize matrices. #pragma once // Dependency: #include "../vec3.hpp" #include "../mat3x3.hpp" #include "../geometric.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_orthonormalize is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_orthonormalize extension included") # endif #endif namespace glm { /// @addtogroup gtx_orthonormalize /// @{ /// Returns the orthonormalized matrix of m. /// /// @see gtx_orthonormalize template GLM_FUNC_DECL mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m); /// Orthonormalizes x according y. /// /// @see gtx_orthonormalize template GLM_FUNC_DECL vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y); /// @} }//namespace glm #include "orthonormalize.inl" ================================================ FILE: android/src/glm/gtx/orthonormalize.inl ================================================ /// @ref gtx_orthonormalize namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m) { mat<3, 3, T, Q> r = m; r[0] = normalize(r[0]); T d0 = dot(r[0], r[1]); r[1] -= r[0] * d0; r[1] = normalize(r[1]); T d1 = dot(r[1], r[2]); d0 = dot(r[0], r[2]); r[2] -= r[0] * d0 + r[1] * d1; r[2] = normalize(r[2]); return r; } template GLM_FUNC_QUALIFIER vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y) { return normalize(x - y * dot(y, x)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/perpendicular.hpp ================================================ /// @ref gtx_perpendicular /// @file glm/gtx/perpendicular.hpp /// /// @see core (dependence) /// @see gtx_projection (dependence) /// /// @defgroup gtx_perpendicular GLM_GTX_perpendicular /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Perpendicular of a vector from other one #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/projection.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_perpendicular is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_perpendicular extension included") # endif #endif namespace glm { /// @addtogroup gtx_perpendicular /// @{ //! Projects x a perpendicular axis of Normal. //! From GLM_GTX_perpendicular extension. template GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal); /// @} }//namespace glm #include "perpendicular.inl" ================================================ FILE: android/src/glm/gtx/perpendicular.inl ================================================ /// @ref gtx_perpendicular namespace glm { template GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal) { return x - proj(x, Normal); } }//namespace glm ================================================ FILE: android/src/glm/gtx/polar_coordinates.hpp ================================================ /// @ref gtx_polar_coordinates /// @file glm/gtx/polar_coordinates.hpp /// /// @see core (dependence) /// /// @defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Conversion from Euclidean space to polar space and revert. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_polar_coordinates is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_polar_coordinates extension included") # endif #endif namespace glm { /// @addtogroup gtx_polar_coordinates /// @{ /// Convert Euclidean to Polar coordinates, x is the latitude, y the longitude and z the xz distance. /// /// @see gtx_polar_coordinates template GLM_FUNC_DECL vec<3, T, Q> polar( vec<3, T, Q> const& euclidean); /// Convert Polar to Euclidean coordinates. /// /// @see gtx_polar_coordinates template GLM_FUNC_DECL vec<3, T, Q> euclidean( vec<2, T, Q> const& polar); /// @} }//namespace glm #include "polar_coordinates.inl" ================================================ FILE: android/src/glm/gtx/polar_coordinates.inl ================================================ /// @ref gtx_polar_coordinates namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> polar ( vec<3, T, Q> const& euclidean ) { T const Length(length(euclidean)); vec<3, T, Q> const tmp(euclidean / Length); T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z)); return vec<3, T, Q>( asin(tmp.y), // latitude atan(tmp.x, tmp.z), // longitude xz_dist); // xz distance } template GLM_FUNC_QUALIFIER vec<3, T, Q> euclidean ( vec<2, T, Q> const& polar ) { T const latitude(polar.x); T const longitude(polar.y); return vec<3, T, Q>( cos(latitude) * sin(longitude), sin(latitude), cos(latitude) * cos(longitude)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/projection.hpp ================================================ /// @ref gtx_projection /// @file glm/gtx/projection.hpp /// /// @see core (dependence) /// /// @defgroup gtx_projection GLM_GTX_projection /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Projection of a vector to other one #pragma once // Dependency: #include "../geometric.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_projection is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_projection extension included") # endif #endif namespace glm { /// @addtogroup gtx_projection /// @{ /// Projects x on Normal. /// /// @param[in] x A vector to project /// @param[in] Normal A normal that doesn't need to be of unit length. /// /// @see gtx_projection template GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); /// @} }//namespace glm #include "projection.inl" ================================================ FILE: android/src/glm/gtx/projection.inl ================================================ /// @ref gtx_projection namespace glm { template GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal) { return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; } }//namespace glm ================================================ FILE: android/src/glm/gtx/quaternion.hpp ================================================ /// @ref gtx_quaternion /// @file glm/gtx/quaternion.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_quaternion GLM_GTX_quaternion /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Extented quaternion types and functions #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/constants.hpp" #include "../gtc/quaternion.hpp" #include "../ext/quaternion_exponential.hpp" #include "../gtx/norm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_quaternion is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_quaternion extension included") # endif #endif namespace glm { /// @addtogroup gtx_quaternion /// @{ /// Create an identity quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL GLM_CONSTEXPR qua quat_identity(); /// Compute a cross product between a quaternion and a vector. /// /// @see gtx_quaternion template GLM_FUNC_DECL vec<3, T, Q> cross( qua const& q, vec<3, T, Q> const& v); //! Compute a cross product between a vector and a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL vec<3, T, Q> cross( vec<3, T, Q> const& v, qua const& q); //! Compute a point on a path according squad equation. //! q1 and q2 are control points; s1 and s2 are intermediate control points. /// /// @see gtx_quaternion template GLM_FUNC_DECL qua squad( qua const& q1, qua const& q2, qua const& s1, qua const& s2, T const& h); //! Returns an intermediate control point for squad interpolation. /// /// @see gtx_quaternion template GLM_FUNC_DECL qua intermediate( qua const& prev, qua const& curr, qua const& next); //! Returns quarternion square root. /// /// @see gtx_quaternion //template //qua sqrt( // qua const& q); //! Rotates a 3 components vector by a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL vec<3, T, Q> rotate( qua const& q, vec<3, T, Q> const& v); /// Rotates a 4 components vector by a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL vec<4, T, Q> rotate( qua const& q, vec<4, T, Q> const& v); /// Extract the real component of a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL T extractRealComponent( qua const& q); /// Converts a quaternion to a 3 * 3 matrix. /// /// @see gtx_quaternion template GLM_FUNC_DECL mat<3, 3, T, Q> toMat3( qua const& x){return mat3_cast(x);} /// Converts a quaternion to a 4 * 4 matrix. /// /// @see gtx_quaternion template GLM_FUNC_DECL mat<4, 4, T, Q> toMat4( qua const& x){return mat4_cast(x);} /// Converts a 3 * 3 matrix to a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL qua toQuat( mat<3, 3, T, Q> const& x){return quat_cast(x);} /// Converts a 4 * 4 matrix to a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL qua toQuat( mat<4, 4, T, Q> const& x){return quat_cast(x);} /// Quaternion interpolation using the rotation short path. /// /// @see gtx_quaternion template GLM_FUNC_DECL qua shortMix( qua const& x, qua const& y, T const& a); /// Quaternion normalized linear interpolation. /// /// @see gtx_quaternion template GLM_FUNC_DECL qua fastMix( qua const& x, qua const& y, T const& a); /// Compute the rotation between two vectors. /// @param orig vector, needs to be normalized /// @param dest vector, needs to be normalized /// /// @see gtx_quaternion template GLM_FUNC_DECL qua rotation( vec<3, T, Q> const& orig, vec<3, T, Q> const& dest); /// Returns the squared length of x. /// /// @see gtx_quaternion template GLM_FUNC_DECL GLM_CONSTEXPR T length2(qua const& q); /// @} }//namespace glm #include "quaternion.inl" ================================================ FILE: android/src/glm/gtx/quaternion.inl ================================================ /// @ref gtx_quaternion #include #include "../gtc/constants.hpp" namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua quat_identity() { return qua(static_cast(1), static_cast(0), static_cast(0), static_cast(0)); } template GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& v, qua const& q) { return inverse(q) * v; } template GLM_FUNC_QUALIFIER vec<3, T, Q> cross(qua const& q, vec<3, T, Q> const& v) { return q * v; } template GLM_FUNC_QUALIFIER qua squad ( qua const& q1, qua const& q2, qua const& s1, qua const& s2, T const& h) { return mix(mix(q1, q2, h), mix(s1, s2, h), static_cast(2) * (static_cast(1) - h) * h); } template GLM_FUNC_QUALIFIER qua intermediate ( qua const& prev, qua const& curr, qua const& next ) { qua invQuat = inverse(curr); return exp((log(next * invQuat) + log(prev * invQuat)) / static_cast(-4)) * curr; } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotate(qua const& q, vec<3, T, Q> const& v) { return q * v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> rotate(qua const& q, vec<4, T, Q> const& v) { return q * v; } template GLM_FUNC_QUALIFIER T extractRealComponent(qua const& q) { T w = static_cast(1) - q.x * q.x - q.y * q.y - q.z * q.z; if(w < T(0)) return T(0); else return -sqrt(w); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T length2(qua const& q) { return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w; } template GLM_FUNC_QUALIFIER qua shortMix(qua const& x, qua const& y, T const& a) { if(a <= static_cast(0)) return x; if(a >= static_cast(1)) return y; T fCos = dot(x, y); qua y2(y); //BUG!!! qua y2; if(fCos < static_cast(0)) { y2 = -y; fCos = -fCos; } //if(fCos > 1.0f) // problem T k0, k1; if(fCos > (static_cast(1) - epsilon())) { k0 = static_cast(1) - a; k1 = static_cast(0) + a; //BUG!!! 1.0f + a; } else { T fSin = sqrt(T(1) - fCos * fCos); T fAngle = atan(fSin, fCos); T fOneOverSin = static_cast(1) / fSin; k0 = sin((static_cast(1) - a) * fAngle) * fOneOverSin; k1 = sin((static_cast(0) + a) * fAngle) * fOneOverSin; } return qua( k0 * x.w + k1 * y2.w, k0 * x.x + k1 * y2.x, k0 * x.y + k1 * y2.y, k0 * x.z + k1 * y2.z); } template GLM_FUNC_QUALIFIER qua fastMix(qua const& x, qua const& y, T const& a) { return glm::normalize(x * (static_cast(1) - a) + (y * a)); } template GLM_FUNC_QUALIFIER qua rotation(vec<3, T, Q> const& orig, vec<3, T, Q> const& dest) { T cosTheta = dot(orig, dest); vec<3, T, Q> rotationAxis; if(cosTheta >= static_cast(1) - epsilon()) { // orig and dest point in the same direction return quat_identity(); } if(cosTheta < static_cast(-1) + epsilon()) { // special case when vectors in opposite directions : // there is no "ideal" rotation axis // So guess one; any will do as long as it's perpendicular to start // This implementation favors a rotation around the Up axis (Y), // since it's often what you want to do. rotationAxis = cross(vec<3, T, Q>(0, 0, 1), orig); if(length2(rotationAxis) < epsilon()) // bad luck, they were parallel, try again! rotationAxis = cross(vec<3, T, Q>(1, 0, 0), orig); rotationAxis = normalize(rotationAxis); return angleAxis(pi(), rotationAxis); } // Implementation from Stan Melax's Game Programming Gems 1 article rotationAxis = cross(orig, dest); T s = sqrt((T(1) + cosTheta) * static_cast(2)); T invs = static_cast(1) / s; return qua( s * static_cast(0.5f), rotationAxis.x * invs, rotationAxis.y * invs, rotationAxis.z * invs); } }//namespace glm ================================================ FILE: android/src/glm/gtx/range.hpp ================================================ /// @ref gtx_range /// @file glm/gtx/range.hpp /// @author Joshua Moerman /// /// @defgroup gtx_range GLM_GTX_range /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines begin and end for vectors and matrices. Useful for range-based for loop. /// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements). #pragma once // Dependencies #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_range is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_range extension included") # endif #endif #include "../gtc/type_ptr.hpp" #include "../gtc/vec1.hpp" namespace glm { /// @addtogroup gtx_range /// @{ # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable : 4100) // unreferenced formal parameter # endif template inline length_t components(vec<1, T, Q> const& v) { return v.length(); } template inline length_t components(vec<2, T, Q> const& v) { return v.length(); } template inline length_t components(vec<3, T, Q> const& v) { return v.length(); } template inline length_t components(vec<4, T, Q> const& v) { return v.length(); } template inline length_t components(genType const& m) { return m.length() * m[0].length(); } template inline typename genType::value_type const * begin(genType const& v) { return value_ptr(v); } template inline typename genType::value_type const * end(genType const& v) { return begin(v) + components(v); } template inline typename genType::value_type * begin(genType& v) { return value_ptr(v); } template inline typename genType::value_type * end(genType& v) { return begin(v) + components(v); } # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif /// @} }//namespace glm ================================================ FILE: android/src/glm/gtx/raw_data.hpp ================================================ /// @ref gtx_raw_data /// @file glm/gtx/raw_data.hpp /// /// @see core (dependence) /// /// @defgroup gtx_raw_data GLM_GTX_raw_data /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Projection of a vector to other one #pragma once // Dependencies #include "../ext/scalar_uint_sized.hpp" #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_raw_data is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_raw_data extension included") # endif #endif namespace glm { /// @addtogroup gtx_raw_data /// @{ //! Type for byte numbers. //! From GLM_GTX_raw_data extension. typedef detail::uint8 byte; //! Type for word numbers. //! From GLM_GTX_raw_data extension. typedef detail::uint16 word; //! Type for dword numbers. //! From GLM_GTX_raw_data extension. typedef detail::uint32 dword; //! Type for qword numbers. //! From GLM_GTX_raw_data extension. typedef detail::uint64 qword; /// @} }// namespace glm #include "raw_data.inl" ================================================ FILE: android/src/glm/gtx/raw_data.inl ================================================ /// @ref gtx_raw_data ================================================ FILE: android/src/glm/gtx/rotate_normalized_axis.hpp ================================================ /// @ref gtx_rotate_normalized_axis /// @file glm/gtx/rotate_normalized_axis.hpp /// /// @see core (dependence) /// @see gtc_matrix_transform /// @see gtc_quaternion /// /// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Quaternions and matrices rotations around normalized axis. #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/epsilon.hpp" #include "../gtc/quaternion.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_rotate_normalized_axis is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_rotate_normalized_axis extension included") # endif #endif namespace glm { /// @addtogroup gtx_rotate_normalized_axis /// @{ /// Builds a rotation 4 * 4 matrix created from a normalized axis and an angle. /// /// @param m Input matrix multiplied by this rotation matrix. /// @param angle Rotation angle expressed in radians. /// @param axis Rotation axis, must be normalized. /// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double. /// /// @see gtx_rotate_normalized_axis /// @see - rotate(T angle, T x, T y, T z) /// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z) /// @see - rotate(T angle, vec<3, T, Q> const& v) template GLM_FUNC_DECL mat<4, 4, T, Q> rotateNormalizedAxis( mat<4, 4, T, Q> const& m, T const& angle, vec<3, T, Q> const& axis); /// Rotates a quaternion from a vector of 3 components normalized axis and an angle. /// /// @param q Source orientation /// @param angle Angle expressed in radians. /// @param axis Normalized axis of the rotation, must be normalized. /// /// @see gtx_rotate_normalized_axis template GLM_FUNC_DECL qua rotateNormalizedAxis( qua const& q, T const& angle, vec<3, T, Q> const& axis); /// @} }//namespace glm #include "rotate_normalized_axis.inl" ================================================ FILE: android/src/glm/gtx/rotate_normalized_axis.inl ================================================ /// @ref gtx_rotate_normalized_axis namespace glm { template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotateNormalizedAxis ( mat<4, 4, T, Q> const& m, T const& angle, vec<3, T, Q> const& v ) { T const a = angle; T const c = cos(a); T const s = sin(a); vec<3, T, Q> const axis(v); vec<3, T, Q> const temp((static_cast(1) - c) * axis); mat<4, 4, T, Q> Rotate; Rotate[0][0] = c + temp[0] * axis[0]; Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; Rotate[1][1] = c + temp[1] * axis[1]; Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; Rotate[2][2] = c + temp[2] * axis[2]; mat<4, 4, T, Q> Result; Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; Result[3] = m[3]; return Result; } template GLM_FUNC_QUALIFIER qua rotateNormalizedAxis ( qua const& q, T const& angle, vec<3, T, Q> const& v ) { vec<3, T, Q> const Tmp(v); T const AngleRad(angle); T const Sin = sin(AngleRad * T(0.5)); return q * qua(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); //return gtc::quaternion::cross(q, tquat(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/rotate_vector.hpp ================================================ /// @ref gtx_rotate_vector /// @file glm/gtx/rotate_vector.hpp /// /// @see core (dependence) /// @see gtx_transform (dependence) /// /// @defgroup gtx_rotate_vector GLM_GTX_rotate_vector /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Function to directly rotate a vector #pragma once // Dependency: #include "../gtx/transform.hpp" #include "../gtc/epsilon.hpp" #include "../ext/vector_relational.hpp" #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_rotate_vector is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_rotate_vector extension included") # endif #endif namespace glm { /// @addtogroup gtx_rotate_vector /// @{ /// Returns Spherical interpolation between two vectors /// /// @param x A first vector /// @param y A second vector /// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// /// @see gtx_rotate_vector template GLM_FUNC_DECL vec<3, T, Q> slerp( vec<3, T, Q> const& x, vec<3, T, Q> const& y, T const& a); //! Rotate a two dimensional vector. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<2, T, Q> rotate( vec<2, T, Q> const& v, T const& angle); //! Rotate a three dimensional vector around an axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<3, T, Q> rotate( vec<3, T, Q> const& v, T const& angle, vec<3, T, Q> const& normal); //! Rotate a four dimensional vector around an axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<4, T, Q> rotate( vec<4, T, Q> const& v, T const& angle, vec<3, T, Q> const& normal); //! Rotate a three dimensional vector around the X axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<3, T, Q> rotateX( vec<3, T, Q> const& v, T const& angle); //! Rotate a three dimensional vector around the Y axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<3, T, Q> rotateY( vec<3, T, Q> const& v, T const& angle); //! Rotate a three dimensional vector around the Z axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<3, T, Q> rotateZ( vec<3, T, Q> const& v, T const& angle); //! Rotate a four dimensional vector around the X axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<4, T, Q> rotateX( vec<4, T, Q> const& v, T const& angle); //! Rotate a four dimensional vector around the Y axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<4, T, Q> rotateY( vec<4, T, Q> const& v, T const& angle); //! Rotate a four dimensional vector around the Z axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<4, T, Q> rotateZ( vec<4, T, Q> const& v, T const& angle); //! Build a rotation matrix from a normal and a up vector. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL mat<4, 4, T, Q> orientation( vec<3, T, Q> const& Normal, vec<3, T, Q> const& Up); /// @} }//namespace glm #include "rotate_vector.inl" ================================================ FILE: android/src/glm/gtx/rotate_vector.inl ================================================ /// @ref gtx_rotate_vector namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> slerp ( vec<3, T, Q> const& x, vec<3, T, Q> const& y, T const& a ) { // get cosine of angle between vectors (-1 -> 1) T CosAlpha = dot(x, y); // get angle (0 -> pi) T Alpha = acos(CosAlpha); // get sine of angle between vectors (0 -> 1) T SinAlpha = sin(Alpha); // this breaks down when SinAlpha = 0, i.e. Alpha = 0 or pi T t1 = sin((static_cast(1) - a) * Alpha) / SinAlpha; T t2 = sin(a * Alpha) / SinAlpha; // interpolate src vectors return x * t1 + y * t2; } template GLM_FUNC_QUALIFIER vec<2, T, Q> rotate ( vec<2, T, Q> const& v, T const& angle ) { vec<2, T, Q> Result; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos - v.y * Sin; Result.y = v.x * Sin + v.y * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotate ( vec<3, T, Q> const& v, T const& angle, vec<3, T, Q> const& normal ) { return mat<3, 3, T, Q>(glm::rotate(angle, normal)) * v; } /* template GLM_FUNC_QUALIFIER vec<3, T, Q> rotateGTX( const vec<3, T, Q>& x, T angle, const vec<3, T, Q>& normal) { const T Cos = cos(radians(angle)); const T Sin = sin(radians(angle)); return x * Cos + ((x * normal) * (T(1) - Cos)) * normal + cross(x, normal) * Sin; } */ template GLM_FUNC_QUALIFIER vec<4, T, Q> rotate ( vec<4, T, Q> const& v, T const& angle, vec<3, T, Q> const& normal ) { return rotate(angle, normal) * v; } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotateX ( vec<3, T, Q> const& v, T const& angle ) { vec<3, T, Q> Result(v); T const Cos(cos(angle)); T const Sin(sin(angle)); Result.y = v.y * Cos - v.z * Sin; Result.z = v.y * Sin + v.z * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotateY ( vec<3, T, Q> const& v, T const& angle ) { vec<3, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos + v.z * Sin; Result.z = -v.x * Sin + v.z * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotateZ ( vec<3, T, Q> const& v, T const& angle ) { vec<3, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos - v.y * Sin; Result.y = v.x * Sin + v.y * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<4, T, Q> rotateX ( vec<4, T, Q> const& v, T const& angle ) { vec<4, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.y = v.y * Cos - v.z * Sin; Result.z = v.y * Sin + v.z * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<4, T, Q> rotateY ( vec<4, T, Q> const& v, T const& angle ) { vec<4, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos + v.z * Sin; Result.z = -v.x * Sin + v.z * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<4, T, Q> rotateZ ( vec<4, T, Q> const& v, T const& angle ) { vec<4, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos - v.y * Sin; Result.y = v.x * Sin + v.y * Cos; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> orientation ( vec<3, T, Q> const& Normal, vec<3, T, Q> const& Up ) { if(all(equal(Normal, Up, epsilon()))) return mat<4, 4, T, Q>(static_cast(1)); vec<3, T, Q> RotationAxis = cross(Up, Normal); T Angle = acos(dot(Normal, Up)); return rotate(Angle, RotationAxis); } }//namespace glm ================================================ FILE: android/src/glm/gtx/scalar_multiplication.hpp ================================================ /// @ref gtx /// @file glm/gtx/scalar_multiplication.hpp /// @author Joshua Moerman /// /// Include to use the features of this extension. /// /// Enables scalar multiplication for all types /// /// Since GLSL is very strict about types, the following (often used) combinations do not work: /// double * vec4 /// int * vec4 /// vec4 / int /// So we'll fix that! Of course "float * vec4" should remain the same (hence the enable_if magic) #pragma once #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_scalar_multiplication is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_scalar_multiplication extension included") # endif #endif #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../mat2x2.hpp" #include namespace glm { template using return_type_scalar_multiplication = typename std::enable_if< !std::is_same::value // T may not be a float && std::is_arithmetic::value, Vec // But it may be an int or double (no vec3 or mat3, ...) >::type; #define GLM_IMPLEMENT_SCAL_MULT(Vec) \ template \ return_type_scalar_multiplication \ operator*(T const& s, Vec rh){ \ return rh *= static_cast(s); \ } \ \ template \ return_type_scalar_multiplication \ operator*(Vec lh, T const& s){ \ return lh *= static_cast(s); \ } \ \ template \ return_type_scalar_multiplication \ operator/(Vec lh, T const& s){ \ return lh *= 1.0f / static_cast(s); \ } GLM_IMPLEMENT_SCAL_MULT(vec2) GLM_IMPLEMENT_SCAL_MULT(vec3) GLM_IMPLEMENT_SCAL_MULT(vec4) GLM_IMPLEMENT_SCAL_MULT(mat2) GLM_IMPLEMENT_SCAL_MULT(mat2x3) GLM_IMPLEMENT_SCAL_MULT(mat2x4) GLM_IMPLEMENT_SCAL_MULT(mat3x2) GLM_IMPLEMENT_SCAL_MULT(mat3) GLM_IMPLEMENT_SCAL_MULT(mat3x4) GLM_IMPLEMENT_SCAL_MULT(mat4x2) GLM_IMPLEMENT_SCAL_MULT(mat4x3) GLM_IMPLEMENT_SCAL_MULT(mat4) #undef GLM_IMPLEMENT_SCAL_MULT } // namespace glm ================================================ FILE: android/src/glm/gtx/scalar_relational.hpp ================================================ /// @ref gtx_scalar_relational /// @file glm/gtx/scalar_relational.hpp /// /// @see core (dependence) /// /// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Extend a position from a source to a position at a defined length. #pragma once // Dependency: #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_extend extension included") # endif #endif namespace glm { /// @addtogroup gtx_scalar_relational /// @{ /// @} }//namespace glm #include "scalar_relational.inl" ================================================ FILE: android/src/glm/gtx/scalar_relational.inl ================================================ /// @ref gtx_scalar_relational namespace glm { template GLM_FUNC_QUALIFIER bool lessThan ( T const& x, T const& y ) { return x < y; } template GLM_FUNC_QUALIFIER bool lessThanEqual ( T const& x, T const& y ) { return x <= y; } template GLM_FUNC_QUALIFIER bool greaterThan ( T const& x, T const& y ) { return x > y; } template GLM_FUNC_QUALIFIER bool greaterThanEqual ( T const& x, T const& y ) { return x >= y; } template GLM_FUNC_QUALIFIER bool equal ( T const& x, T const& y ) { return detail::compute_equal::is_iec559>::call(x, y); } template GLM_FUNC_QUALIFIER bool notEqual ( T const& x, T const& y ) { return !detail::compute_equal::is_iec559>::call(x, y); } GLM_FUNC_QUALIFIER bool any ( bool const& x ) { return x; } GLM_FUNC_QUALIFIER bool all ( bool const& x ) { return x; } GLM_FUNC_QUALIFIER bool not_ ( bool const& x ) { return !x; } }//namespace glm ================================================ FILE: android/src/glm/gtx/spline.hpp ================================================ /// @ref gtx_spline /// @file glm/gtx/spline.hpp /// /// @see core (dependence) /// /// @defgroup gtx_spline GLM_GTX_spline /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Spline functions #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/optimum_pow.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_spline is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_spline extension included") # endif #endif namespace glm { /// @addtogroup gtx_spline /// @{ /// Return a point from a catmull rom curve. /// @see gtx_spline extension. template GLM_FUNC_DECL genType catmullRom( genType const& v1, genType const& v2, genType const& v3, genType const& v4, typename genType::value_type const& s); /// Return a point from a hermite curve. /// @see gtx_spline extension. template GLM_FUNC_DECL genType hermite( genType const& v1, genType const& t1, genType const& v2, genType const& t2, typename genType::value_type const& s); /// Return a point from a cubic curve. /// @see gtx_spline extension. template GLM_FUNC_DECL genType cubic( genType const& v1, genType const& v2, genType const& v3, genType const& v4, typename genType::value_type const& s); /// @} }//namespace glm #include "spline.inl" ================================================ FILE: android/src/glm/gtx/spline.inl ================================================ /// @ref gtx_spline namespace glm { template GLM_FUNC_QUALIFIER genType catmullRom ( genType const& v1, genType const& v2, genType const& v3, genType const& v4, typename genType::value_type const& s ) { typename genType::value_type s2 = pow2(s); typename genType::value_type s3 = pow3(s); typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s; typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2); typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s; typename genType::value_type f4 = s3 - s2; return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2); } template GLM_FUNC_QUALIFIER genType hermite ( genType const& v1, genType const& t1, genType const& v2, genType const& t2, typename genType::value_type const& s ) { typename genType::value_type s2 = pow2(s); typename genType::value_type s3 = pow3(s); typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1); typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2; typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s; typename genType::value_type f4 = s3 - s2; return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2; } template GLM_FUNC_QUALIFIER genType cubic ( genType const& v1, genType const& v2, genType const& v3, genType const& v4, typename genType::value_type const& s ) { return ((v1 * s + v2) * s + v3) * s + v4; } }//namespace glm ================================================ FILE: android/src/glm/gtx/std_based_type.hpp ================================================ /// @ref gtx_std_based_type /// @file glm/gtx/std_based_type.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_std_based_type GLM_GTX_std_based_type /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Adds vector types based on STL value types. #pragma once // Dependency: #include "../glm.hpp" #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_std_based_type is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_std_based_type extension included") # endif #endif namespace glm { /// @addtogroup gtx_std_based_type /// @{ /// Vector type based of one std::size_t component. /// @see GLM_GTX_std_based_type typedef vec<1, std::size_t, defaultp> size1; /// Vector type based of two std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<2, std::size_t, defaultp> size2; /// Vector type based of three std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<3, std::size_t, defaultp> size3; /// Vector type based of four std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<4, std::size_t, defaultp> size4; /// Vector type based of one std::size_t component. /// @see GLM_GTX_std_based_type typedef vec<1, std::size_t, defaultp> size1_t; /// Vector type based of two std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<2, std::size_t, defaultp> size2_t; /// Vector type based of three std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<3, std::size_t, defaultp> size3_t; /// Vector type based of four std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<4, std::size_t, defaultp> size4_t; /// @} }//namespace glm #include "std_based_type.inl" ================================================ FILE: android/src/glm/gtx/std_based_type.inl ================================================ /// @ref gtx_std_based_type namespace glm { } ================================================ FILE: android/src/glm/gtx/string_cast.hpp ================================================ /// @ref gtx_string_cast /// @file glm/gtx/string_cast.hpp /// /// @see core (dependence) /// @see gtx_integer (dependence) /// @see gtx_quaternion (dependence) /// /// @defgroup gtx_string_cast GLM_GTX_string_cast /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Setup strings for GLM type values /// /// This extension is not supported with CUDA #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/type_precision.hpp" #include "../gtc/quaternion.hpp" #include "../gtx/dual_quaternion.hpp" #include #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_string_cast is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_string_cast extension included") # endif #endif #if(GLM_COMPILER & GLM_COMPILER_CUDA) # error "GLM_GTX_string_cast is not supported on CUDA compiler" #endif namespace glm { /// @addtogroup gtx_string_cast /// @{ /// Create a string from a GLM vector or matrix typed variable. /// @see gtx_string_cast extension. template GLM_FUNC_DECL std::string to_string(genType const& x); /// @} }//namespace glm #include "string_cast.inl" ================================================ FILE: android/src/glm/gtx/string_cast.inl ================================================ /// @ref gtx_string_cast #include #include namespace glm{ namespace detail { template struct cast { typedef T value_type; }; template <> struct cast { typedef double value_type; }; GLM_FUNC_QUALIFIER std::string format(const char* msg, ...) { std::size_t const STRING_BUFFER(4096); char text[STRING_BUFFER]; va_list list; if(msg == GLM_NULLPTR) return std::string(); va_start(list, msg); # if (GLM_COMPILER & GLM_COMPILER_VC) vsprintf_s(text, STRING_BUFFER, msg, list); # else// std::vsprintf(text, msg, list); # endif// va_end(list); return std::string(text); } static const char* LabelTrue = "true"; static const char* LabelFalse = "false"; template struct literal { GLM_FUNC_QUALIFIER static char const * value() {return "%d";} }; template struct literal { GLM_FUNC_QUALIFIER static char const * value() {return "%f";} }; # if GLM_MODEL == GLM_MODEL_32 && GLM_COMPILER && GLM_COMPILER_VC template<> struct literal { GLM_FUNC_QUALIFIER static char const * value() {return "%lld";} }; template<> struct literal { GLM_FUNC_QUALIFIER static char const * value() {return "%lld";} }; # endif//GLM_MODEL == GLM_MODEL_32 && GLM_COMPILER && GLM_COMPILER_VC template struct prefix{}; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "d";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "b";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "u8";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "i8";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "u16";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "i16";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "u";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "i";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "u64";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "i64";} }; template struct compute_to_string {}; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<1, bool, Q> const& x) { return detail::format("bvec1(%s)", x[0] ? detail::LabelTrue : detail::LabelFalse); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<2, bool, Q> const& x) { return detail::format("bvec2(%s, %s)", x[0] ? detail::LabelTrue : detail::LabelFalse, x[1] ? detail::LabelTrue : detail::LabelFalse); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<3, bool, Q> const& x) { return detail::format("bvec3(%s, %s, %s)", x[0] ? detail::LabelTrue : detail::LabelFalse, x[1] ? detail::LabelTrue : detail::LabelFalse, x[2] ? detail::LabelTrue : detail::LabelFalse); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<4, bool, Q> const& x) { return detail::format("bvec4(%s, %s, %s, %s)", x[0] ? detail::LabelTrue : detail::LabelFalse, x[1] ? detail::LabelTrue : detail::LabelFalse, x[2] ? detail::LabelTrue : detail::LabelFalse, x[3] ? detail::LabelTrue : detail::LabelFalse); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<1, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%svec1(%s)", PrefixStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<2, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%svec2(%s, %s)", PrefixStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0]), static_cast::value_type>(x[1])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<3, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%svec3(%s, %s, %s)", PrefixStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0]), static_cast::value_type>(x[1]), static_cast::value_type>(x[2])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<4, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%svec4(%s, %s, %s, %s)", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0]), static_cast::value_type>(x[1]), static_cast::value_type>(x[2]), static_cast::value_type>(x[3])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<2, 2, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat2x2((%s, %s), (%s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<2, 3, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat2x3((%s, %s, %s), (%s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<2, 4, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat2x4((%s, %s, %s, %s), (%s, %s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[0][3]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[1][3])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<3, 2, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat3x2((%s, %s), (%s, %s), (%s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<3, 3, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat3x3((%s, %s, %s), (%s, %s, %s), (%s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[2][2])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<3, 4, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat3x4((%s, %s, %s, %s), (%s, %s, %s, %s), (%s, %s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[0][3]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[1][3]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[2][2]), static_cast::value_type>(x[2][3])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<4, 2, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat4x2((%s, %s), (%s, %s), (%s, %s), (%s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[3][0]), static_cast::value_type>(x[3][1])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<4, 3, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat4x3((%s, %s, %s), (%s, %s, %s), (%s, %s, %s), (%s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[2][2]), static_cast::value_type>(x[3][0]), static_cast::value_type>(x[3][1]), static_cast::value_type>(x[3][2])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<4, 4, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat4x4((%s, %s, %s, %s), (%s, %s, %s, %s), (%s, %s, %s, %s), (%s, %s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[0][3]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[1][3]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[2][2]), static_cast::value_type>(x[2][3]), static_cast::value_type>(x[3][0]), static_cast::value_type>(x[3][1]), static_cast::value_type>(x[3][2]), static_cast::value_type>(x[3][3])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(qua const& q) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%squat(%s, {%s, %s, %s})", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(q.w), static_cast::value_type>(q.x), static_cast::value_type>(q.y), static_cast::value_type>(q.z)); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(tdualquat const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%sdualquat((%s, {%s, %s, %s}), (%s, {%s, %s, %s}))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x.real.w), static_cast::value_type>(x.real.x), static_cast::value_type>(x.real.y), static_cast::value_type>(x.real.z), static_cast::value_type>(x.dual.w), static_cast::value_type>(x.dual.x), static_cast::value_type>(x.dual.y), static_cast::value_type>(x.dual.z)); } }; }//namespace detail template GLM_FUNC_QUALIFIER std::string to_string(matType const& x) { return detail::compute_to_string::call(x); } }//namespace glm ================================================ FILE: android/src/glm/gtx/texture.hpp ================================================ /// @ref gtx_texture /// @file glm/gtx/texture.hpp /// /// @see core (dependence) /// /// @defgroup gtx_texture GLM_GTX_texture /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Wrapping mode of texture coordinates. #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/integer.hpp" #include "../gtx/component_wise.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_texture is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_texture extension included") # endif #endif namespace glm { /// @addtogroup gtx_texture /// @{ /// Compute the number of mipmaps levels necessary to create a mipmap complete texture /// /// @param Extent Extent of the texture base level mipmap /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum template T levels(vec const& Extent); /// @} }// namespace glm #include "texture.inl" ================================================ FILE: android/src/glm/gtx/texture.inl ================================================ /// @ref gtx_texture namespace glm { template inline T levels(vec const& Extent) { return glm::log2(compMax(Extent)) + static_cast(1); } template inline T levels(T Extent) { return vec<1, T, defaultp>(Extent).x; } }//namespace glm ================================================ FILE: android/src/glm/gtx/transform.hpp ================================================ /// @ref gtx_transform /// @file glm/gtx/transform.hpp /// /// @see core (dependence) /// @see gtc_matrix_transform (dependence) /// @see gtx_transform /// @see gtx_transform2 /// /// @defgroup gtx_transform GLM_GTX_transform /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add transformation matrices #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/matrix_transform.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_transform is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_transform extension included") # endif #endif namespace glm { /// @addtogroup gtx_transform /// @{ /// Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. /// @see gtc_matrix_transform /// @see gtx_transform template GLM_FUNC_DECL mat<4, 4, T, Q> translate( vec<3, T, Q> const& v); /// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians. /// @see gtc_matrix_transform /// @see gtx_transform template GLM_FUNC_DECL mat<4, 4, T, Q> rotate( T angle, vec<3, T, Q> const& v); /// Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components. /// @see gtc_matrix_transform /// @see gtx_transform template GLM_FUNC_DECL mat<4, 4, T, Q> scale( vec<3, T, Q> const& v); /// @} }// namespace glm #include "transform.inl" ================================================ FILE: android/src/glm/gtx/transform.inl ================================================ /// @ref gtx_transform namespace glm { template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(vec<3, T, Q> const& v) { return translate(mat<4, 4, T, Q>(static_cast(1)), v); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v) { return rotate(mat<4, 4, T, Q>(static_cast(1)), angle, v); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(vec<3, T, Q> const& v) { return scale(mat<4, 4, T, Q>(static_cast(1)), v); } }//namespace glm ================================================ FILE: android/src/glm/gtx/transform2.hpp ================================================ /// @ref gtx_transform2 /// @file glm/gtx/transform2.hpp /// /// @see core (dependence) /// @see gtx_transform (dependence) /// /// @defgroup gtx_transform2 GLM_GTX_transform2 /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add extra transformation matrices #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/transform.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_transform2 is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_transform2 extension included") # endif #endif namespace glm { /// @addtogroup gtx_transform2 /// @{ //! Transforms a matrix with a shearing on X axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<3, 3, T, Q> shearX2D(mat<3, 3, T, Q> const& m, T y); //! Transforms a matrix with a shearing on Y axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<3, 3, T, Q> shearY2D(mat<3, 3, T, Q> const& m, T x); //! Transforms a matrix with a shearing on X axis //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> shearX3D(mat<4, 4, T, Q> const& m, T y, T z); //! Transforms a matrix with a shearing on Y axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> shearY3D(mat<4, 4, T, Q> const& m, T x, T z); //! Transforms a matrix with a shearing on Z axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> shearZ3D(mat<4, 4, T, Q> const& m, T x, T y); //template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shear(const mat<4, 4, T, Q> & m, shearPlane, planePoint, angle) // Identity + tan(angle) * cross(Normal, OnPlaneVector) 0 // - dot(PointOnPlane, normal) * OnPlaneVector 1 // Reflect functions seem to don't work //template mat<3, 3, T, Q> reflect2D(const mat<3, 3, T, Q> & m, const vec<3, T, Q>& normal){return reflect2DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension) //template mat<4, 4, T, Q> reflect3D(const mat<4, 4, T, Q> & m, const vec<3, T, Q>& normal){return reflect3DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension) //! Build planar projection matrix along normal axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<3, 3, T, Q> proj2D(mat<3, 3, T, Q> const& m, vec<3, T, Q> const& normal); //! Build planar projection matrix along normal axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> proj3D(mat<4, 4, T, Q> const & m, vec<3, T, Q> const& normal); //! Build a scale bias matrix. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> scaleBias(T scale, T bias); //! Build a scale bias matrix. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> scaleBias(mat<4, 4, T, Q> const& m, T scale, T bias); /// @} }// namespace glm #include "transform2.inl" ================================================ FILE: android/src/glm/gtx/transform2.inl ================================================ /// @ref gtx_transform2 namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX2D(mat<3, 3, T, Q> const& m, T s) { mat<3, 3, T, Q> r(1); r[1][0] = s; return m * r; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY2D(mat<3, 3, T, Q> const& m, T s) { mat<3, 3, T, Q> r(1); r[0][1] = s; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shearX3D(mat<4, 4, T, Q> const& m, T s, T t) { mat<4, 4, T, Q> r(1); r[0][1] = s; r[0][2] = t; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shearY3D(mat<4, 4, T, Q> const& m, T s, T t) { mat<4, 4, T, Q> r(1); r[1][0] = s; r[1][2] = t; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shearZ3D(mat<4, 4, T, Q> const& m, T s, T t) { mat<4, 4, T, Q> r(1); r[2][0] = s; r[2][1] = t; return m * r; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> reflect2D(mat<3, 3, T, Q> const& m, vec<3, T, Q> const& normal) { mat<3, 3, T, Q> r(static_cast(1)); r[0][0] = static_cast(1) - static_cast(2) * normal.x * normal.x; r[0][1] = -static_cast(2) * normal.x * normal.y; r[1][0] = -static_cast(2) * normal.x * normal.y; r[1][1] = static_cast(1) - static_cast(2) * normal.y * normal.y; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> reflect3D(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& normal) { mat<4, 4, T, Q> r(static_cast(1)); r[0][0] = static_cast(1) - static_cast(2) * normal.x * normal.x; r[0][1] = -static_cast(2) * normal.x * normal.y; r[0][2] = -static_cast(2) * normal.x * normal.z; r[1][0] = -static_cast(2) * normal.x * normal.y; r[1][1] = static_cast(1) - static_cast(2) * normal.y * normal.y; r[1][2] = -static_cast(2) * normal.y * normal.z; r[2][0] = -static_cast(2) * normal.x * normal.z; r[2][1] = -static_cast(2) * normal.y * normal.z; r[2][2] = static_cast(1) - static_cast(2) * normal.z * normal.z; return m * r; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> proj2D( const mat<3, 3, T, Q>& m, const vec<3, T, Q>& normal) { mat<3, 3, T, Q> r(static_cast(1)); r[0][0] = static_cast(1) - normal.x * normal.x; r[0][1] = - normal.x * normal.y; r[1][0] = - normal.x * normal.y; r[1][1] = static_cast(1) - normal.y * normal.y; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> proj3D( const mat<4, 4, T, Q>& m, const vec<3, T, Q>& normal) { mat<4, 4, T, Q> r(static_cast(1)); r[0][0] = static_cast(1) - normal.x * normal.x; r[0][1] = - normal.x * normal.y; r[0][2] = - normal.x * normal.z; r[1][0] = - normal.x * normal.y; r[1][1] = static_cast(1) - normal.y * normal.y; r[1][2] = - normal.y * normal.z; r[2][0] = - normal.x * normal.z; r[2][1] = - normal.y * normal.z; r[2][2] = static_cast(1) - normal.z * normal.z; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scaleBias(T scale, T bias) { mat<4, 4, T, Q> result; result[3] = vec<4, T, Q>(vec<3, T, Q>(bias), static_cast(1)); result[0][0] = scale; result[1][1] = scale; result[2][2] = scale; return result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scaleBias(mat<4, 4, T, Q> const& m, T scale, T bias) { return m * scaleBias(scale, bias); } }//namespace glm ================================================ FILE: android/src/glm/gtx/type_aligned.hpp ================================================ /// @ref gtx_type_aligned /// @file glm/gtx/type_aligned.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_type_aligned GLM_GTX_type_aligned /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines aligned types. #pragma once // Dependency: #include "../gtc/type_precision.hpp" #include "../gtc/quaternion.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_type_aligned is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_type_aligned extension included") # endif #endif namespace glm { /////////////////////////// // Signed int vector types /// @addtogroup gtx_type_aligned /// @{ /// Low qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int8, aligned_lowp_int8, 1); /// Low qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int16, aligned_lowp_int16, 2); /// Low qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int32, aligned_lowp_int32, 4); /// Low qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int64, aligned_lowp_int64, 8); /// Low qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int8_t, aligned_lowp_int8_t, 1); /// Low qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int16_t, aligned_lowp_int16_t, 2); /// Low qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int32_t, aligned_lowp_int32_t, 4); /// Low qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int64_t, aligned_lowp_int64_t, 8); /// Low qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i8, aligned_lowp_i8, 1); /// Low qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i16, aligned_lowp_i16, 2); /// Low qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i32, aligned_lowp_i32, 4); /// Low qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i64, aligned_lowp_i64, 8); /// Medium qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int8, aligned_mediump_int8, 1); /// Medium qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int16, aligned_mediump_int16, 2); /// Medium qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int32, aligned_mediump_int32, 4); /// Medium qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int64, aligned_mediump_int64, 8); /// Medium qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int8_t, aligned_mediump_int8_t, 1); /// Medium qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int16_t, aligned_mediump_int16_t, 2); /// Medium qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int32_t, aligned_mediump_int32_t, 4); /// Medium qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int64_t, aligned_mediump_int64_t, 8); /// Medium qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i8, aligned_mediump_i8, 1); /// Medium qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i16, aligned_mediump_i16, 2); /// Medium qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i32, aligned_mediump_i32, 4); /// Medium qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i64, aligned_mediump_i64, 8); /// High qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int8, aligned_highp_int8, 1); /// High qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int16, aligned_highp_int16, 2); /// High qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int32, aligned_highp_int32, 4); /// High qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int64, aligned_highp_int64, 8); /// High qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int8_t, aligned_highp_int8_t, 1); /// High qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int16_t, aligned_highp_int16_t, 2); /// High qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int32_t, aligned_highp_int32_t, 4); /// High qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int64_t, aligned_highp_int64_t, 8); /// High qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i8, aligned_highp_i8, 1); /// High qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i16, aligned_highp_i16, 2); /// High qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i32, aligned_highp_i32, 4); /// High qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i64, aligned_highp_i64, 8); /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int8, aligned_int8, 1); /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int16, aligned_int16, 2); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int32, aligned_int32, 4); /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int64, aligned_int64, 8); /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int8_t, aligned_int8_t, 1); /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int16_t, aligned_int16_t, 2); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int32_t, aligned_int32_t, 4); /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int64_t, aligned_int64_t, 8); /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8, aligned_i8, 1); /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16, aligned_i16, 2); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32, aligned_i32, 4); /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64, aligned_i64, 8); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec1, aligned_ivec1, 4); /// Default qualifier 32 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec2, aligned_ivec2, 8); /// Default qualifier 32 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec3, aligned_ivec3, 16); /// Default qualifier 32 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec4, aligned_ivec4, 16); /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec1, aligned_i8vec1, 1); /// Default qualifier 8 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec2, aligned_i8vec2, 2); /// Default qualifier 8 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec3, aligned_i8vec3, 4); /// Default qualifier 8 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec4, aligned_i8vec4, 4); /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec1, aligned_i16vec1, 2); /// Default qualifier 16 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec2, aligned_i16vec2, 4); /// Default qualifier 16 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec3, aligned_i16vec3, 8); /// Default qualifier 16 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec4, aligned_i16vec4, 8); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec1, aligned_i32vec1, 4); /// Default qualifier 32 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec2, aligned_i32vec2, 8); /// Default qualifier 32 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec3, aligned_i32vec3, 16); /// Default qualifier 32 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec4, aligned_i32vec4, 16); /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec1, aligned_i64vec1, 8); /// Default qualifier 64 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec2, aligned_i64vec2, 16); /// Default qualifier 64 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec3, aligned_i64vec3, 32); /// Default qualifier 64 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec4, aligned_i64vec4, 32); ///////////////////////////// // Unsigned int vector types /// Low qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint8, aligned_lowp_uint8, 1); /// Low qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint16, aligned_lowp_uint16, 2); /// Low qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint32, aligned_lowp_uint32, 4); /// Low qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint64, aligned_lowp_uint64, 8); /// Low qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint8_t, aligned_lowp_uint8_t, 1); /// Low qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint16_t, aligned_lowp_uint16_t, 2); /// Low qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint32_t, aligned_lowp_uint32_t, 4); /// Low qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint64_t, aligned_lowp_uint64_t, 8); /// Low qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u8, aligned_lowp_u8, 1); /// Low qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u16, aligned_lowp_u16, 2); /// Low qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u32, aligned_lowp_u32, 4); /// Low qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u64, aligned_lowp_u64, 8); /// Medium qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint8, aligned_mediump_uint8, 1); /// Medium qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint16, aligned_mediump_uint16, 2); /// Medium qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint32, aligned_mediump_uint32, 4); /// Medium qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint64, aligned_mediump_uint64, 8); /// Medium qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint8_t, aligned_mediump_uint8_t, 1); /// Medium qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint16_t, aligned_mediump_uint16_t, 2); /// Medium qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint32_t, aligned_mediump_uint32_t, 4); /// Medium qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint64_t, aligned_mediump_uint64_t, 8); /// Medium qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u8, aligned_mediump_u8, 1); /// Medium qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u16, aligned_mediump_u16, 2); /// Medium qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u32, aligned_mediump_u32, 4); /// Medium qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u64, aligned_mediump_u64, 8); /// High qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint8, aligned_highp_uint8, 1); /// High qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint16, aligned_highp_uint16, 2); /// High qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint32, aligned_highp_uint32, 4); /// High qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint64, aligned_highp_uint64, 8); /// High qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint8_t, aligned_highp_uint8_t, 1); /// High qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint16_t, aligned_highp_uint16_t, 2); /// High qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint32_t, aligned_highp_uint32_t, 4); /// High qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint64_t, aligned_highp_uint64_t, 8); /// High qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u8, aligned_highp_u8, 1); /// High qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u16, aligned_highp_u16, 2); /// High qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u32, aligned_highp_u32, 4); /// High qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u64, aligned_highp_u64, 8); /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint8, aligned_uint8, 1); /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint16, aligned_uint16, 2); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint32, aligned_uint32, 4); /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint64, aligned_uint64, 8); /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint8_t, aligned_uint8_t, 1); /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint16_t, aligned_uint16_t, 2); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint32_t, aligned_uint32_t, 4); /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint64_t, aligned_uint64_t, 8); /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8, aligned_u8, 1); /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16, aligned_u16, 2); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32, aligned_u32, 4); /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64, aligned_u64, 8); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec1, aligned_uvec1, 4); /// Default qualifier 32 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec2, aligned_uvec2, 8); /// Default qualifier 32 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec3, aligned_uvec3, 16); /// Default qualifier 32 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec4, aligned_uvec4, 16); /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec1, aligned_u8vec1, 1); /// Default qualifier 8 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec2, aligned_u8vec2, 2); /// Default qualifier 8 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec3, aligned_u8vec3, 4); /// Default qualifier 8 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec4, aligned_u8vec4, 4); /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec1, aligned_u16vec1, 2); /// Default qualifier 16 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec2, aligned_u16vec2, 4); /// Default qualifier 16 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec3, aligned_u16vec3, 8); /// Default qualifier 16 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec4, aligned_u16vec4, 8); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec1, aligned_u32vec1, 4); /// Default qualifier 32 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec2, aligned_u32vec2, 8); /// Default qualifier 32 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec3, aligned_u32vec3, 16); /// Default qualifier 32 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec4, aligned_u32vec4, 16); /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec1, aligned_u64vec1, 8); /// Default qualifier 64 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec2, aligned_u64vec2, 16); /// Default qualifier 64 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec3, aligned_u64vec3, 32); /// Default qualifier 64 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec4, aligned_u64vec4, 32); ////////////////////// // Float vector types /// 32 bit single-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float32, aligned_float32, 4); /// 32 bit single-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float32_t, aligned_float32_t, 4); /// 32 bit single-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float32, aligned_f32, 4); # ifndef GLM_FORCE_SINGLE_ONLY /// 64 bit double-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float64, aligned_float64, 8); /// 64 bit double-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float64_t, aligned_float64_t, 8); /// 64 bit double-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float64, aligned_f64, 8); # endif//GLM_FORCE_SINGLE_ONLY /// Single-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec1, aligned_vec1, 4); /// Single-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec2, aligned_vec2, 8); /// Single-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec3, aligned_vec3, 16); /// Single-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec4, aligned_vec4, 16); /// Single-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec1, aligned_fvec1, 4); /// Single-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec2, aligned_fvec2, 8); /// Single-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec3, aligned_fvec3, 16); /// Single-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec4, aligned_fvec4, 16); /// Single-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec1, aligned_f32vec1, 4); /// Single-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec2, aligned_f32vec2, 8); /// Single-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec3, aligned_f32vec3, 16); /// Single-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec4, aligned_f32vec4, 16); /// Double-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec1, aligned_dvec1, 8); /// Double-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec2, aligned_dvec2, 16); /// Double-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec3, aligned_dvec3, 32); /// Double-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec4, aligned_dvec4, 32); # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec1, aligned_f64vec1, 8); /// Double-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec2, aligned_f64vec2, 16); /// Double-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec3, aligned_f64vec3, 32); /// Double-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec4, aligned_f64vec4, 32); # endif//GLM_FORCE_SINGLE_ONLY ////////////////////// // Float matrix types /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1 mat1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat2, aligned_mat2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat3, aligned_mat3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat4, aligned_mat4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 mat1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat2x2, aligned_mat2x2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat3x3, aligned_mat3x3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat4x4, aligned_mat4x4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 fmat1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef f32 fmat1x1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2x2, 16); /// Single-qualifier floating-point aligned 2x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x3, aligned_fmat2x3, 16); /// Single-qualifier floating-point aligned 2x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x4, aligned_fmat2x4, 16); /// Single-qualifier floating-point aligned 3x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x2, aligned_fmat3x2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3x3, 16); /// Single-qualifier floating-point aligned 3x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x4, aligned_fmat3x4, 16); /// Single-qualifier floating-point aligned 4x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x2, aligned_fmat4x2, 16); /// Single-qualifier floating-point aligned 4x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x3, aligned_fmat4x3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4x4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 f32mat1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef f32 f32mat1x1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2x2, 16); /// Single-qualifier floating-point aligned 2x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x3, aligned_f32mat2x3, 16); /// Single-qualifier floating-point aligned 2x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x4, aligned_f32mat2x4, 16); /// Single-qualifier floating-point aligned 3x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x2, aligned_f32mat3x2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3x3, 16); /// Single-qualifier floating-point aligned 3x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x4, aligned_f32mat3x4, 16); /// Single-qualifier floating-point aligned 4x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x2, aligned_f32mat4x2, 16); /// Single-qualifier floating-point aligned 4x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x3, aligned_f32mat4x3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4x4, 16); # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 f64mat1; /// Double-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2, 32); /// Double-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3, 32); /// Double-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4, 32); /// Double-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef f64 f64mat1x1; /// Double-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2x2, 32); /// Double-qualifier floating-point aligned 2x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x3, aligned_f64mat2x3, 32); /// Double-qualifier floating-point aligned 2x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x4, aligned_f64mat2x4, 32); /// Double-qualifier floating-point aligned 3x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x2, aligned_f64mat3x2, 32); /// Double-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3x3, 32); /// Double-qualifier floating-point aligned 3x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x4, aligned_f64mat3x4, 32); /// Double-qualifier floating-point aligned 4x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x2, aligned_f64mat4x2, 32); /// Double-qualifier floating-point aligned 4x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x3, aligned_f64mat4x3, 32); /// Double-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4x4, 32); # endif//GLM_FORCE_SINGLE_ONLY ////////////////////////// // Quaternion types /// Single-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(quat, aligned_quat, 16); /// Single-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(quat, aligned_fquat, 16); /// Double-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dquat, aligned_dquat, 32); /// Single-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32quat, aligned_f32quat, 16); # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64quat, aligned_f64quat, 32); # endif//GLM_FORCE_SINGLE_ONLY /// @} }//namespace glm #include "type_aligned.inl" ================================================ FILE: android/src/glm/gtx/type_aligned.inl ================================================ /// @ref gtc_type_aligned namespace glm { } ================================================ FILE: android/src/glm/gtx/type_trait.hpp ================================================ /// @ref gtx_type_trait /// @file glm/gtx/type_trait.hpp /// /// @see core (dependence) /// /// @defgroup gtx_type_trait GLM_GTX_type_trait /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines traits for each type. #pragma once #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_type_trait is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_type_trait extension included") # endif #endif // Dependency: #include "../detail/qualifier.hpp" #include "../gtc/quaternion.hpp" #include "../gtx/dual_quaternion.hpp" namespace glm { /// @addtogroup gtx_type_trait /// @{ template struct type { static bool const is_vec = false; static bool const is_mat = false; static bool const is_quat = false; static length_t const components = 0; static length_t const cols = 0; static length_t const rows = 0; }; template struct type > { static bool const is_vec = true; static bool const is_mat = false; static bool const is_quat = false; static length_t const components = L; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; static length_t const components = C; static length_t const cols = C; static length_t const rows = R; }; template struct type > { static bool const is_vec = false; static bool const is_mat = false; static bool const is_quat = true; static length_t const components = 4; }; template struct type > { static bool const is_vec = false; static bool const is_mat = false; static bool const is_quat = true; static length_t const components = 8; }; /// @} }//namespace glm #include "type_trait.inl" ================================================ FILE: android/src/glm/gtx/type_trait.inl ================================================ /// @ref gtx_type_trait namespace glm { template bool const type::is_vec; template bool const type::is_mat; template bool const type::is_quat; template length_t const type::components; template length_t const type::cols; template length_t const type::rows; // vec template bool const type >::is_vec; template bool const type >::is_mat; template bool const type >::is_quat; template length_t const type >::components; // mat template bool const type >::is_vec; template bool const type >::is_mat; template bool const type >::is_quat; template length_t const type >::components; template length_t const type >::cols; template length_t const type >::rows; // tquat template bool const type >::is_vec; template bool const type >::is_mat; template bool const type >::is_quat; template length_t const type >::components; // tdualquat template bool const type >::is_vec; template bool const type >::is_mat; template bool const type >::is_quat; template length_t const type >::components; }//namespace glm ================================================ FILE: android/src/glm/gtx/vec_swizzle.hpp ================================================ /// @ref gtx_vec_swizzle /// @file glm/gtx/vec_swizzle.hpp /// /// @see core (dependence) /// /// @defgroup gtx_vec_swizzle GLM_GTX_vec_swizzle /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Functions to perform swizzle operation. #pragma once #include "../glm.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_vec_swizzle is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_vec_swizzle extension included") # endif #endif namespace glm { // xx template GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<1, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.x); } template GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<2, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.x); } template GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.x); } template GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.x); } // xy template GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<2, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.y); } template GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.y); } template GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.y); } // xz template GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.z); } template GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.z); } // xw template GLM_INLINE glm::vec<2, T, Q> xw(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.w); } // yx template GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<2, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.x); } template GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.x); } template GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.x); } // yy template GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<2, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.y); } template GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.y); } template GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.y); } // yz template GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.z); } template GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.z); } // yw template GLM_INLINE glm::vec<2, T, Q> yw(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.w); } // zx template GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.x); } template GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.x); } // zy template GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.y); } template GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.y); } // zz template GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.z); } template GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.z); } // zw template GLM_INLINE glm::vec<2, T, Q> zw(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.w); } // wx template GLM_INLINE glm::vec<2, T, Q> wx(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.w, v.x); } // wy template GLM_INLINE glm::vec<2, T, Q> wy(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.w, v.y); } // wz template GLM_INLINE glm::vec<2, T, Q> wz(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.w, v.z); } // ww template GLM_INLINE glm::vec<2, T, Q> ww(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.w, v.w); } // xxx template GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<1, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.x); } // xxy template GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.y); } // xxz template GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.z); } template GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.z); } // xxw template GLM_INLINE glm::vec<3, T, Q> xxw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.w); } // xyx template GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.x); } // xyy template GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.y); } // xyz template GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.z); } template GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.z); } // xyw template GLM_INLINE glm::vec<3, T, Q> xyw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.w); } // xzx template GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.x); } template GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.x); } // xzy template GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.y); } template GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.y); } // xzz template GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.z); } template GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.z); } // xzw template GLM_INLINE glm::vec<3, T, Q> xzw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.w); } // xwx template GLM_INLINE glm::vec<3, T, Q> xwx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.w, v.x); } // xwy template GLM_INLINE glm::vec<3, T, Q> xwy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.w, v.y); } // xwz template GLM_INLINE glm::vec<3, T, Q> xwz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.w, v.z); } // xww template GLM_INLINE glm::vec<3, T, Q> xww(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.w, v.w); } // yxx template GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.x); } // yxy template GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.y); } // yxz template GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.z); } template GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.z); } // yxw template GLM_INLINE glm::vec<3, T, Q> yxw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.w); } // yyx template GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.x); } // yyy template GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.y); } // yyz template GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.z); } template GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.z); } // yyw template GLM_INLINE glm::vec<3, T, Q> yyw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.w); } // yzx template GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.x); } template GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.x); } // yzy template GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.y); } template GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.y); } // yzz template GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.z); } template GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.z); } // yzw template GLM_INLINE glm::vec<3, T, Q> yzw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.w); } // ywx template GLM_INLINE glm::vec<3, T, Q> ywx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.w, v.x); } // ywy template GLM_INLINE glm::vec<3, T, Q> ywy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.w, v.y); } // ywz template GLM_INLINE glm::vec<3, T, Q> ywz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.w, v.z); } // yww template GLM_INLINE glm::vec<3, T, Q> yww(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.w, v.w); } // zxx template GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.x); } // zxy template GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.y); } // zxz template GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.z); } template GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.z); } // zxw template GLM_INLINE glm::vec<3, T, Q> zxw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.w); } // zyx template GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.x); } // zyy template GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.y); } // zyz template GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.z); } template GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.z); } // zyw template GLM_INLINE glm::vec<3, T, Q> zyw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.w); } // zzx template GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.x); } template GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.x); } // zzy template GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.y); } template GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.y); } // zzz template GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.z); } template GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.z); } // zzw template GLM_INLINE glm::vec<3, T, Q> zzw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.w); } // zwx template GLM_INLINE glm::vec<3, T, Q> zwx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.w, v.x); } // zwy template GLM_INLINE glm::vec<3, T, Q> zwy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.w, v.y); } // zwz template GLM_INLINE glm::vec<3, T, Q> zwz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.w, v.z); } // zww template GLM_INLINE glm::vec<3, T, Q> zww(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.w, v.w); } // wxx template GLM_INLINE glm::vec<3, T, Q> wxx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.x, v.x); } // wxy template GLM_INLINE glm::vec<3, T, Q> wxy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.x, v.y); } // wxz template GLM_INLINE glm::vec<3, T, Q> wxz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.x, v.z); } // wxw template GLM_INLINE glm::vec<3, T, Q> wxw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.x, v.w); } // wyx template GLM_INLINE glm::vec<3, T, Q> wyx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.y, v.x); } // wyy template GLM_INLINE glm::vec<3, T, Q> wyy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.y, v.y); } // wyz template GLM_INLINE glm::vec<3, T, Q> wyz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.y, v.z); } // wyw template GLM_INLINE glm::vec<3, T, Q> wyw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.y, v.w); } // wzx template GLM_INLINE glm::vec<3, T, Q> wzx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.z, v.x); } // wzy template GLM_INLINE glm::vec<3, T, Q> wzy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.z, v.y); } // wzz template GLM_INLINE glm::vec<3, T, Q> wzz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.z, v.z); } // wzw template GLM_INLINE glm::vec<3, T, Q> wzw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.z, v.w); } // wwx template GLM_INLINE glm::vec<3, T, Q> wwx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.w, v.x); } // wwy template GLM_INLINE glm::vec<3, T, Q> wwy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.w, v.y); } // wwz template GLM_INLINE glm::vec<3, T, Q> wwz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.w, v.z); } // www template GLM_INLINE glm::vec<3, T, Q> www(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.w, v.w); } // xxxx template GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<1, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x); } // xxxy template GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y); } // xxxz template GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z); } // xxxw template GLM_INLINE glm::vec<4, T, Q> xxxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.w); } // xxyx template GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x); } // xxyy template GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y); } // xxyz template GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z); } // xxyw template GLM_INLINE glm::vec<4, T, Q> xxyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.w); } // xxzx template GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x); } // xxzy template GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y); } // xxzz template GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z); } // xxzw template GLM_INLINE glm::vec<4, T, Q> xxzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.w); } // xxwx template GLM_INLINE glm::vec<4, T, Q> xxwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.w, v.x); } // xxwy template GLM_INLINE glm::vec<4, T, Q> xxwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.w, v.y); } // xxwz template GLM_INLINE glm::vec<4, T, Q> xxwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.w, v.z); } // xxww template GLM_INLINE glm::vec<4, T, Q> xxww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.w, v.w); } // xyxx template GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x); } // xyxy template GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y); } // xyxz template GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z); } // xyxw template GLM_INLINE glm::vec<4, T, Q> xyxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.w); } // xyyx template GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x); } // xyyy template GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y); } // xyyz template GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z); } // xyyw template GLM_INLINE glm::vec<4, T, Q> xyyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.w); } // xyzx template GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x); } // xyzy template GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y); } // xyzz template GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z); } // xyzw template GLM_INLINE glm::vec<4, T, Q> xyzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.w); } // xywx template GLM_INLINE glm::vec<4, T, Q> xywx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.w, v.x); } // xywy template GLM_INLINE glm::vec<4, T, Q> xywy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.w, v.y); } // xywz template GLM_INLINE glm::vec<4, T, Q> xywz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.w, v.z); } // xyww template GLM_INLINE glm::vec<4, T, Q> xyww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.w, v.w); } // xzxx template GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x); } // xzxy template GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y); } // xzxz template GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z); } // xzxw template GLM_INLINE glm::vec<4, T, Q> xzxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.w); } // xzyx template GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x); } // xzyy template GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y); } // xzyz template GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z); } // xzyw template GLM_INLINE glm::vec<4, T, Q> xzyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.w); } // xzzx template GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x); } // xzzy template GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y); } // xzzz template GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z); } // xzzw template GLM_INLINE glm::vec<4, T, Q> xzzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.w); } // xzwx template GLM_INLINE glm::vec<4, T, Q> xzwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.w, v.x); } // xzwy template GLM_INLINE glm::vec<4, T, Q> xzwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.w, v.y); } // xzwz template GLM_INLINE glm::vec<4, T, Q> xzwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.w, v.z); } // xzww template GLM_INLINE glm::vec<4, T, Q> xzww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.w, v.w); } // xwxx template GLM_INLINE glm::vec<4, T, Q> xwxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.x, v.x); } // xwxy template GLM_INLINE glm::vec<4, T, Q> xwxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.x, v.y); } // xwxz template GLM_INLINE glm::vec<4, T, Q> xwxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.x, v.z); } // xwxw template GLM_INLINE glm::vec<4, T, Q> xwxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.x, v.w); } // xwyx template GLM_INLINE glm::vec<4, T, Q> xwyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.y, v.x); } // xwyy template GLM_INLINE glm::vec<4, T, Q> xwyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.y, v.y); } // xwyz template GLM_INLINE glm::vec<4, T, Q> xwyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.y, v.z); } // xwyw template GLM_INLINE glm::vec<4, T, Q> xwyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.y, v.w); } // xwzx template GLM_INLINE glm::vec<4, T, Q> xwzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.z, v.x); } // xwzy template GLM_INLINE glm::vec<4, T, Q> xwzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.z, v.y); } // xwzz template GLM_INLINE glm::vec<4, T, Q> xwzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.z, v.z); } // xwzw template GLM_INLINE glm::vec<4, T, Q> xwzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.z, v.w); } // xwwx template GLM_INLINE glm::vec<4, T, Q> xwwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.w, v.x); } // xwwy template GLM_INLINE glm::vec<4, T, Q> xwwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.w, v.y); } // xwwz template GLM_INLINE glm::vec<4, T, Q> xwwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.w, v.z); } // xwww template GLM_INLINE glm::vec<4, T, Q> xwww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.w, v.w); } // yxxx template GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x); } // yxxy template GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y); } // yxxz template GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z); } // yxxw template GLM_INLINE glm::vec<4, T, Q> yxxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.w); } // yxyx template GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x); } // yxyy template GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y); } // yxyz template GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z); } // yxyw template GLM_INLINE glm::vec<4, T, Q> yxyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.w); } // yxzx template GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x); } // yxzy template GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y); } // yxzz template GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z); } // yxzw template GLM_INLINE glm::vec<4, T, Q> yxzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.w); } // yxwx template GLM_INLINE glm::vec<4, T, Q> yxwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.w, v.x); } // yxwy template GLM_INLINE glm::vec<4, T, Q> yxwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.w, v.y); } // yxwz template GLM_INLINE glm::vec<4, T, Q> yxwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.w, v.z); } // yxww template GLM_INLINE glm::vec<4, T, Q> yxww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.w, v.w); } // yyxx template GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x); } // yyxy template GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y); } // yyxz template GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z); } // yyxw template GLM_INLINE glm::vec<4, T, Q> yyxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.w); } // yyyx template GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x); } // yyyy template GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y); } // yyyz template GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z); } // yyyw template GLM_INLINE glm::vec<4, T, Q> yyyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.w); } // yyzx template GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x); } // yyzy template GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y); } // yyzz template GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z); } // yyzw template GLM_INLINE glm::vec<4, T, Q> yyzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.w); } // yywx template GLM_INLINE glm::vec<4, T, Q> yywx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.w, v.x); } // yywy template GLM_INLINE glm::vec<4, T, Q> yywy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.w, v.y); } // yywz template GLM_INLINE glm::vec<4, T, Q> yywz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.w, v.z); } // yyww template GLM_INLINE glm::vec<4, T, Q> yyww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.w, v.w); } // yzxx template GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x); } // yzxy template GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y); } // yzxz template GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z); } // yzxw template GLM_INLINE glm::vec<4, T, Q> yzxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.w); } // yzyx template GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x); } // yzyy template GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y); } // yzyz template GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z); } // yzyw template GLM_INLINE glm::vec<4, T, Q> yzyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.w); } // yzzx template GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x); } // yzzy template GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y); } // yzzz template GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z); } // yzzw template GLM_INLINE glm::vec<4, T, Q> yzzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.w); } // yzwx template GLM_INLINE glm::vec<4, T, Q> yzwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.w, v.x); } // yzwy template GLM_INLINE glm::vec<4, T, Q> yzwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.w, v.y); } // yzwz template GLM_INLINE glm::vec<4, T, Q> yzwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.w, v.z); } // yzww template GLM_INLINE glm::vec<4, T, Q> yzww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.w, v.w); } // ywxx template GLM_INLINE glm::vec<4, T, Q> ywxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.x, v.x); } // ywxy template GLM_INLINE glm::vec<4, T, Q> ywxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.x, v.y); } // ywxz template GLM_INLINE glm::vec<4, T, Q> ywxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.x, v.z); } // ywxw template GLM_INLINE glm::vec<4, T, Q> ywxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.x, v.w); } // ywyx template GLM_INLINE glm::vec<4, T, Q> ywyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.y, v.x); } // ywyy template GLM_INLINE glm::vec<4, T, Q> ywyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.y, v.y); } // ywyz template GLM_INLINE glm::vec<4, T, Q> ywyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.y, v.z); } // ywyw template GLM_INLINE glm::vec<4, T, Q> ywyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.y, v.w); } // ywzx template GLM_INLINE glm::vec<4, T, Q> ywzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.z, v.x); } // ywzy template GLM_INLINE glm::vec<4, T, Q> ywzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.z, v.y); } // ywzz template GLM_INLINE glm::vec<4, T, Q> ywzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.z, v.z); } // ywzw template GLM_INLINE glm::vec<4, T, Q> ywzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.z, v.w); } // ywwx template GLM_INLINE glm::vec<4, T, Q> ywwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.w, v.x); } // ywwy template GLM_INLINE glm::vec<4, T, Q> ywwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.w, v.y); } // ywwz template GLM_INLINE glm::vec<4, T, Q> ywwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.w, v.z); } // ywww template GLM_INLINE glm::vec<4, T, Q> ywww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.w, v.w); } // zxxx template GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x); } // zxxy template GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y); } // zxxz template GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z); } // zxxw template GLM_INLINE glm::vec<4, T, Q> zxxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.w); } // zxyx template GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x); } // zxyy template GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y); } // zxyz template GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z); } // zxyw template GLM_INLINE glm::vec<4, T, Q> zxyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.w); } // zxzx template GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x); } // zxzy template GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y); } // zxzz template GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z); } // zxzw template GLM_INLINE glm::vec<4, T, Q> zxzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.w); } // zxwx template GLM_INLINE glm::vec<4, T, Q> zxwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.w, v.x); } // zxwy template GLM_INLINE glm::vec<4, T, Q> zxwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.w, v.y); } // zxwz template GLM_INLINE glm::vec<4, T, Q> zxwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.w, v.z); } // zxww template GLM_INLINE glm::vec<4, T, Q> zxww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.w, v.w); } // zyxx template GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x); } // zyxy template GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y); } // zyxz template GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z); } // zyxw template GLM_INLINE glm::vec<4, T, Q> zyxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.w); } // zyyx template GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x); } // zyyy template GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y); } // zyyz template GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z); } // zyyw template GLM_INLINE glm::vec<4, T, Q> zyyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.w); } // zyzx template GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x); } // zyzy template GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y); } // zyzz template GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z); } // zyzw template GLM_INLINE glm::vec<4, T, Q> zyzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.w); } // zywx template GLM_INLINE glm::vec<4, T, Q> zywx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.w, v.x); } // zywy template GLM_INLINE glm::vec<4, T, Q> zywy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.w, v.y); } // zywz template GLM_INLINE glm::vec<4, T, Q> zywz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.w, v.z); } // zyww template GLM_INLINE glm::vec<4, T, Q> zyww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.w, v.w); } // zzxx template GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x); } // zzxy template GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y); } // zzxz template GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z); } // zzxw template GLM_INLINE glm::vec<4, T, Q> zzxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.w); } // zzyx template GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x); } // zzyy template GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y); } // zzyz template GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z); } // zzyw template GLM_INLINE glm::vec<4, T, Q> zzyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.w); } // zzzx template GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x); } // zzzy template GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y); } // zzzz template GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z); } // zzzw template GLM_INLINE glm::vec<4, T, Q> zzzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.w); } // zzwx template GLM_INLINE glm::vec<4, T, Q> zzwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.w, v.x); } // zzwy template GLM_INLINE glm::vec<4, T, Q> zzwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.w, v.y); } // zzwz template GLM_INLINE glm::vec<4, T, Q> zzwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.w, v.z); } // zzww template GLM_INLINE glm::vec<4, T, Q> zzww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.w, v.w); } // zwxx template GLM_INLINE glm::vec<4, T, Q> zwxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.x, v.x); } // zwxy template GLM_INLINE glm::vec<4, T, Q> zwxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.x, v.y); } // zwxz template GLM_INLINE glm::vec<4, T, Q> zwxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.x, v.z); } // zwxw template GLM_INLINE glm::vec<4, T, Q> zwxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.x, v.w); } // zwyx template GLM_INLINE glm::vec<4, T, Q> zwyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.y, v.x); } // zwyy template GLM_INLINE glm::vec<4, T, Q> zwyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.y, v.y); } // zwyz template GLM_INLINE glm::vec<4, T, Q> zwyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.y, v.z); } // zwyw template GLM_INLINE glm::vec<4, T, Q> zwyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.y, v.w); } // zwzx template GLM_INLINE glm::vec<4, T, Q> zwzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.z, v.x); } // zwzy template GLM_INLINE glm::vec<4, T, Q> zwzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.z, v.y); } // zwzz template GLM_INLINE glm::vec<4, T, Q> zwzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.z, v.z); } // zwzw template GLM_INLINE glm::vec<4, T, Q> zwzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.z, v.w); } // zwwx template GLM_INLINE glm::vec<4, T, Q> zwwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.w, v.x); } // zwwy template GLM_INLINE glm::vec<4, T, Q> zwwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.w, v.y); } // zwwz template GLM_INLINE glm::vec<4, T, Q> zwwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.w, v.z); } // zwww template GLM_INLINE glm::vec<4, T, Q> zwww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.w, v.w); } // wxxx template GLM_INLINE glm::vec<4, T, Q> wxxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.x, v.x); } // wxxy template GLM_INLINE glm::vec<4, T, Q> wxxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.x, v.y); } // wxxz template GLM_INLINE glm::vec<4, T, Q> wxxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.x, v.z); } // wxxw template GLM_INLINE glm::vec<4, T, Q> wxxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.x, v.w); } // wxyx template GLM_INLINE glm::vec<4, T, Q> wxyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.y, v.x); } // wxyy template GLM_INLINE glm::vec<4, T, Q> wxyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.y, v.y); } // wxyz template GLM_INLINE glm::vec<4, T, Q> wxyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.y, v.z); } // wxyw template GLM_INLINE glm::vec<4, T, Q> wxyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.y, v.w); } // wxzx template GLM_INLINE glm::vec<4, T, Q> wxzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.z, v.x); } // wxzy template GLM_INLINE glm::vec<4, T, Q> wxzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.z, v.y); } // wxzz template GLM_INLINE glm::vec<4, T, Q> wxzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.z, v.z); } // wxzw template GLM_INLINE glm::vec<4, T, Q> wxzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.z, v.w); } // wxwx template GLM_INLINE glm::vec<4, T, Q> wxwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.w, v.x); } // wxwy template GLM_INLINE glm::vec<4, T, Q> wxwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.w, v.y); } // wxwz template GLM_INLINE glm::vec<4, T, Q> wxwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.w, v.z); } // wxww template GLM_INLINE glm::vec<4, T, Q> wxww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.w, v.w); } // wyxx template GLM_INLINE glm::vec<4, T, Q> wyxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.x, v.x); } // wyxy template GLM_INLINE glm::vec<4, T, Q> wyxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.x, v.y); } // wyxz template GLM_INLINE glm::vec<4, T, Q> wyxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.x, v.z); } // wyxw template GLM_INLINE glm::vec<4, T, Q> wyxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.x, v.w); } // wyyx template GLM_INLINE glm::vec<4, T, Q> wyyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.y, v.x); } // wyyy template GLM_INLINE glm::vec<4, T, Q> wyyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.y, v.y); } // wyyz template GLM_INLINE glm::vec<4, T, Q> wyyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.y, v.z); } // wyyw template GLM_INLINE glm::vec<4, T, Q> wyyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.y, v.w); } // wyzx template GLM_INLINE glm::vec<4, T, Q> wyzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.z, v.x); } // wyzy template GLM_INLINE glm::vec<4, T, Q> wyzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.z, v.y); } // wyzz template GLM_INLINE glm::vec<4, T, Q> wyzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.z, v.z); } // wyzw template GLM_INLINE glm::vec<4, T, Q> wyzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.z, v.w); } // wywx template GLM_INLINE glm::vec<4, T, Q> wywx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.w, v.x); } // wywy template GLM_INLINE glm::vec<4, T, Q> wywy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.w, v.y); } // wywz template GLM_INLINE glm::vec<4, T, Q> wywz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.w, v.z); } // wyww template GLM_INLINE glm::vec<4, T, Q> wyww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.w, v.w); } // wzxx template GLM_INLINE glm::vec<4, T, Q> wzxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.x, v.x); } // wzxy template GLM_INLINE glm::vec<4, T, Q> wzxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.x, v.y); } // wzxz template GLM_INLINE glm::vec<4, T, Q> wzxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.x, v.z); } // wzxw template GLM_INLINE glm::vec<4, T, Q> wzxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.x, v.w); } // wzyx template GLM_INLINE glm::vec<4, T, Q> wzyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.y, v.x); } // wzyy template GLM_INLINE glm::vec<4, T, Q> wzyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.y, v.y); } // wzyz template GLM_INLINE glm::vec<4, T, Q> wzyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.y, v.z); } // wzyw template GLM_INLINE glm::vec<4, T, Q> wzyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.y, v.w); } // wzzx template GLM_INLINE glm::vec<4, T, Q> wzzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.z, v.x); } // wzzy template GLM_INLINE glm::vec<4, T, Q> wzzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.z, v.y); } // wzzz template GLM_INLINE glm::vec<4, T, Q> wzzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.z, v.z); } // wzzw template GLM_INLINE glm::vec<4, T, Q> wzzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.z, v.w); } // wzwx template GLM_INLINE glm::vec<4, T, Q> wzwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.w, v.x); } // wzwy template GLM_INLINE glm::vec<4, T, Q> wzwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.w, v.y); } // wzwz template GLM_INLINE glm::vec<4, T, Q> wzwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.w, v.z); } // wzww template GLM_INLINE glm::vec<4, T, Q> wzww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.w, v.w); } // wwxx template GLM_INLINE glm::vec<4, T, Q> wwxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.x, v.x); } // wwxy template GLM_INLINE glm::vec<4, T, Q> wwxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.x, v.y); } // wwxz template GLM_INLINE glm::vec<4, T, Q> wwxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.x, v.z); } // wwxw template GLM_INLINE glm::vec<4, T, Q> wwxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.x, v.w); } // wwyx template GLM_INLINE glm::vec<4, T, Q> wwyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.y, v.x); } // wwyy template GLM_INLINE glm::vec<4, T, Q> wwyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.y, v.y); } // wwyz template GLM_INLINE glm::vec<4, T, Q> wwyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.y, v.z); } // wwyw template GLM_INLINE glm::vec<4, T, Q> wwyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.y, v.w); } // wwzx template GLM_INLINE glm::vec<4, T, Q> wwzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.z, v.x); } // wwzy template GLM_INLINE glm::vec<4, T, Q> wwzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.z, v.y); } // wwzz template GLM_INLINE glm::vec<4, T, Q> wwzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.z, v.z); } // wwzw template GLM_INLINE glm::vec<4, T, Q> wwzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.z, v.w); } // wwwx template GLM_INLINE glm::vec<4, T, Q> wwwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.w, v.x); } // wwwy template GLM_INLINE glm::vec<4, T, Q> wwwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.w, v.y); } // wwwz template GLM_INLINE glm::vec<4, T, Q> wwwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.w, v.z); } // wwww template GLM_INLINE glm::vec<4, T, Q> wwww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.w, v.w); } } ================================================ FILE: android/src/glm/gtx/vector_angle.hpp ================================================ /// @ref gtx_vector_angle /// @file glm/gtx/vector_angle.hpp /// /// @see core (dependence) /// @see gtx_quaternion (dependence) /// @see gtx_epsilon (dependence) /// /// @defgroup gtx_vector_angle GLM_GTX_vector_angle /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Compute angle between vectors #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/epsilon.hpp" #include "../gtx/quaternion.hpp" #include "../gtx/rotate_vector.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_vector_angle is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_vector_angle extension included") # endif #endif namespace glm { /// @addtogroup gtx_vector_angle /// @{ //! Returns the absolute angle between two vectors. //! Parameters need to be normalized. /// @see gtx_vector_angle extension. template GLM_FUNC_DECL T angle(vec const& x, vec const& y); //! Returns the oriented angle between two 2d vectors. //! Parameters need to be normalized. /// @see gtx_vector_angle extension. template GLM_FUNC_DECL T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y); //! Returns the oriented angle between two 3d vectors based from a reference axis. //! Parameters need to be normalized. /// @see gtx_vector_angle extension. template GLM_FUNC_DECL T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref); /// @} }// namespace glm #include "vector_angle.inl" ================================================ FILE: android/src/glm/gtx/vector_angle.inl ================================================ /// @ref gtx_vector_angle namespace glm { template GLM_FUNC_QUALIFIER genType angle ( genType const& x, genType const& y ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); return acos(clamp(dot(x, y), genType(-1), genType(1))); } template GLM_FUNC_QUALIFIER T angle(vec const& x, vec const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); return acos(clamp(dot(x, y), T(-1), T(1))); } //! \todo epsilon is hard coded to 0.01 template GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); if(all(epsilonEqual(y, glm::rotate(x, Angle), T(0.0001)))) return Angle; else return -Angle; } template GLM_FUNC_QUALIFIER T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0)); } }//namespace glm ================================================ FILE: android/src/glm/gtx/vector_query.hpp ================================================ /// @ref gtx_vector_query /// @file glm/gtx/vector_query.hpp /// /// @see core (dependence) /// /// @defgroup gtx_vector_query GLM_GTX_vector_query /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Query informations of vector types #pragma once // Dependency: #include "../glm.hpp" #include #include #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_vector_query is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_vector_query extension included") # endif #endif namespace glm { /// @addtogroup gtx_vector_query /// @{ //! Check whether two vectors are collinears. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool areCollinear(vec const& v0, vec const& v1, T const& epsilon); //! Check whether two vectors are orthogonals. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool areOrthogonal(vec const& v0, vec const& v1, T const& epsilon); //! Check whether a vector is normalized. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool isNormalized(vec const& v, T const& epsilon); //! Check whether a vector is null. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool isNull(vec const& v, T const& epsilon); //! Check whether a each component of a vector is null. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL vec isCompNull(vec const& v, T const& epsilon); //! Check whether two vectors are orthonormal. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool areOrthonormal(vec const& v0, vec const& v1, T const& epsilon); /// @} }// namespace glm #include "vector_query.inl" ================================================ FILE: android/src/glm/gtx/vector_query.inl ================================================ /// @ref gtx_vector_query #include namespace glm{ namespace detail { template struct compute_areCollinear{}; template struct compute_areCollinear<2, T, Q> { GLM_FUNC_QUALIFIER static bool call(vec<2, T, Q> const& v0, vec<2, T, Q> const& v1, T const& epsilon) { return length(cross(vec<3, T, Q>(v0, static_cast(0)), vec<3, T, Q>(v1, static_cast(0)))) < epsilon; } }; template struct compute_areCollinear<3, T, Q> { GLM_FUNC_QUALIFIER static bool call(vec<3, T, Q> const& v0, vec<3, T, Q> const& v1, T const& epsilon) { return length(cross(v0, v1)) < epsilon; } }; template struct compute_areCollinear<4, T, Q> { GLM_FUNC_QUALIFIER static bool call(vec<4, T, Q> const& v0, vec<4, T, Q> const& v1, T const& epsilon) { return length(cross(vec<3, T, Q>(v0), vec<3, T, Q>(v1))) < epsilon; } }; template struct compute_isCompNull{}; template struct compute_isCompNull<2, T, Q> { GLM_FUNC_QUALIFIER static vec<2, bool, Q> call(vec<2, T, Q> const& v, T const& epsilon) { return vec<2, bool, Q>( (abs(v.x) < epsilon), (abs(v.y) < epsilon)); } }; template struct compute_isCompNull<3, T, Q> { GLM_FUNC_QUALIFIER static vec<3, bool, Q> call(vec<3, T, Q> const& v, T const& epsilon) { return vec<3, bool, Q>( (abs(v.x) < epsilon), (abs(v.y) < epsilon), (abs(v.z) < epsilon)); } }; template struct compute_isCompNull<4, T, Q> { GLM_FUNC_QUALIFIER static vec<4, bool, Q> call(vec<4, T, Q> const& v, T const& epsilon) { return vec<4, bool, Q>( (abs(v.x) < epsilon), (abs(v.y) < epsilon), (abs(v.z) < epsilon), (abs(v.w) < epsilon)); } }; }//namespace detail template GLM_FUNC_QUALIFIER bool areCollinear(vec const& v0, vec const& v1, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'areCollinear' only accept floating-point inputs"); return detail::compute_areCollinear::call(v0, v1, epsilon); } template GLM_FUNC_QUALIFIER bool areOrthogonal(vec const& v0, vec const& v1, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'areOrthogonal' only accept floating-point inputs"); return abs(dot(v0, v1)) <= max( static_cast(1), length(v0)) * max(static_cast(1), length(v1)) * epsilon; } template GLM_FUNC_QUALIFIER bool isNormalized(vec const& v, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isNormalized' only accept floating-point inputs"); return abs(length(v) - static_cast(1)) <= static_cast(2) * epsilon; } template GLM_FUNC_QUALIFIER bool isNull(vec const& v, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isNull' only accept floating-point inputs"); return length(v) <= epsilon; } template GLM_FUNC_QUALIFIER vec isCompNull(vec const& v, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isCompNull' only accept floating-point inputs"); return detail::compute_isCompNull::call(v, epsilon); } template GLM_FUNC_QUALIFIER vec<2, bool, Q> isCompNull(vec<2, T, Q> const& v, T const& epsilon) { return vec<2, bool, Q>( abs(v.x) < epsilon, abs(v.y) < epsilon); } template GLM_FUNC_QUALIFIER vec<3, bool, Q> isCompNull(vec<3, T, Q> const& v, T const& epsilon) { return vec<3, bool, Q>( abs(v.x) < epsilon, abs(v.y) < epsilon, abs(v.z) < epsilon); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> isCompNull(vec<4, T, Q> const& v, T const& epsilon) { return vec<4, bool, Q>( abs(v.x) < epsilon, abs(v.y) < epsilon, abs(v.z) < epsilon, abs(v.w) < epsilon); } template GLM_FUNC_QUALIFIER bool areOrthonormal(vec const& v0, vec const& v1, T const& epsilon) { return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon); } }//namespace glm ================================================ FILE: android/src/glm/gtx/wrap.hpp ================================================ /// @ref gtx_wrap /// @file glm/gtx/wrap.hpp /// /// @see core (dependence) /// /// @defgroup gtx_wrap GLM_GTX_wrap /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Wrapping mode of texture coordinates. #pragma once // Dependency: #include "../glm.hpp" #include "../ext/scalar_common.hpp" #include "../ext/vector_common.hpp" #include "../gtc/vec1.hpp" #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) # ifndef GLM_ENABLE_EXPERIMENTAL # pragma message("GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") # else # pragma message("GLM: GLM_GTX_wrap extension included") # endif #endif namespace glm { /// @addtogroup gtx_wrap /// @{ /// @} }// namespace glm #include "wrap.inl" ================================================ FILE: android/src/glm/gtx/wrap.inl ================================================ /// @ref gtx_wrap namespace glm { }//namespace glm ================================================ FILE: android/src/glm/integer.hpp ================================================ /// @ref core /// @file glm/integer.hpp /// /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions /// /// @defgroup core_func_integer Integer functions /// @ingroup core /// /// Provides GLSL functions on integer types /// /// These all operate component-wise. The description is per component. /// The notation [a, b] means the set of bits from bit-number a through bit-number /// b, inclusive. The lowest-order bit is bit 0. /// /// Include to use these core features. #pragma once #include "detail/qualifier.hpp" #include "common.hpp" #include "vector_relational.hpp" namespace glm { /// @addtogroup core_func_integer /// @{ /// Adds 32-bit unsigned integer x and y, returning the sum /// modulo pow(2, 32). The value carry is set to 0 if the sum was /// less than pow(2, 32), or to 1 otherwise. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL uaddCarry man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec uaddCarry( vec const& x, vec const& y, vec & carry); /// Subtracts the 32-bit unsigned integer y from x, returning /// the difference if non-negative, or pow(2, 32) plus the difference /// otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL usubBorrow man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec usubBorrow( vec const& x, vec const& y, vec & borrow); /// Multiplies 32-bit integers x and y, producing a 64-bit /// result. The 32 least-significant bits are returned in lsb. /// The 32 most-significant bits are returned in msb. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL umulExtended man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL void umulExtended( vec const& x, vec const& y, vec & msb, vec & lsb); /// Multiplies 32-bit integers x and y, producing a 64-bit /// result. The 32 least-significant bits are returned in lsb. /// The 32 most-significant bits are returned in msb. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL imulExtended man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL void imulExtended( vec const& x, vec const& y, vec & msb, vec & lsb); /// Extracts bits [offset, offset + bits - 1] from value, /// returning them in the least significant bits of the result. /// For unsigned data types, the most significant bits of the /// result will be set to zero. For signed data types, the /// most significant bits will be set to the value of bit offset + base - 1. /// /// If bits is zero, the result will be zero. The result will be /// undefined if offset or bits is negative, or if the sum of /// offset and bits is greater than the number of bits used /// to store the operand. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar types. /// /// @see GLSL bitfieldExtract man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec bitfieldExtract( vec const& Value, int Offset, int Bits); /// Returns the insertion the bits least-significant bits of insert into base. /// /// The result will have bits [offset, offset + bits - 1] taken /// from bits [0, bits - 1] of insert, and all other bits taken /// directly from the corresponding bits of base. If bits is /// zero, the result will simply be base. The result will be /// undefined if offset or bits is negative, or if the sum of /// offset and bits is greater than the number of bits used to /// store the operand. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar or vector types. /// /// @see GLSL bitfieldInsert man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec bitfieldInsert( vec const& Base, vec const& Insert, int Offset, int Bits); /// Returns the reversal of the bits of value. /// The bit numbered n of the result will be taken from bit (bits - 1) - n of value, /// where bits is the total number of bits used to represent value. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar or vector types. /// /// @see GLSL bitfieldReverse man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec bitfieldReverse(vec const& v); /// Returns the number of bits set to 1 in the binary representation of value. /// /// @tparam genType Signed or unsigned integer scalar or vector types. /// /// @see GLSL bitCount man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL int bitCount(genType v); /// Returns the number of bits set to 1 in the binary representation of value. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar or vector types. /// /// @see GLSL bitCount man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec bitCount(vec const& v); /// Returns the bit number of the least significant bit set to /// 1 in the binary representation of value. /// If value is zero, -1 will be returned. /// /// @tparam genIUType Signed or unsigned integer scalar types. /// /// @see GLSL findLSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL int findLSB(genIUType x); /// Returns the bit number of the least significant bit set to /// 1 in the binary representation of value. /// If value is zero, -1 will be returned. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar types. /// /// @see GLSL findLSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec findLSB(vec const& v); /// Returns the bit number of the most significant bit in the binary representation of value. /// For positive integers, the result will be the bit number of the most significant bit set to 1. /// For negative integers, the result will be the bit number of the most significant /// bit set to 0. For a value of zero or negative one, -1 will be returned. /// /// @tparam genIUType Signed or unsigned integer scalar types. /// /// @see GLSL findMSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL int findMSB(genIUType x); /// Returns the bit number of the most significant bit in the binary representation of value. /// For positive integers, the result will be the bit number of the most significant bit set to 1. /// For negative integers, the result will be the bit number of the most significant /// bit set to 0. For a value of zero or negative one, -1 will be returned. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar types. /// /// @see GLSL findMSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec findMSB(vec const& v); /// @} }//namespace glm #include "detail/func_integer.inl" ================================================ FILE: android/src/glm/mat2x2.hpp ================================================ /// @ref core /// @file glm/mat2x2.hpp #pragma once #include "./ext/matrix_double2x2.hpp" #include "./ext/matrix_double2x2_precision.hpp" #include "./ext/matrix_float2x2.hpp" #include "./ext/matrix_float2x2_precision.hpp" ================================================ FILE: android/src/glm/mat2x3.hpp ================================================ /// @ref core /// @file glm/mat2x3.hpp #pragma once #include "./ext/matrix_double2x3.hpp" #include "./ext/matrix_double2x3_precision.hpp" #include "./ext/matrix_float2x3.hpp" #include "./ext/matrix_float2x3_precision.hpp" ================================================ FILE: android/src/glm/mat2x4.hpp ================================================ /// @ref core /// @file glm/mat2x4.hpp #pragma once #include "./ext/matrix_double2x4.hpp" #include "./ext/matrix_double2x4_precision.hpp" #include "./ext/matrix_float2x4.hpp" #include "./ext/matrix_float2x4_precision.hpp" ================================================ FILE: android/src/glm/mat3x2.hpp ================================================ /// @ref core /// @file glm/mat3x2.hpp #pragma once #include "./ext/matrix_double3x2.hpp" #include "./ext/matrix_double3x2_precision.hpp" #include "./ext/matrix_float3x2.hpp" #include "./ext/matrix_float3x2_precision.hpp" ================================================ FILE: android/src/glm/mat3x3.hpp ================================================ /// @ref core /// @file glm/mat3x3.hpp #pragma once #include "./ext/matrix_double3x3.hpp" #include "./ext/matrix_double3x3_precision.hpp" #include "./ext/matrix_float3x3.hpp" #include "./ext/matrix_float3x3_precision.hpp" ================================================ FILE: android/src/glm/mat3x4.hpp ================================================ /// @ref core /// @file glm/mat3x4.hpp #pragma once #include "./ext/matrix_double3x4.hpp" #include "./ext/matrix_double3x4_precision.hpp" #include "./ext/matrix_float3x4.hpp" #include "./ext/matrix_float3x4_precision.hpp" ================================================ FILE: android/src/glm/mat4x2.hpp ================================================ /// @ref core /// @file glm/mat4x2.hpp #pragma once #include "./ext/matrix_double4x2.hpp" #include "./ext/matrix_double4x2_precision.hpp" #include "./ext/matrix_float4x2.hpp" #include "./ext/matrix_float4x2_precision.hpp" ================================================ FILE: android/src/glm/mat4x3.hpp ================================================ /// @ref core /// @file glm/mat4x3.hpp #pragma once #include "./ext/matrix_double4x3.hpp" #include "./ext/matrix_double4x3_precision.hpp" #include "./ext/matrix_float4x3.hpp" #include "./ext/matrix_float4x3_precision.hpp" ================================================ FILE: android/src/glm/mat4x4.hpp ================================================ /// @ref core /// @file glm/mat4x4.hpp #pragma once #include "./ext/matrix_double4x4.hpp" #include "./ext/matrix_double4x4_precision.hpp" #include "./ext/matrix_float4x4.hpp" #include "./ext/matrix_float4x4_precision.hpp" ================================================ FILE: android/src/glm/matrix.hpp ================================================ /// @ref core /// @file glm/matrix.hpp /// /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions /// /// @defgroup core_func_matrix Matrix functions /// @ingroup core /// /// Provides GLSL matrix functions. /// /// Include to use these core features. #pragma once // Dependencies #include "detail/qualifier.hpp" #include "detail/setup.hpp" #include "vec2.hpp" #include "vec3.hpp" #include "vec4.hpp" #include "mat2x2.hpp" #include "mat2x3.hpp" #include "mat2x4.hpp" #include "mat3x2.hpp" #include "mat3x3.hpp" #include "mat3x4.hpp" #include "mat4x2.hpp" #include "mat4x3.hpp" #include "mat4x4.hpp" namespace glm { namespace detail { template struct outerProduct_trait{}; template struct outerProduct_trait<2, 2, T, Q> { typedef mat<2, 2, T, Q> type; }; template struct outerProduct_trait<2, 3, T, Q> { typedef mat<3, 2, T, Q> type; }; template struct outerProduct_trait<2, 4, T, Q> { typedef mat<4, 2, T, Q> type; }; template struct outerProduct_trait<3, 2, T, Q> { typedef mat<2, 3, T, Q> type; }; template struct outerProduct_trait<3, 3, T, Q> { typedef mat<3, 3, T, Q> type; }; template struct outerProduct_trait<3, 4, T, Q> { typedef mat<4, 3, T, Q> type; }; template struct outerProduct_trait<4, 2, T, Q> { typedef mat<2, 4, T, Q> type; }; template struct outerProduct_trait<4, 3, T, Q> { typedef mat<3, 4, T, Q> type; }; template struct outerProduct_trait<4, 4, T, Q> { typedef mat<4, 4, T, Q> type; }; }//namespace detail /// @addtogroup core_func_matrix /// @{ /// Multiply matrix x by matrix y component-wise, i.e., /// result[i][j] is the scalar product of x[i][j] and y[i][j]. /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL matrixCompMult man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL mat matrixCompMult(mat const& x, mat const& y); /// Treats the first parameter c as a column vector /// and the second parameter r as a row vector /// and does a linear algebraic matrix multiply c * r. /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL outerProduct man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL typename detail::outerProduct_trait::type outerProduct(vec const& c, vec const& r); /// Returns the transposed matrix of x /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL transpose man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL typename mat::transpose_type transpose(mat const& x); /// Return the determinant of a squared matrix. /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL determinant man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL T determinant(mat const& m); /// Return the inverse of a squared matrix. /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL inverse man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL mat inverse(mat const& m); /// @} }//namespace glm #include "detail/func_matrix.inl" ================================================ FILE: android/src/glm/packing.hpp ================================================ /// @ref core /// @file glm/packing.hpp /// /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions /// @see gtc_packing /// /// @defgroup core_func_packing Floating-Point Pack and Unpack Functions /// @ingroup core /// /// Provides GLSL functions to pack and unpack half, single and double-precision floating point values into more compact integer types. /// /// These functions do not operate component-wise, rather as described in each case. /// /// Include to use these core features. #pragma once #include "./ext/vector_uint2.hpp" #include "./ext/vector_float2.hpp" #include "./ext/vector_float4.hpp" namespace glm { /// @addtogroup core_func_packing /// @{ /// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm2x16: round(clamp(c, 0, +1) * 65535.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see GLSL packUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packUnorm2x16(vec2 const& v); /// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm2x16: round(clamp(v, -1, +1) * 32767.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see GLSL packSnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packSnorm2x16(vec2 const& v); /// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm4x8: round(clamp(c, 0, +1) * 255.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packUnorm4x8(vec4 const& v); /// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm4x8: round(clamp(c, -1, +1) * 127.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packSnorm4x8(vec4 const& v); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm2x16: f / 65535.0 /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see GLSL unpackUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackUnorm2x16(uint p); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm2x16: clamp(f / 32767.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see GLSL unpackSnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackSnorm2x16(uint p); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm4x8: f / 255.0 /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see GLSL unpackUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackUnorm4x8(uint p); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm4x8: clamp(f / 127.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackSnorm4x8(uint p); /// Returns a double-qualifier value obtained by packing the components of v into a 64-bit value. /// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. /// Otherwise, the bit- level representation of v is preserved. /// The first vector component specifies the 32 least significant bits; /// the second component specifies the 32 most significant bits. /// /// @see GLSL packDouble2x32 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL double packDouble2x32(uvec2 const& v); /// Returns a two-component unsigned integer vector representation of v. /// The bit-level representation of v is preserved. /// The first component of the vector contains the 32 least significant bits of the double; /// the second component consists the 32 most significant bits. /// /// @see GLSL unpackDouble2x32 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uvec2 unpackDouble2x32(double v); /// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector /// to the 16-bit floating-point representation found in the OpenGL Specification, /// and then packing these two 16- bit integers into a 32-bit unsigned integer. /// The first vector component specifies the 16 least-significant bits of the result; /// the second component specifies the 16 most-significant bits. /// /// @see GLSL packHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packHalf2x16(vec2 const& v); /// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, /// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, /// and converting them to 32-bit floating-point values. /// The first component of the vector is obtained from the 16 least-significant bits of v; /// the second component is obtained from the 16 most-significant bits of v. /// /// @see GLSL unpackHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackHalf2x16(uint v); /// @} }//namespace glm #include "detail/func_packing.inl" ================================================ FILE: android/src/glm/simd/common.h ================================================ /// @ref simd /// @file glm/simd/common.h #pragma once #include "platform.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_add(glm_f32vec4 a, glm_f32vec4 b) { return _mm_add_ps(a, b); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_add(glm_f32vec4 a, glm_f32vec4 b) { return _mm_add_ss(a, b); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sub(glm_f32vec4 a, glm_f32vec4 b) { return _mm_sub_ps(a, b); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sub(glm_f32vec4 a, glm_f32vec4 b) { return _mm_sub_ss(a, b); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_mul(glm_f32vec4 a, glm_f32vec4 b) { return _mm_mul_ps(a, b); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_mul(glm_f32vec4 a, glm_f32vec4 b) { return _mm_mul_ss(a, b); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_div(glm_f32vec4 a, glm_f32vec4 b) { return _mm_div_ps(a, b); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_div(glm_f32vec4 a, glm_f32vec4 b) { return _mm_div_ss(a, b); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_div_lowp(glm_f32vec4 a, glm_f32vec4 b) { return glm_vec4_mul(a, _mm_rcp_ps(b)); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_swizzle_xyzw(glm_f32vec4 a) { # if GLM_ARCH & GLM_ARCH_AVX2_BIT return _mm_permute_ps(a, _MM_SHUFFLE(3, 2, 1, 0)); # else return _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 2, 1, 0)); # endif } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_fma(glm_f32vec4 a, glm_f32vec4 b, glm_f32vec4 c) { # if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && !(GLM_COMPILER & GLM_COMPILER_CLANG) return _mm_fmadd_ss(a, b, c); # else return _mm_add_ss(_mm_mul_ss(a, b), c); # endif } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_fma(glm_f32vec4 a, glm_f32vec4 b, glm_f32vec4 c) { # if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && !(GLM_COMPILER & GLM_COMPILER_CLANG) return _mm_fmadd_ps(a, b, c); # else return glm_vec4_add(glm_vec4_mul(a, b), c); # endif } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_abs(glm_f32vec4 x) { return _mm_and_ps(x, _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF))); } GLM_FUNC_QUALIFIER glm_ivec4 glm_ivec4_abs(glm_ivec4 x) { # if GLM_ARCH & GLM_ARCH_SSSE3_BIT return _mm_sign_epi32(x, x); # else glm_ivec4 const sgn0 = _mm_srai_epi32(x, 31); glm_ivec4 const inv0 = _mm_xor_si128(x, sgn0); glm_ivec4 const sub0 = _mm_sub_epi32(inv0, sgn0); return sub0; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sign(glm_vec4 x) { glm_vec4 const zro0 = _mm_setzero_ps(); glm_vec4 const cmp0 = _mm_cmplt_ps(x, zro0); glm_vec4 const cmp1 = _mm_cmpgt_ps(x, zro0); glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(-1.0f)); glm_vec4 const and1 = _mm_and_ps(cmp1, _mm_set1_ps(1.0f)); glm_vec4 const or0 = _mm_or_ps(and0, and1); return or0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_round(glm_vec4 x) { # if GLM_ARCH & GLM_ARCH_SSE41_BIT return _mm_round_ps(x, _MM_FROUND_TO_NEAREST_INT); # else glm_vec4 const sgn0 = _mm_castsi128_ps(_mm_set1_epi32(int(0x80000000))); glm_vec4 const and0 = _mm_and_ps(sgn0, x); glm_vec4 const or0 = _mm_or_ps(and0, _mm_set_ps1(8388608.0f)); glm_vec4 const add0 = glm_vec4_add(x, or0); glm_vec4 const sub0 = glm_vec4_sub(add0, or0); return sub0; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_floor(glm_vec4 x) { # if GLM_ARCH & GLM_ARCH_SSE41_BIT return _mm_floor_ps(x); # else glm_vec4 const rnd0 = glm_vec4_round(x); glm_vec4 const cmp0 = _mm_cmplt_ps(x, rnd0); glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f)); glm_vec4 const sub0 = glm_vec4_sub(rnd0, and0); return sub0; # endif } /* trunc TODO GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_trunc(glm_vec4 x) { return glm_vec4(); } */ //roundEven GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_roundEven(glm_vec4 x) { glm_vec4 const sgn0 = _mm_castsi128_ps(_mm_set1_epi32(int(0x80000000))); glm_vec4 const and0 = _mm_and_ps(sgn0, x); glm_vec4 const or0 = _mm_or_ps(and0, _mm_set_ps1(8388608.0f)); glm_vec4 const add0 = glm_vec4_add(x, or0); glm_vec4 const sub0 = glm_vec4_sub(add0, or0); return sub0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_ceil(glm_vec4 x) { # if GLM_ARCH & GLM_ARCH_SSE41_BIT return _mm_ceil_ps(x); # else glm_vec4 const rnd0 = glm_vec4_round(x); glm_vec4 const cmp0 = _mm_cmpgt_ps(x, rnd0); glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f)); glm_vec4 const add0 = glm_vec4_add(rnd0, and0); return add0; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_fract(glm_vec4 x) { glm_vec4 const flr0 = glm_vec4_floor(x); glm_vec4 const sub0 = glm_vec4_sub(x, flr0); return sub0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mod(glm_vec4 x, glm_vec4 y) { glm_vec4 const div0 = glm_vec4_div(x, y); glm_vec4 const flr0 = glm_vec4_floor(div0); glm_vec4 const mul0 = glm_vec4_mul(y, flr0); glm_vec4 const sub0 = glm_vec4_sub(x, mul0); return sub0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_clamp(glm_vec4 v, glm_vec4 minVal, glm_vec4 maxVal) { glm_vec4 const min0 = _mm_min_ps(v, maxVal); glm_vec4 const max0 = _mm_max_ps(min0, minVal); return max0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mix(glm_vec4 v1, glm_vec4 v2, glm_vec4 a) { glm_vec4 const sub0 = glm_vec4_sub(_mm_set1_ps(1.0f), a); glm_vec4 const mul0 = glm_vec4_mul(v1, sub0); glm_vec4 const mad0 = glm_vec4_fma(v2, a, mul0); return mad0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_step(glm_vec4 edge, glm_vec4 x) { glm_vec4 const cmp = _mm_cmple_ps(x, edge); return _mm_movemask_ps(cmp) == 0 ? _mm_set1_ps(1.0f) : _mm_setzero_ps(); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_smoothstep(glm_vec4 edge0, glm_vec4 edge1, glm_vec4 x) { glm_vec4 const sub0 = glm_vec4_sub(x, edge0); glm_vec4 const sub1 = glm_vec4_sub(edge1, edge0); glm_vec4 const div0 = glm_vec4_sub(sub0, sub1); glm_vec4 const clp0 = glm_vec4_clamp(div0, _mm_setzero_ps(), _mm_set1_ps(1.0f)); glm_vec4 const mul0 = glm_vec4_mul(_mm_set1_ps(2.0f), clp0); glm_vec4 const sub2 = glm_vec4_sub(_mm_set1_ps(3.0f), mul0); glm_vec4 const mul1 = glm_vec4_mul(clp0, clp0); glm_vec4 const mul2 = glm_vec4_mul(mul1, sub2); return mul2; } // Agner Fog method GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_nan(glm_vec4 x) { glm_ivec4 const t1 = _mm_castps_si128(x); // reinterpret as 32-bit integer glm_ivec4 const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1)); // shift out sign bit glm_ivec4 const t3 = _mm_set1_epi32(int(0xFF000000)); // exponent mask glm_ivec4 const t4 = _mm_and_si128(t2, t3); // exponent glm_ivec4 const t5 = _mm_andnot_si128(t3, t2); // fraction glm_ivec4 const Equal = _mm_cmpeq_epi32(t3, t4); glm_ivec4 const Nequal = _mm_cmpeq_epi32(t5, _mm_setzero_si128()); glm_ivec4 const And = _mm_and_si128(Equal, Nequal); return _mm_castsi128_ps(And); // exponent = all 1s and fraction != 0 } // Agner Fog method GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_inf(glm_vec4 x) { glm_ivec4 const t1 = _mm_castps_si128(x); // reinterpret as 32-bit integer glm_ivec4 const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1)); // shift out sign bit return _mm_castsi128_ps(_mm_cmpeq_epi32(t2, _mm_set1_epi32(int(0xFF000000)))); // exponent is all 1s, fraction is 0 } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/simd/exponential.h ================================================ /// @ref simd /// @file glm/simd/experimental.h #pragma once #include "platform.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sqrt_lowp(glm_f32vec4 x) { return _mm_mul_ss(_mm_rsqrt_ss(x), x); } GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sqrt_lowp(glm_f32vec4 x) { return _mm_mul_ps(_mm_rsqrt_ps(x), x); } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/simd/geometric.h ================================================ /// @ref simd /// @file glm/simd/geometric.h #pragma once #include "common.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_DECL glm_vec4 glm_vec4_dot(glm_vec4 v1, glm_vec4 v2); GLM_FUNC_DECL glm_vec4 glm_vec1_dot(glm_vec4 v1, glm_vec4 v2); GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_length(glm_vec4 x) { glm_vec4 const dot0 = glm_vec4_dot(x, x); glm_vec4 const sqt0 = _mm_sqrt_ps(dot0); return sqt0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_distance(glm_vec4 p0, glm_vec4 p1) { glm_vec4 const sub0 = _mm_sub_ps(p0, p1); glm_vec4 const len0 = glm_vec4_length(sub0); return len0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_dot(glm_vec4 v1, glm_vec4 v2) { # if GLM_ARCH & GLM_ARCH_AVX_BIT return _mm_dp_ps(v1, v2, 0xff); # elif GLM_ARCH & GLM_ARCH_SSE3_BIT glm_vec4 const mul0 = _mm_mul_ps(v1, v2); glm_vec4 const hadd0 = _mm_hadd_ps(mul0, mul0); glm_vec4 const hadd1 = _mm_hadd_ps(hadd0, hadd0); return hadd1; # else glm_vec4 const mul0 = _mm_mul_ps(v1, v2); glm_vec4 const swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1)); glm_vec4 const add0 = _mm_add_ps(mul0, swp0); glm_vec4 const swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3)); glm_vec4 const add1 = _mm_add_ps(add0, swp1); return add1; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_dot(glm_vec4 v1, glm_vec4 v2) { # if GLM_ARCH & GLM_ARCH_AVX_BIT return _mm_dp_ps(v1, v2, 0xff); # elif GLM_ARCH & GLM_ARCH_SSE3_BIT glm_vec4 const mul0 = _mm_mul_ps(v1, v2); glm_vec4 const had0 = _mm_hadd_ps(mul0, mul0); glm_vec4 const had1 = _mm_hadd_ps(had0, had0); return had1; # else glm_vec4 const mul0 = _mm_mul_ps(v1, v2); glm_vec4 const mov0 = _mm_movehl_ps(mul0, mul0); glm_vec4 const add0 = _mm_add_ps(mov0, mul0); glm_vec4 const swp1 = _mm_shuffle_ps(add0, add0, 1); glm_vec4 const add1 = _mm_add_ss(add0, swp1); return add1; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_cross(glm_vec4 v1, glm_vec4 v2) { glm_vec4 const swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1)); glm_vec4 const swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2)); glm_vec4 const swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1)); glm_vec4 const swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2)); glm_vec4 const mul0 = _mm_mul_ps(swp0, swp3); glm_vec4 const mul1 = _mm_mul_ps(swp1, swp2); glm_vec4 const sub0 = _mm_sub_ps(mul0, mul1); return sub0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_normalize(glm_vec4 v) { glm_vec4 const dot0 = glm_vec4_dot(v, v); glm_vec4 const isr0 = _mm_rsqrt_ps(dot0); glm_vec4 const mul0 = _mm_mul_ps(v, isr0); return mul0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_faceforward(glm_vec4 N, glm_vec4 I, glm_vec4 Nref) { glm_vec4 const dot0 = glm_vec4_dot(Nref, I); glm_vec4 const sgn0 = glm_vec4_sign(dot0); glm_vec4 const mul0 = _mm_mul_ps(sgn0, _mm_set1_ps(-1.0f)); glm_vec4 const mul1 = _mm_mul_ps(N, mul0); return mul1; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_reflect(glm_vec4 I, glm_vec4 N) { glm_vec4 const dot0 = glm_vec4_dot(N, I); glm_vec4 const mul0 = _mm_mul_ps(N, dot0); glm_vec4 const mul1 = _mm_mul_ps(mul0, _mm_set1_ps(2.0f)); glm_vec4 const sub0 = _mm_sub_ps(I, mul1); return sub0; } GLM_FUNC_QUALIFIER __m128 glm_vec4_refract(glm_vec4 I, glm_vec4 N, glm_vec4 eta) { glm_vec4 const dot0 = glm_vec4_dot(N, I); glm_vec4 const mul0 = _mm_mul_ps(eta, eta); glm_vec4 const mul1 = _mm_mul_ps(dot0, dot0); glm_vec4 const sub0 = _mm_sub_ps(_mm_set1_ps(1.0f), mul0); glm_vec4 const sub1 = _mm_sub_ps(_mm_set1_ps(1.0f), mul1); glm_vec4 const mul2 = _mm_mul_ps(sub0, sub1); if(_mm_movemask_ps(_mm_cmplt_ss(mul2, _mm_set1_ps(0.0f))) == 0) return _mm_set1_ps(0.0f); glm_vec4 const sqt0 = _mm_sqrt_ps(mul2); glm_vec4 const mad0 = glm_vec4_fma(eta, dot0, sqt0); glm_vec4 const mul4 = _mm_mul_ps(mad0, N); glm_vec4 const mul5 = _mm_mul_ps(eta, I); glm_vec4 const sub2 = _mm_sub_ps(mul5, mul4); return sub2; } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/simd/integer.h ================================================ /// @ref simd /// @file glm/simd/integer.h #pragma once #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave(glm_uvec4 x) { glm_uvec4 const Mask4 = _mm_set1_epi32(0x0000FFFF); glm_uvec4 const Mask3 = _mm_set1_epi32(0x00FF00FF); glm_uvec4 const Mask2 = _mm_set1_epi32(0x0F0F0F0F); glm_uvec4 const Mask1 = _mm_set1_epi32(0x33333333); glm_uvec4 const Mask0 = _mm_set1_epi32(0x55555555); glm_uvec4 Reg1; glm_uvec4 Reg2; // REG1 = x; // REG2 = y; //Reg1 = _mm_unpacklo_epi64(x, y); Reg1 = x; //REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF); //REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF); Reg2 = _mm_slli_si128(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask4); //REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF); //REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF); Reg2 = _mm_slli_si128(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask3); //REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F); //REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F); Reg2 = _mm_slli_epi32(Reg1, 4); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask2); //REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333); //REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333); Reg2 = _mm_slli_epi32(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask1); //REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555); //REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555); Reg2 = _mm_slli_epi32(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask0); //return REG1 | (REG2 << 1); Reg2 = _mm_slli_epi32(Reg1, 1); Reg2 = _mm_srli_si128(Reg2, 8); Reg1 = _mm_or_si128(Reg1, Reg2); return Reg1; } GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave2(glm_uvec4 x, glm_uvec4 y) { glm_uvec4 const Mask4 = _mm_set1_epi32(0x0000FFFF); glm_uvec4 const Mask3 = _mm_set1_epi32(0x00FF00FF); glm_uvec4 const Mask2 = _mm_set1_epi32(0x0F0F0F0F); glm_uvec4 const Mask1 = _mm_set1_epi32(0x33333333); glm_uvec4 const Mask0 = _mm_set1_epi32(0x55555555); glm_uvec4 Reg1; glm_uvec4 Reg2; // REG1 = x; // REG2 = y; Reg1 = _mm_unpacklo_epi64(x, y); //REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF); //REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF); Reg2 = _mm_slli_si128(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask4); //REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF); //REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF); Reg2 = _mm_slli_si128(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask3); //REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F); //REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F); Reg2 = _mm_slli_epi32(Reg1, 4); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask2); //REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333); //REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333); Reg2 = _mm_slli_epi32(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask1); //REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555); //REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555); Reg2 = _mm_slli_epi32(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask0); //return REG1 | (REG2 << 1); Reg2 = _mm_slli_epi32(Reg1, 1); Reg2 = _mm_srli_si128(Reg2, 8); Reg1 = _mm_or_si128(Reg1, Reg2); return Reg1; } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/simd/matrix.h ================================================ /// @ref simd /// @file glm/simd/matrix.h #pragma once #include "geometric.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_QUALIFIER void glm_mat4_matrixCompMult(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4]) { out[0] = _mm_mul_ps(in1[0], in2[0]); out[1] = _mm_mul_ps(in1[1], in2[1]); out[2] = _mm_mul_ps(in1[2], in2[2]); out[3] = _mm_mul_ps(in1[3], in2[3]); } GLM_FUNC_QUALIFIER void glm_mat4_add(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4]) { out[0] = _mm_add_ps(in1[0], in2[0]); out[1] = _mm_add_ps(in1[1], in2[1]); out[2] = _mm_add_ps(in1[2], in2[2]); out[3] = _mm_add_ps(in1[3], in2[3]); } GLM_FUNC_QUALIFIER void glm_mat4_sub(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4]) { out[0] = _mm_sub_ps(in1[0], in2[0]); out[1] = _mm_sub_ps(in1[1], in2[1]); out[2] = _mm_sub_ps(in1[2], in2[2]); out[3] = _mm_sub_ps(in1[3], in2[3]); } GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_mul_vec4(glm_vec4 const m[4], glm_vec4 v) { __m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0)); __m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1)); __m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2)); __m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(m[0], v0); __m128 m1 = _mm_mul_ps(m[1], v1); __m128 m2 = _mm_mul_ps(m[2], v2); __m128 m3 = _mm_mul_ps(m[3], v3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); return a2; } GLM_FUNC_QUALIFIER __m128 glm_vec4_mul_mat4(glm_vec4 v, glm_vec4 const m[4]) { __m128 i0 = m[0]; __m128 i1 = m[1]; __m128 i2 = m[2]; __m128 i3 = m[3]; __m128 m0 = _mm_mul_ps(v, i0); __m128 m1 = _mm_mul_ps(v, i1); __m128 m2 = _mm_mul_ps(v, i2); __m128 m3 = _mm_mul_ps(v, i3); __m128 u0 = _mm_unpacklo_ps(m0, m1); __m128 u1 = _mm_unpackhi_ps(m0, m1); __m128 a0 = _mm_add_ps(u0, u1); __m128 u2 = _mm_unpacklo_ps(m2, m3); __m128 u3 = _mm_unpackhi_ps(m2, m3); __m128 a1 = _mm_add_ps(u2, u3); __m128 f0 = _mm_movelh_ps(a0, a1); __m128 f1 = _mm_movehl_ps(a1, a0); __m128 f2 = _mm_add_ps(f0, f1); return f2; } GLM_FUNC_QUALIFIER void glm_mat4_mul(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4]) { { __m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0)); __m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1)); __m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2)); __m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(in1[0], e0); __m128 m1 = _mm_mul_ps(in1[1], e1); __m128 m2 = _mm_mul_ps(in1[2], e2); __m128 m3 = _mm_mul_ps(in1[3], e3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); out[0] = a2; } { __m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(in1[0], e0); __m128 m1 = _mm_mul_ps(in1[1], e1); __m128 m2 = _mm_mul_ps(in1[2], e2); __m128 m3 = _mm_mul_ps(in1[3], e3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); out[1] = a2; } { __m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(in1[0], e0); __m128 m1 = _mm_mul_ps(in1[1], e1); __m128 m2 = _mm_mul_ps(in1[2], e2); __m128 m3 = _mm_mul_ps(in1[3], e3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); out[2] = a2; } { //(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3)) __m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0)); __m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1)); __m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2)); __m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(in1[0], e0); __m128 m1 = _mm_mul_ps(in1[1], e1); __m128 m2 = _mm_mul_ps(in1[2], e2); __m128 m3 = _mm_mul_ps(in1[3], e3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); out[3] = a2; } } GLM_FUNC_QUALIFIER void glm_mat4_transpose(glm_vec4 const in[4], glm_vec4 out[4]) { __m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44); __m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE); __m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44); __m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE); out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88); out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD); out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88); out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD); } GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_highp(glm_vec4 const in[4]) { __m128 Fac0; { // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; // valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac0 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac1; { // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; // valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac1 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac2; { // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; // valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac2 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac3; { // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; // valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac3 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac4; { // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; // valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac4 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac5; { // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; // valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac5 = _mm_sub_ps(Mul00, Mul01); } __m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f); __m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f); // m[1][0] // m[0][0] // m[0][0] // m[0][0] __m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][1] // m[0][1] // m[0][1] // m[0][1] __m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][2] // m[0][2] // m[0][2] // m[0][2] __m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][3] // m[0][3] // m[0][3] // m[0][3] __m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0)); // col0 // + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]), // - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]), // + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]), // - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]), __m128 Mul00 = _mm_mul_ps(Vec1, Fac0); __m128 Mul01 = _mm_mul_ps(Vec2, Fac1); __m128 Mul02 = _mm_mul_ps(Vec3, Fac2); __m128 Sub00 = _mm_sub_ps(Mul00, Mul01); __m128 Add00 = _mm_add_ps(Sub00, Mul02); __m128 Inv0 = _mm_mul_ps(SignB, Add00); // col1 // - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]), // + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]), // - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]), // + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]), __m128 Mul03 = _mm_mul_ps(Vec0, Fac0); __m128 Mul04 = _mm_mul_ps(Vec2, Fac3); __m128 Mul05 = _mm_mul_ps(Vec3, Fac4); __m128 Sub01 = _mm_sub_ps(Mul03, Mul04); __m128 Add01 = _mm_add_ps(Sub01, Mul05); __m128 Inv1 = _mm_mul_ps(SignA, Add01); // col2 // + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]), // - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]), // + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]), // - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]), __m128 Mul06 = _mm_mul_ps(Vec0, Fac1); __m128 Mul07 = _mm_mul_ps(Vec1, Fac3); __m128 Mul08 = _mm_mul_ps(Vec3, Fac5); __m128 Sub02 = _mm_sub_ps(Mul06, Mul07); __m128 Add02 = _mm_add_ps(Sub02, Mul08); __m128 Inv2 = _mm_mul_ps(SignB, Add02); // col3 // - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]), // + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]), // - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]), // + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3])); __m128 Mul09 = _mm_mul_ps(Vec0, Fac2); __m128 Mul10 = _mm_mul_ps(Vec1, Fac4); __m128 Mul11 = _mm_mul_ps(Vec2, Fac5); __m128 Sub03 = _mm_sub_ps(Mul09, Mul10); __m128 Add03 = _mm_add_ps(Sub03, Mul11); __m128 Inv3 = _mm_mul_ps(SignA, Add03); __m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0)); // valType Determinant = m[0][0] * Inverse[0][0] // + m[0][1] * Inverse[1][0] // + m[0][2] * Inverse[2][0] // + m[0][3] * Inverse[3][0]; __m128 Det0 = glm_vec4_dot(in[0], Row2); return Det0; } GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_lowp(glm_vec4 const m[4]) { // _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128( //T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; //T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; //T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; //T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; //T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; //T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // First 2 columns __m128 Swp2A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 1, 1, 2))); __m128 Swp3A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(3, 2, 3, 3))); __m128 MulA = _mm_mul_ps(Swp2A, Swp3A); // Second 2 columns __m128 Swp2B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(3, 2, 3, 3))); __m128 Swp3B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(0, 1, 1, 2))); __m128 MulB = _mm_mul_ps(Swp2B, Swp3B); // Columns subtraction __m128 SubE = _mm_sub_ps(MulA, MulB); // Last 2 rows __m128 Swp2C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 0, 1, 2))); __m128 Swp3C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(1, 2, 0, 0))); __m128 MulC = _mm_mul_ps(Swp2C, Swp3C); __m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC); //vec<4, T, Q> DetCof( // + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02), // - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04), // + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05), // - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05)); __m128 SubFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubE), _MM_SHUFFLE(2, 1, 0, 0))); __m128 SwpFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(0, 0, 0, 1))); __m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA); __m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1)); __m128 SubFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpB), _MM_SHUFFLE(3, 1, 1, 0)));//SubF[0], SubE[3], SubE[3], SubE[1]; __m128 SwpFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(1, 1, 2, 2))); __m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB); __m128 SubRes = _mm_sub_ps(MulFacA, MulFacB); __m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2)); __m128 SubFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpC), _MM_SHUFFLE(3, 3, 2, 0))); __m128 SwpFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(2, 3, 3, 3))); __m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC); __m128 AddRes = _mm_add_ps(SubRes, MulFacC); __m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f)); //return m[0][0] * DetCof[0] // + m[0][1] * DetCof[1] // + m[0][2] * DetCof[2] // + m[0][3] * DetCof[3]; return glm_vec4_dot(m[0], DetCof); } GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant(glm_vec4 const m[4]) { // _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(add) //T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; //T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; //T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; //T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; //T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; //T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // First 2 columns __m128 Swp2A = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 1, 1, 2)); __m128 Swp3A = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(3, 2, 3, 3)); __m128 MulA = _mm_mul_ps(Swp2A, Swp3A); // Second 2 columns __m128 Swp2B = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(3, 2, 3, 3)); __m128 Swp3B = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(0, 1, 1, 2)); __m128 MulB = _mm_mul_ps(Swp2B, Swp3B); // Columns subtraction __m128 SubE = _mm_sub_ps(MulA, MulB); // Last 2 rows __m128 Swp2C = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 0, 1, 2)); __m128 Swp3C = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(1, 2, 0, 0)); __m128 MulC = _mm_mul_ps(Swp2C, Swp3C); __m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC); //vec<4, T, Q> DetCof( // + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02), // - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04), // + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05), // - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05)); __m128 SubFacA = _mm_shuffle_ps(SubE, SubE, _MM_SHUFFLE(2, 1, 0, 0)); __m128 SwpFacA = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(0, 0, 0, 1)); __m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA); __m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1)); __m128 SubFacB = _mm_shuffle_ps(SubTmpB, SubTmpB, _MM_SHUFFLE(3, 1, 1, 0));//SubF[0], SubE[3], SubE[3], SubE[1]; __m128 SwpFacB = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(1, 1, 2, 2)); __m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB); __m128 SubRes = _mm_sub_ps(MulFacA, MulFacB); __m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2)); __m128 SubFacC = _mm_shuffle_ps(SubTmpC, SubTmpC, _MM_SHUFFLE(3, 3, 2, 0)); __m128 SwpFacC = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(2, 3, 3, 3)); __m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC); __m128 AddRes = _mm_add_ps(SubRes, MulFacC); __m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f)); //return m[0][0] * DetCof[0] // + m[0][1] * DetCof[1] // + m[0][2] * DetCof[2] // + m[0][3] * DetCof[3]; return glm_vec4_dot(m[0], DetCof); } GLM_FUNC_QUALIFIER void glm_mat4_inverse(glm_vec4 const in[4], glm_vec4 out[4]) { __m128 Fac0; { // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; // valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac0 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac1; { // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; // valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac1 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac2; { // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; // valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac2 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac3; { // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; // valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac3 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac4; { // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; // valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac4 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac5; { // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; // valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac5 = _mm_sub_ps(Mul00, Mul01); } __m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f); __m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f); // m[1][0] // m[0][0] // m[0][0] // m[0][0] __m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][1] // m[0][1] // m[0][1] // m[0][1] __m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][2] // m[0][2] // m[0][2] // m[0][2] __m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][3] // m[0][3] // m[0][3] // m[0][3] __m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0)); // col0 // + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]), // - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]), // + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]), // - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]), __m128 Mul00 = _mm_mul_ps(Vec1, Fac0); __m128 Mul01 = _mm_mul_ps(Vec2, Fac1); __m128 Mul02 = _mm_mul_ps(Vec3, Fac2); __m128 Sub00 = _mm_sub_ps(Mul00, Mul01); __m128 Add00 = _mm_add_ps(Sub00, Mul02); __m128 Inv0 = _mm_mul_ps(SignB, Add00); // col1 // - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]), // + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]), // - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]), // + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]), __m128 Mul03 = _mm_mul_ps(Vec0, Fac0); __m128 Mul04 = _mm_mul_ps(Vec2, Fac3); __m128 Mul05 = _mm_mul_ps(Vec3, Fac4); __m128 Sub01 = _mm_sub_ps(Mul03, Mul04); __m128 Add01 = _mm_add_ps(Sub01, Mul05); __m128 Inv1 = _mm_mul_ps(SignA, Add01); // col2 // + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]), // - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]), // + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]), // - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]), __m128 Mul06 = _mm_mul_ps(Vec0, Fac1); __m128 Mul07 = _mm_mul_ps(Vec1, Fac3); __m128 Mul08 = _mm_mul_ps(Vec3, Fac5); __m128 Sub02 = _mm_sub_ps(Mul06, Mul07); __m128 Add02 = _mm_add_ps(Sub02, Mul08); __m128 Inv2 = _mm_mul_ps(SignB, Add02); // col3 // - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]), // + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]), // - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]), // + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3])); __m128 Mul09 = _mm_mul_ps(Vec0, Fac2); __m128 Mul10 = _mm_mul_ps(Vec1, Fac4); __m128 Mul11 = _mm_mul_ps(Vec2, Fac5); __m128 Sub03 = _mm_sub_ps(Mul09, Mul10); __m128 Add03 = _mm_add_ps(Sub03, Mul11); __m128 Inv3 = _mm_mul_ps(SignA, Add03); __m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0)); // valType Determinant = m[0][0] * Inverse[0][0] // + m[0][1] * Inverse[1][0] // + m[0][2] * Inverse[2][0] // + m[0][3] * Inverse[3][0]; __m128 Det0 = glm_vec4_dot(in[0], Row2); __m128 Rcp0 = _mm_div_ps(_mm_set1_ps(1.0f), Det0); //__m128 Rcp0 = _mm_rcp_ps(Det0); // Inverse /= Determinant; out[0] = _mm_mul_ps(Inv0, Rcp0); out[1] = _mm_mul_ps(Inv1, Rcp0); out[2] = _mm_mul_ps(Inv2, Rcp0); out[3] = _mm_mul_ps(Inv3, Rcp0); } GLM_FUNC_QUALIFIER void glm_mat4_inverse_lowp(glm_vec4 const in[4], glm_vec4 out[4]) { __m128 Fac0; { // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; // valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac0 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac1; { // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; // valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac1 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac2; { // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; // valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac2 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac3; { // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; // valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac3 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac4; { // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; // valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac4 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac5; { // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; // valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac5 = _mm_sub_ps(Mul00, Mul01); } __m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f); __m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f); // m[1][0] // m[0][0] // m[0][0] // m[0][0] __m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][1] // m[0][1] // m[0][1] // m[0][1] __m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][2] // m[0][2] // m[0][2] // m[0][2] __m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][3] // m[0][3] // m[0][3] // m[0][3] __m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0)); // col0 // + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]), // - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]), // + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]), // - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]), __m128 Mul00 = _mm_mul_ps(Vec1, Fac0); __m128 Mul01 = _mm_mul_ps(Vec2, Fac1); __m128 Mul02 = _mm_mul_ps(Vec3, Fac2); __m128 Sub00 = _mm_sub_ps(Mul00, Mul01); __m128 Add00 = _mm_add_ps(Sub00, Mul02); __m128 Inv0 = _mm_mul_ps(SignB, Add00); // col1 // - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]), // + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]), // - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]), // + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]), __m128 Mul03 = _mm_mul_ps(Vec0, Fac0); __m128 Mul04 = _mm_mul_ps(Vec2, Fac3); __m128 Mul05 = _mm_mul_ps(Vec3, Fac4); __m128 Sub01 = _mm_sub_ps(Mul03, Mul04); __m128 Add01 = _mm_add_ps(Sub01, Mul05); __m128 Inv1 = _mm_mul_ps(SignA, Add01); // col2 // + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]), // - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]), // + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]), // - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]), __m128 Mul06 = _mm_mul_ps(Vec0, Fac1); __m128 Mul07 = _mm_mul_ps(Vec1, Fac3); __m128 Mul08 = _mm_mul_ps(Vec3, Fac5); __m128 Sub02 = _mm_sub_ps(Mul06, Mul07); __m128 Add02 = _mm_add_ps(Sub02, Mul08); __m128 Inv2 = _mm_mul_ps(SignB, Add02); // col3 // - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]), // + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]), // - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]), // + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3])); __m128 Mul09 = _mm_mul_ps(Vec0, Fac2); __m128 Mul10 = _mm_mul_ps(Vec1, Fac4); __m128 Mul11 = _mm_mul_ps(Vec2, Fac5); __m128 Sub03 = _mm_sub_ps(Mul09, Mul10); __m128 Add03 = _mm_add_ps(Sub03, Mul11); __m128 Inv3 = _mm_mul_ps(SignA, Add03); __m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0)); // valType Determinant = m[0][0] * Inverse[0][0] // + m[0][1] * Inverse[1][0] // + m[0][2] * Inverse[2][0] // + m[0][3] * Inverse[3][0]; __m128 Det0 = glm_vec4_dot(in[0], Row2); __m128 Rcp0 = _mm_rcp_ps(Det0); //__m128 Rcp0 = _mm_div_ps(one, Det0); // Inverse /= Determinant; out[0] = _mm_mul_ps(Inv0, Rcp0); out[1] = _mm_mul_ps(Inv1, Rcp0); out[2] = _mm_mul_ps(Inv2, Rcp0); out[3] = _mm_mul_ps(Inv3, Rcp0); } /* GLM_FUNC_QUALIFIER void glm_mat4_rotate(__m128 const in[4], float Angle, float const v[3], __m128 out[4]) { float a = glm::radians(Angle); float c = cos(a); float s = sin(a); glm::vec4 AxisA(v[0], v[1], v[2], float(0)); __m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x); __m128 AxisC = detail::sse_nrm_ps(AxisB); __m128 Cos0 = _mm_set_ss(c); __m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Sin0 = _mm_set_ss(s); __m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0)); // vec<3, T, Q> temp = (valType(1) - c) * axis; __m128 Temp0 = _mm_sub_ps(one, CosA); __m128 Temp1 = _mm_mul_ps(Temp0, AxisC); //Rotate[0][0] = c + temp[0] * axis[0]; //Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; //Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; __m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0)); __m128 TmpA0 = _mm_mul_ps(Axis0, AxisC); __m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0)); __m128 TmpA1 = _mm_add_ps(CosA0, TmpA0); __m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f); __m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3)); __m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2); __m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3); //Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; //Rotate[1][1] = c + temp[1] * axis[1]; //Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; __m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1)); __m128 TmpB0 = _mm_mul_ps(Axis1, AxisC); __m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1)); __m128 TmpB1 = _mm_add_ps(CosA1, TmpB0); __m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f); __m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2)); __m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2); __m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3); //Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; //Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; //Rotate[2][2] = c + temp[2] * axis[2]; __m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2)); __m128 TmpC0 = _mm_mul_ps(Axis2, AxisC); __m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1)); __m128 TmpC1 = _mm_add_ps(CosA2, TmpC0); __m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f); __m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1)); __m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2); __m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3); __m128 Result[4]; Result[0] = TmpA4; Result[1] = TmpB4; Result[2] = TmpC4; Result[3] = _mm_set_ps(1, 0, 0, 0); //mat<4, 4, valType> Result; //Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; //Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; //Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; //Result[3] = m[3]; //return Result; sse_mul_ps(in, Result, out); } */ GLM_FUNC_QUALIFIER void glm_mat4_outerProduct(__m128 const& c, __m128 const& r, __m128 out[4]) { out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0))); out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1))); out[2] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(2, 2, 2, 2))); out[3] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(3, 3, 3, 3))); } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/simd/neon.h ================================================ /// @ref simd_neon /// @file glm/simd/neon.h #pragma once #if GLM_ARCH & GLM_ARCH_NEON_BIT #include namespace glm { namespace neon { static float32x4_t dupq_lane(float32x4_t vsrc, int lane) { switch(lane) { #if GLM_ARCH & GLM_ARCH_ARMV8_BIT case 0: return vdupq_laneq_f32(vsrc, 0); case 1: return vdupq_laneq_f32(vsrc, 1); case 2: return vdupq_laneq_f32(vsrc, 2); case 3: return vdupq_laneq_f32(vsrc, 3); #else case 0: return vdupq_n_f32(vgetq_lane_f32(vsrc, 0)); case 1: return vdupq_n_f32(vgetq_lane_f32(vsrc, 1)); case 2: return vdupq_n_f32(vgetq_lane_f32(vsrc, 2)); case 3: return vdupq_n_f32(vgetq_lane_f32(vsrc, 3)); #endif } assert(!"Unreachable code executed!"); return vdupq_n_f32(0.0f); } static float32x2_t dup_lane(float32x4_t vsrc, int lane) { switch(lane) { #if GLM_ARCH & GLM_ARCH_ARMV8_BIT case 0: return vdup_laneq_f32(vsrc, 0); case 1: return vdup_laneq_f32(vsrc, 1); case 2: return vdup_laneq_f32(vsrc, 2); case 3: return vdup_laneq_f32(vsrc, 3); #else case 0: return vdup_n_f32(vgetq_lane_f32(vsrc, 0)); case 1: return vdup_n_f32(vgetq_lane_f32(vsrc, 1)); case 2: return vdup_n_f32(vgetq_lane_f32(vsrc, 2)); case 3: return vdup_n_f32(vgetq_lane_f32(vsrc, 3)); #endif } assert(!"Unreachable code executed!"); return vdup_n_f32(0.0f); } static float32x4_t copy_lane(float32x4_t vdst, int dlane, float32x4_t vsrc, int slane) { #if GLM_ARCH & GLM_ARCH_ARMV8_BIT switch(dlane) { case 0: switch(slane) { case 0: return vcopyq_laneq_f32(vdst, 0, vsrc, 0); case 1: return vcopyq_laneq_f32(vdst, 0, vsrc, 1); case 2: return vcopyq_laneq_f32(vdst, 0, vsrc, 2); case 3: return vcopyq_laneq_f32(vdst, 0, vsrc, 3); } assert(!"Unreachable code executed!"); case 1: switch(slane) { case 0: return vcopyq_laneq_f32(vdst, 1, vsrc, 0); case 1: return vcopyq_laneq_f32(vdst, 1, vsrc, 1); case 2: return vcopyq_laneq_f32(vdst, 1, vsrc, 2); case 3: return vcopyq_laneq_f32(vdst, 1, vsrc, 3); } assert(!"Unreachable code executed!"); case 2: switch(slane) { case 0: return vcopyq_laneq_f32(vdst, 2, vsrc, 0); case 1: return vcopyq_laneq_f32(vdst, 2, vsrc, 1); case 2: return vcopyq_laneq_f32(vdst, 2, vsrc, 2); case 3: return vcopyq_laneq_f32(vdst, 2, vsrc, 3); } assert(!"Unreachable code executed!"); case 3: switch(slane) { case 0: return vcopyq_laneq_f32(vdst, 3, vsrc, 0); case 1: return vcopyq_laneq_f32(vdst, 3, vsrc, 1); case 2: return vcopyq_laneq_f32(vdst, 3, vsrc, 2); case 3: return vcopyq_laneq_f32(vdst, 3, vsrc, 3); } assert(!"Unreachable code executed!"); } #else float l; switch(slane) { case 0: l = vgetq_lane_f32(vsrc, 0); break; case 1: l = vgetq_lane_f32(vsrc, 1); break; case 2: l = vgetq_lane_f32(vsrc, 2); break; case 3: l = vgetq_lane_f32(vsrc, 3); break; default: assert(!"Unreachable code executed!"); } switch(dlane) { case 0: return vsetq_lane_f32(l, vdst, 0); case 1: return vsetq_lane_f32(l, vdst, 1); case 2: return vsetq_lane_f32(l, vdst, 2); case 3: return vsetq_lane_f32(l, vdst, 3); } #endif assert(!"Unreachable code executed!"); return vdupq_n_f32(0.0f); } static float32x4_t mul_lane(float32x4_t v, float32x4_t vlane, int lane) { #if GLM_ARCH & GLM_ARCH_ARMV8_BIT switch(lane) { case 0: return vmulq_laneq_f32(v, vlane, 0); break; case 1: return vmulq_laneq_f32(v, vlane, 1); break; case 2: return vmulq_laneq_f32(v, vlane, 2); break; case 3: return vmulq_laneq_f32(v, vlane, 3); break; default: assert(!"Unreachable code executed!"); } assert(!"Unreachable code executed!"); return vdupq_n_f32(0.0f); #else return vmulq_f32(v, dupq_lane(vlane, lane)); #endif } static float32x4_t madd_lane(float32x4_t acc, float32x4_t v, float32x4_t vlane, int lane) { #if GLM_ARCH & GLM_ARCH_ARMV8_BIT #ifdef GLM_CONFIG_FORCE_FMA # define FMADD_LANE(acc, x, y, L) do { asm volatile ("fmla %0.4s, %1.4s, %2.4s" : "+w"(acc) : "w"(x), "w"(dup_lane(y, L))); } while(0) #else # define FMADD_LANE(acc, x, y, L) do { acc = vmlaq_laneq_f32(acc, x, y, L); } while(0) #endif switch(lane) { case 0: FMADD_LANE(acc, v, vlane, 0); return acc; case 1: FMADD_LANE(acc, v, vlane, 1); return acc; case 2: FMADD_LANE(acc, v, vlane, 2); return acc; case 3: FMADD_LANE(acc, v, vlane, 3); return acc; default: assert(!"Unreachable code executed!"); } assert(!"Unreachable code executed!"); return vdupq_n_f32(0.0f); # undef FMADD_LANE #else return vaddq_f32(acc, vmulq_f32(v, dupq_lane(vlane, lane))); #endif } } //namespace neon } // namespace glm #endif // GLM_ARCH & GLM_ARCH_NEON_BIT ================================================ FILE: android/src/glm/simd/packing.h ================================================ /// @ref simd /// @file glm/simd/packing.h #pragma once #if GLM_ARCH & GLM_ARCH_SSE2_BIT #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/simd/platform.h ================================================ #pragma once /////////////////////////////////////////////////////////////////////////////////// // Platform #define GLM_PLATFORM_UNKNOWN 0x00000000 #define GLM_PLATFORM_WINDOWS 0x00010000 #define GLM_PLATFORM_LINUX 0x00020000 #define GLM_PLATFORM_APPLE 0x00040000 //#define GLM_PLATFORM_IOS 0x00080000 #define GLM_PLATFORM_ANDROID 0x00100000 #define GLM_PLATFORM_CHROME_NACL 0x00200000 #define GLM_PLATFORM_UNIX 0x00400000 #define GLM_PLATFORM_QNXNTO 0x00800000 #define GLM_PLATFORM_WINCE 0x01000000 #define GLM_PLATFORM_CYGWIN 0x02000000 #ifdef GLM_FORCE_PLATFORM_UNKNOWN # define GLM_PLATFORM GLM_PLATFORM_UNKNOWN #elif defined(__CYGWIN__) # define GLM_PLATFORM GLM_PLATFORM_CYGWIN #elif defined(__QNXNTO__) # define GLM_PLATFORM GLM_PLATFORM_QNXNTO #elif defined(__APPLE__) # define GLM_PLATFORM GLM_PLATFORM_APPLE #elif defined(WINCE) # define GLM_PLATFORM GLM_PLATFORM_WINCE #elif defined(_WIN32) # define GLM_PLATFORM GLM_PLATFORM_WINDOWS #elif defined(__native_client__) # define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL #elif defined(__ANDROID__) # define GLM_PLATFORM GLM_PLATFORM_ANDROID #elif defined(__linux) # define GLM_PLATFORM GLM_PLATFORM_LINUX #elif defined(__unix) # define GLM_PLATFORM GLM_PLATFORM_UNIX #else # define GLM_PLATFORM GLM_PLATFORM_UNKNOWN #endif// /////////////////////////////////////////////////////////////////////////////////// // Compiler #define GLM_COMPILER_UNKNOWN 0x00000000 // Intel #define GLM_COMPILER_INTEL 0x00100000 #define GLM_COMPILER_INTEL14 0x00100040 #define GLM_COMPILER_INTEL15 0x00100050 #define GLM_COMPILER_INTEL16 0x00100060 #define GLM_COMPILER_INTEL17 0x00100070 // Visual C++ defines #define GLM_COMPILER_VC 0x01000000 #define GLM_COMPILER_VC12 0x01000001 #define GLM_COMPILER_VC14 0x01000002 #define GLM_COMPILER_VC15 0x01000003 #define GLM_COMPILER_VC15_3 0x01000004 #define GLM_COMPILER_VC15_5 0x01000005 #define GLM_COMPILER_VC15_6 0x01000006 #define GLM_COMPILER_VC15_7 0x01000007 #define GLM_COMPILER_VC15_8 0x01000008 #define GLM_COMPILER_VC15_9 0x01000009 #define GLM_COMPILER_VC16 0x0100000A // GCC defines #define GLM_COMPILER_GCC 0x02000000 #define GLM_COMPILER_GCC46 0x020000D0 #define GLM_COMPILER_GCC47 0x020000E0 #define GLM_COMPILER_GCC48 0x020000F0 #define GLM_COMPILER_GCC49 0x02000100 #define GLM_COMPILER_GCC5 0x02000200 #define GLM_COMPILER_GCC6 0x02000300 #define GLM_COMPILER_GCC7 0x02000400 #define GLM_COMPILER_GCC8 0x02000500 // CUDA #define GLM_COMPILER_CUDA 0x10000000 #define GLM_COMPILER_CUDA75 0x10000001 #define GLM_COMPILER_CUDA80 0x10000002 #define GLM_COMPILER_CUDA90 0x10000004 // SYCL #define GLM_COMPILER_SYCL 0x00300000 // Clang #define GLM_COMPILER_CLANG 0x20000000 #define GLM_COMPILER_CLANG34 0x20000050 #define GLM_COMPILER_CLANG35 0x20000060 #define GLM_COMPILER_CLANG36 0x20000070 #define GLM_COMPILER_CLANG37 0x20000080 #define GLM_COMPILER_CLANG38 0x20000090 #define GLM_COMPILER_CLANG39 0x200000A0 #define GLM_COMPILER_CLANG40 0x200000B0 #define GLM_COMPILER_CLANG41 0x200000C0 #define GLM_COMPILER_CLANG42 0x200000D0 // Build model #define GLM_MODEL_32 0x00000010 #define GLM_MODEL_64 0x00000020 // Force generic C++ compiler #ifdef GLM_FORCE_COMPILER_UNKNOWN # define GLM_COMPILER GLM_COMPILER_UNKNOWN #elif defined(__INTEL_COMPILER) # if __INTEL_COMPILER >= 1700 # define GLM_COMPILER GLM_COMPILER_INTEL17 # elif __INTEL_COMPILER >= 1600 # define GLM_COMPILER GLM_COMPILER_INTEL16 # elif __INTEL_COMPILER >= 1500 # define GLM_COMPILER GLM_COMPILER_INTEL15 # elif __INTEL_COMPILER >= 1400 # define GLM_COMPILER GLM_COMPILER_INTEL14 # elif __INTEL_COMPILER < 1400 # error "GLM requires ICC 2013 SP1 or newer" # endif // CUDA #elif defined(__CUDACC__) # if !defined(CUDA_VERSION) && !defined(GLM_FORCE_CUDA) # include // make sure version is defined since nvcc does not define it itself! # endif # if CUDA_VERSION >= 8000 # define GLM_COMPILER GLM_COMPILER_CUDA80 # elif CUDA_VERSION >= 7500 # define GLM_COMPILER GLM_COMPILER_CUDA75 # elif CUDA_VERSION >= 7000 # define GLM_COMPILER GLM_COMPILER_CUDA70 # elif CUDA_VERSION < 7000 # error "GLM requires CUDA 7.0 or higher" # endif // SYCL #elif defined(__SYCL_DEVICE_ONLY__) # define GLM_COMPILER GLM_COMPILER_SYCL // Clang #elif defined(__clang__) # if defined(__apple_build_version__) # if (__clang_major__ < 6) # error "GLM requires Clang 3.4 / Apple Clang 6.0 or higher" # elif __clang_major__ == 6 && __clang_minor__ == 0 # define GLM_COMPILER GLM_COMPILER_CLANG35 # elif __clang_major__ == 6 && __clang_minor__ >= 1 # define GLM_COMPILER GLM_COMPILER_CLANG36 # elif __clang_major__ >= 7 # define GLM_COMPILER GLM_COMPILER_CLANG37 # endif # else # if ((__clang_major__ == 3) && (__clang_minor__ < 4)) || (__clang_major__ < 3) # error "GLM requires Clang 3.4 or higher" # elif __clang_major__ == 3 && __clang_minor__ == 4 # define GLM_COMPILER GLM_COMPILER_CLANG34 # elif __clang_major__ == 3 && __clang_minor__ == 5 # define GLM_COMPILER GLM_COMPILER_CLANG35 # elif __clang_major__ == 3 && __clang_minor__ == 6 # define GLM_COMPILER GLM_COMPILER_CLANG36 # elif __clang_major__ == 3 && __clang_minor__ == 7 # define GLM_COMPILER GLM_COMPILER_CLANG37 # elif __clang_major__ == 3 && __clang_minor__ == 8 # define GLM_COMPILER GLM_COMPILER_CLANG38 # elif __clang_major__ == 3 && __clang_minor__ >= 9 # define GLM_COMPILER GLM_COMPILER_CLANG39 # elif __clang_major__ == 4 && __clang_minor__ == 0 # define GLM_COMPILER GLM_COMPILER_CLANG40 # elif __clang_major__ == 4 && __clang_minor__ == 1 # define GLM_COMPILER GLM_COMPILER_CLANG41 # elif __clang_major__ == 4 && __clang_minor__ >= 2 # define GLM_COMPILER GLM_COMPILER_CLANG42 # elif __clang_major__ >= 4 # define GLM_COMPILER GLM_COMPILER_CLANG42 # endif # endif // Visual C++ #elif defined(_MSC_VER) # if _MSC_VER >= 1920 # define GLM_COMPILER GLM_COMPILER_VC16 # elif _MSC_VER >= 1916 # define GLM_COMPILER GLM_COMPILER_VC15_9 # elif _MSC_VER >= 1915 # define GLM_COMPILER GLM_COMPILER_VC15_8 # elif _MSC_VER >= 1914 # define GLM_COMPILER GLM_COMPILER_VC15_7 # elif _MSC_VER >= 1913 # define GLM_COMPILER GLM_COMPILER_VC15_6 # elif _MSC_VER >= 1912 # define GLM_COMPILER GLM_COMPILER_VC15_5 # elif _MSC_VER >= 1911 # define GLM_COMPILER GLM_COMPILER_VC15_3 # elif _MSC_VER >= 1910 # define GLM_COMPILER GLM_COMPILER_VC15 # elif _MSC_VER >= 1900 # define GLM_COMPILER GLM_COMPILER_VC14 # elif _MSC_VER >= 1800 # define GLM_COMPILER GLM_COMPILER_VC12 # elif _MSC_VER < 1800 # error "GLM requires Visual C++ 12 - 2013 or higher" # endif//_MSC_VER // G++ #elif defined(__GNUC__) || defined(__MINGW32__) # if __GNUC__ >= 8 # define GLM_COMPILER GLM_COMPILER_GCC8 # elif __GNUC__ >= 7 # define GLM_COMPILER GLM_COMPILER_GCC7 # elif __GNUC__ >= 6 # define GLM_COMPILER GLM_COMPILER_GCC6 # elif __GNUC__ >= 5 # define GLM_COMPILER GLM_COMPILER_GCC5 # elif __GNUC__ == 4 && __GNUC_MINOR__ >= 9 # define GLM_COMPILER GLM_COMPILER_GCC49 # elif __GNUC__ == 4 && __GNUC_MINOR__ >= 8 # define GLM_COMPILER GLM_COMPILER_GCC48 # elif __GNUC__ == 4 && __GNUC_MINOR__ >= 7 # define GLM_COMPILER GLM_COMPILER_GCC47 # elif __GNUC__ == 4 && __GNUC_MINOR__ >= 6 # define GLM_COMPILER GLM_COMPILER_GCC46 # elif ((__GNUC__ == 4) && (__GNUC_MINOR__ < 6)) || (__GNUC__ < 4) # error "GLM requires GCC 4.6 or higher" # endif #else # define GLM_COMPILER GLM_COMPILER_UNKNOWN #endif #ifndef GLM_COMPILER # error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message." #endif//GLM_COMPILER /////////////////////////////////////////////////////////////////////////////////// // Instruction sets // User defines: GLM_FORCE_PURE GLM_FORCE_INTRINSICS GLM_FORCE_SSE2 GLM_FORCE_SSE3 GLM_FORCE_AVX GLM_FORCE_AVX2 GLM_FORCE_AVX2 #define GLM_ARCH_MIPS_BIT (0x10000000) #define GLM_ARCH_PPC_BIT (0x20000000) #define GLM_ARCH_ARM_BIT (0x40000000) #define GLM_ARCH_ARMV8_BIT (0x01000000) #define GLM_ARCH_X86_BIT (0x80000000) #define GLM_ARCH_SIMD_BIT (0x00001000) #define GLM_ARCH_NEON_BIT (0x00000001) #define GLM_ARCH_SSE_BIT (0x00000002) #define GLM_ARCH_SSE2_BIT (0x00000004) #define GLM_ARCH_SSE3_BIT (0x00000008) #define GLM_ARCH_SSSE3_BIT (0x00000010) #define GLM_ARCH_SSE41_BIT (0x00000020) #define GLM_ARCH_SSE42_BIT (0x00000040) #define GLM_ARCH_AVX_BIT (0x00000080) #define GLM_ARCH_AVX2_BIT (0x00000100) #define GLM_ARCH_UNKNOWN (0) #define GLM_ARCH_X86 (GLM_ARCH_X86_BIT) #define GLM_ARCH_SSE (GLM_ARCH_SSE_BIT | GLM_ARCH_SIMD_BIT | GLM_ARCH_X86) #define GLM_ARCH_SSE2 (GLM_ARCH_SSE2_BIT | GLM_ARCH_SSE) #define GLM_ARCH_SSE3 (GLM_ARCH_SSE3_BIT | GLM_ARCH_SSE2) #define GLM_ARCH_SSSE3 (GLM_ARCH_SSSE3_BIT | GLM_ARCH_SSE3) #define GLM_ARCH_SSE41 (GLM_ARCH_SSE41_BIT | GLM_ARCH_SSSE3) #define GLM_ARCH_SSE42 (GLM_ARCH_SSE42_BIT | GLM_ARCH_SSE41) #define GLM_ARCH_AVX (GLM_ARCH_AVX_BIT | GLM_ARCH_SSE42) #define GLM_ARCH_AVX2 (GLM_ARCH_AVX2_BIT | GLM_ARCH_AVX) #define GLM_ARCH_ARM (GLM_ARCH_ARM_BIT) #define GLM_ARCH_ARMV8 (GLM_ARCH_NEON_BIT | GLM_ARCH_SIMD_BIT | GLM_ARCH_ARM | GLM_ARCH_ARMV8_BIT) #define GLM_ARCH_NEON (GLM_ARCH_NEON_BIT | GLM_ARCH_SIMD_BIT | GLM_ARCH_ARM) #define GLM_ARCH_MIPS (GLM_ARCH_MIPS_BIT) #define GLM_ARCH_PPC (GLM_ARCH_PPC_BIT) #if defined(GLM_FORCE_ARCH_UNKNOWN) || defined(GLM_FORCE_PURE) # define GLM_ARCH GLM_ARCH_UNKNOWN #elif defined(GLM_FORCE_NEON) # if __ARM_ARCH >= 8 # define GLM_ARCH (GLM_ARCH_ARMV8) # else # define GLM_ARCH (GLM_ARCH_NEON) # endif # define GLM_FORCE_INTRINSICS #elif defined(GLM_FORCE_AVX2) # define GLM_ARCH (GLM_ARCH_AVX2) # define GLM_FORCE_INTRINSICS #elif defined(GLM_FORCE_AVX) # define GLM_ARCH (GLM_ARCH_AVX) # define GLM_FORCE_INTRINSICS #elif defined(GLM_FORCE_SSE42) # define GLM_ARCH (GLM_ARCH_SSE42) # define GLM_FORCE_INTRINSICS #elif defined(GLM_FORCE_SSE41) # define GLM_ARCH (GLM_ARCH_SSE41) # define GLM_FORCE_INTRINSICS #elif defined(GLM_FORCE_SSSE3) # define GLM_ARCH (GLM_ARCH_SSSE3) # define GLM_FORCE_INTRINSICS #elif defined(GLM_FORCE_SSE3) # define GLM_ARCH (GLM_ARCH_SSE3) # define GLM_FORCE_INTRINSICS #elif defined(GLM_FORCE_SSE2) # define GLM_ARCH (GLM_ARCH_SSE2) # define GLM_FORCE_INTRINSICS #elif defined(GLM_FORCE_SSE) # define GLM_ARCH (GLM_ARCH_SSE) # define GLM_FORCE_INTRINSICS #elif defined(GLM_FORCE_INTRINSICS) && !defined(GLM_FORCE_XYZW_ONLY) # if defined(__AVX2__) # define GLM_ARCH (GLM_ARCH_AVX2) # elif defined(__AVX__) # define GLM_ARCH (GLM_ARCH_AVX) # elif defined(__SSE4_2__) # define GLM_ARCH (GLM_ARCH_SSE42) # elif defined(__SSE4_1__) # define GLM_ARCH (GLM_ARCH_SSE41) # elif defined(__SSSE3__) # define GLM_ARCH (GLM_ARCH_SSSE3) # elif defined(__SSE3__) # define GLM_ARCH (GLM_ARCH_SSE3) # elif defined(__SSE2__) || defined(__x86_64__) || defined(_M_X64) || defined(_M_IX86_FP) # define GLM_ARCH (GLM_ARCH_SSE2) # elif defined(__i386__) # define GLM_ARCH (GLM_ARCH_X86) # elif defined(__ARM_ARCH) && (__ARM_ARCH >= 8) # define GLM_ARCH (GLM_ARCH_ARMV8) # elif defined(__ARM_NEON) # define GLM_ARCH (GLM_ARCH_ARM | GLM_ARCH_NEON) # elif defined(__arm__ ) || defined(_M_ARM) # define GLM_ARCH (GLM_ARCH_ARM) # elif defined(__mips__ ) # define GLM_ARCH (GLM_ARCH_MIPS) # elif defined(__powerpc__ ) || defined(_M_PPC) # define GLM_ARCH (GLM_ARCH_PPC) # else # define GLM_ARCH (GLM_ARCH_UNKNOWN) # endif #else # if defined(__x86_64__) || defined(_M_X64) || defined(_M_IX86) || defined(__i386__) # define GLM_ARCH (GLM_ARCH_X86) # elif defined(__arm__) || defined(_M_ARM) # define GLM_ARCH (GLM_ARCH_ARM) # elif defined(__powerpc__) || defined(_M_PPC) # define GLM_ARCH (GLM_ARCH_PPC) # elif defined(__mips__) # define GLM_ARCH (GLM_ARCH_MIPS) # else # define GLM_ARCH (GLM_ARCH_UNKNOWN) # endif #endif #if GLM_ARCH & GLM_ARCH_AVX2_BIT # include #elif GLM_ARCH & GLM_ARCH_AVX_BIT # include #elif GLM_ARCH & GLM_ARCH_SSE42_BIT # if GLM_COMPILER & GLM_COMPILER_CLANG # include # endif # include #elif GLM_ARCH & GLM_ARCH_SSE41_BIT # include #elif GLM_ARCH & GLM_ARCH_SSSE3_BIT # include #elif GLM_ARCH & GLM_ARCH_SSE3_BIT # include #elif GLM_ARCH & GLM_ARCH_SSE2_BIT # include #elif GLM_ARCH & GLM_ARCH_NEON_BIT # include "neon.h" #endif//GLM_ARCH #if GLM_ARCH & GLM_ARCH_SSE2_BIT typedef __m128 glm_f32vec4; typedef __m128i glm_i32vec4; typedef __m128i glm_u32vec4; typedef __m128d glm_f64vec2; typedef __m128i glm_i64vec2; typedef __m128i glm_u64vec2; typedef glm_f32vec4 glm_vec4; typedef glm_i32vec4 glm_ivec4; typedef glm_u32vec4 glm_uvec4; typedef glm_f64vec2 glm_dvec2; #endif #if GLM_ARCH & GLM_ARCH_AVX_BIT typedef __m256d glm_f64vec4; typedef glm_f64vec4 glm_dvec4; #endif #if GLM_ARCH & GLM_ARCH_AVX2_BIT typedef __m256i glm_i64vec4; typedef __m256i glm_u64vec4; #endif #if GLM_ARCH & GLM_ARCH_NEON_BIT typedef float32x4_t glm_f32vec4; typedef int32x4_t glm_i32vec4; typedef uint32x4_t glm_u32vec4; #endif ================================================ FILE: android/src/glm/simd/trigonometric.h ================================================ /// @ref simd /// @file glm/simd/trigonometric.h #pragma once #if GLM_ARCH & GLM_ARCH_SSE2_BIT #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/simd/vector_relational.h ================================================ /// @ref simd /// @file glm/simd/vector_relational.h #pragma once #if GLM_ARCH & GLM_ARCH_SSE2_BIT #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT ================================================ FILE: android/src/glm/trigonometric.hpp ================================================ /// @ref core /// @file glm/trigonometric.hpp /// /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions /// /// @defgroup core_func_trigonometric Angle and Trigonometry Functions /// @ingroup core /// /// Function parameters specified as angle are assumed to be in units of radians. /// In no case will any of these functions result in a divide by zero error. If /// the divisor of a ratio is 0, then results will be undefined. /// /// These all operate component-wise. The description is per component. /// /// Include to use these core features. /// /// @see ext_vector_trigonometric #pragma once #include "detail/setup.hpp" #include "detail/qualifier.hpp" namespace glm { /// @addtogroup core_func_trigonometric /// @{ /// Converts degrees to radians and returns the result. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL radians man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec radians(vec const& degrees); /// Converts radians to degrees and returns the result. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL degrees man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec degrees(vec const& radians); /// The standard trigonometric sine function. /// The values returned by this function will range from [-1, 1]. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL sin man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec sin(vec const& angle); /// The standard trigonometric cosine function. /// The values returned by this function will range from [-1, 1]. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL cos man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec cos(vec const& angle); /// The standard trigonometric tangent function. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL tan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec tan(vec const& angle); /// Arc sine. Returns an angle whose sine is x. /// The range of values returned by this function is [-PI/2, PI/2]. /// Results are undefined if |x| > 1. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL asin man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec asin(vec const& x); /// Arc cosine. Returns an angle whose sine is x. /// The range of values returned by this function is [0, PI]. /// Results are undefined if |x| > 1. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL acos man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec acos(vec const& x); /// Arc tangent. Returns an angle whose tangent is y/x. /// The signs of x and y are used to determine what /// quadrant the angle is in. The range of values returned /// by this function is [-PI, PI]. Results are undefined /// if x and y are both 0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL atan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec atan(vec const& y, vec const& x); /// Arc tangent. Returns an angle whose tangent is y_over_x. /// The range of values returned by this function is [-PI/2, PI/2]. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL atan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec atan(vec const& y_over_x); /// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2 /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL sinh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec sinh(vec const& angle); /// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2 /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL cosh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec cosh(vec const& angle); /// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle) /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL tanh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec tanh(vec const& angle); /// Arc hyperbolic sine; returns the inverse of sinh. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL asinh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec asinh(vec const& x); /// Arc hyperbolic cosine; returns the non-negative inverse /// of cosh. Results are undefined if x < 1. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL acosh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec acosh(vec const& x); /// Arc hyperbolic tangent; returns the inverse of tanh. /// Results are undefined if abs(x) >= 1. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL atanh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec atanh(vec const& x); /// @} }//namespace glm #include "detail/func_trigonometric.inl" ================================================ FILE: android/src/glm/vec2.hpp ================================================ /// @ref core /// @file glm/vec2.hpp #pragma once #include "./ext/vector_bool2.hpp" #include "./ext/vector_bool2_precision.hpp" #include "./ext/vector_float2.hpp" #include "./ext/vector_float2_precision.hpp" #include "./ext/vector_double2.hpp" #include "./ext/vector_double2_precision.hpp" #include "./ext/vector_int2.hpp" #include "./ext/vector_int2_sized.hpp" #include "./ext/vector_uint2.hpp" #include "./ext/vector_uint2_sized.hpp" ================================================ FILE: android/src/glm/vec3.hpp ================================================ /// @ref core /// @file glm/vec3.hpp #pragma once #include "./ext/vector_bool3.hpp" #include "./ext/vector_bool3_precision.hpp" #include "./ext/vector_float3.hpp" #include "./ext/vector_float3_precision.hpp" #include "./ext/vector_double3.hpp" #include "./ext/vector_double3_precision.hpp" #include "./ext/vector_int3.hpp" #include "./ext/vector_int3_sized.hpp" #include "./ext/vector_uint3.hpp" #include "./ext/vector_uint3_sized.hpp" ================================================ FILE: android/src/glm/vec4.hpp ================================================ /// @ref core /// @file glm/vec4.hpp #pragma once #include "./ext/vector_bool4.hpp" #include "./ext/vector_bool4_precision.hpp" #include "./ext/vector_float4.hpp" #include "./ext/vector_float4_precision.hpp" #include "./ext/vector_double4.hpp" #include "./ext/vector_double4_precision.hpp" #include "./ext/vector_int4.hpp" #include "./ext/vector_int4_sized.hpp" #include "./ext/vector_uint4.hpp" #include "./ext/vector_uint4_sized.hpp" ================================================ FILE: android/src/glm/vector_relational.hpp ================================================ /// @ref core /// @file glm/vector_relational.hpp /// /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions /// /// @defgroup core_func_vector_relational Vector Relational Functions /// @ingroup core /// /// Relational and equality operators (<, <=, >, >=, ==, !=) are defined to /// operate on scalars and produce scalar Boolean results. For vector results, /// use the following built-in functions. /// /// In all cases, the sizes of all the input and return vectors for any particular /// call must match. /// /// Include to use these core features. /// /// @see ext_vector_relational #pragma once #include "detail/qualifier.hpp" #include "detail/setup.hpp" namespace glm { /// @addtogroup core_func_vector_relational /// @{ /// Returns the component-wise comparison result of x < y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point or integer scalar type. /// /// @see GLSL lessThan man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec lessThan(vec const& x, vec const& y); /// Returns the component-wise comparison of result x <= y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point or integer scalar type. /// /// @see GLSL lessThanEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec lessThanEqual(vec const& x, vec const& y); /// Returns the component-wise comparison of result x > y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point or integer scalar type. /// /// @see GLSL greaterThan man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec greaterThan(vec const& x, vec const& y); /// Returns the component-wise comparison of result x >= y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point or integer scalar type. /// /// @see GLSL greaterThanEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec greaterThanEqual(vec const& x, vec const& y); /// Returns the component-wise comparison of result x == y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point, integer or bool scalar type. /// /// @see GLSL equal man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec equal(vec const& x, vec const& y); /// Returns the component-wise comparison of result x != y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point, integer or bool scalar type. /// /// @see GLSL notEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec notEqual(vec const& x, vec const& y); /// Returns true if any component of x is true. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL any man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL GLM_CONSTEXPR bool any(vec const& v); /// Returns true if all components of x are true. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL all man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL GLM_CONSTEXPR bool all(vec const& v); /// Returns the component-wise logical complement of x. /// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL not man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec not_(vec const& v); /// @} }//namespace glm #include "detail/func_vector_relational.inl" ================================================ FILE: android/src/main/AndroidManifest.xml ================================================ ================================================ FILE: android/src/main/java/com/example/flutter_opengl/FlutterOpenglPlugin.java ================================================ package com.example.flutter_opengl; import android.graphics.SurfaceTexture; import android.util.Log; import android.view.Surface; import androidx.annotation.NonNull; import java.util.Map; import io.flutter.embedding.engine.plugins.FlutterPlugin; import io.flutter.plugin.common.MethodCall; import io.flutter.plugin.common.MethodChannel; import io.flutter.plugin.common.MethodChannel.MethodCallHandler; import io.flutter.plugin.common.MethodChannel.Result; import io.flutter.view.TextureRegistry; /** * FlutterOpenglPlugin */ public class FlutterOpenglPlugin implements FlutterPlugin, MethodCallHandler { private static String TAG = FlutterOpenglPlugin.class.getSimpleName(); static { System.loadLibrary("flutter_opengl_plugin"); } public static native void nativeSetSurface(Surface surface, int width, int height); /// The MethodChannel that will the communication between Flutter and native Android /// /// This local reference serves to register the plugin with the Flutter Engine and unregister it /// when the Flutter Engine is detached from the Activity private MethodChannel channel; private TextureRegistry textures; TextureRegistry.SurfaceTextureEntry entry; SurfaceTexture surfaceTexture; int width, height; private double getDouble(Object obj) { if (obj instanceof Double) return (Double) obj; return -1; } private int getInt(Object obj) { if (obj instanceof Integer) return (int) obj; return -1; } private int getBoolean(Object obj) { if (obj instanceof Boolean) return ((Boolean) obj).booleanValue() ? 1 : 0; return -1; } private String getString(Object obj) { if (obj instanceof String) return ((String) obj).toString(); return ""; } @Override public void onAttachedToEngine(@NonNull FlutterPluginBinding flutterPluginBinding) { textures = flutterPluginBinding.getTextureRegistry(); channel = new MethodChannel(flutterPluginBinding.getBinaryMessenger(), "flutter_opengl_plugin"); channel.setMethodCallHandler(this); } @Override public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) { final Map arguments = (Map) call.arguments; if (arguments != null) Log.d("FlutteropenglPlugin", call.method + " " + call.arguments.toString()); if (call.method.equals("draw")) { // for testing purpose } else if (call.method.equals("createSurface")) { width = (int)getInt(arguments.get("width")); height = (int)getInt(arguments.get("height")); // check if all arguments are sane if (width == -1) { Log.i(TAG, "onMethodCall: width not passed correctly!"); result.error("onMethodCall()", "onMethodCall: width not passed correctly!", null); return; } if (height == -1) { Log.i(TAG, "onMethodCall: height not passed correctly!"); result.error("onMethodCall()", "onMethodCall: height not passed correctly!", null); return; } entry = textures.createSurfaceTexture(); surfaceTexture = entry.surfaceTexture(); Surface surface = new Surface(surfaceTexture); nativeSetSurface(surface, width, height); result.success(entry.id()); } else { result.notImplemented(); } } @Override public void onDetachedFromEngine(@NonNull FlutterPluginBinding binding) { channel.setMethodCallHandler(null); } } ================================================ FILE: example/.gitignore ================================================ # Miscellaneous *.class *.log *.pyc *.swp .DS_Store .atom/ .buildlog/ .history .svn/ migrate_working_dir/ # IntelliJ related *.iml *.ipr *.iws .idea/ # The .vscode folder contains launch configuration and tasks you configure in # VS Code which you may wish to be included in version control, so this line # is commented out by default. #.vscode/ # Flutter/Dart/Pub related **/doc/api/ **/ios/Flutter/.last_build_id .dart_tool/ .flutter-plugins .flutter-plugins-dependencies .packages .pub-cache/ .pub/ /build/ # Symbolication related app.*.symbols # Obfuscation related app.*.map.json # Android Studio will place build artifacts here /android/app/debug /android/app/profile /android/app/release ================================================ FILE: example/README.md ================================================ # flutter_opengl_example Demonstrates how to use the flutter_opengl plugin. ## Getting Started This project is a starting point for a Flutter application. A few resources to get you started if this is your first Flutter project: - [Lab: Write your first Flutter app](https://docs.flutter.dev/get-started/codelab) - [Cookbook: Useful Flutter samples](https://docs.flutter.dev/cookbook) For help getting started with Flutter development, view the [online documentation](https://docs.flutter.dev/), which offers tutorials, samples, guidance on mobile development, and a full API reference. ================================================ FILE: example/analysis_options.yaml ================================================ # This file configures the analyzer, which statically analyzes Dart code to # check for errors, warnings, and lints. # # The issues identified by the analyzer are surfaced in the UI of Dart-enabled # IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be # invoked from the command line by running `flutter analyze`. # The following line activates a set of recommended lints for Flutter apps, # packages, and plugins designed to encourage good coding practices. include: package:flutter_lints/flutter.yaml linter: # The lint rules applied to this project can be customized in the # section below to disable rules from the `package:flutter_lints/flutter.yaml` # included above or to enable additional rules. A list of all available lints # and their documentation is published at # https://dart-lang.github.io/linter/lints/index.html. # # Instead of disabling a lint rule for the entire project in the # section below, it can also be suppressed for a single line of code # or a specific dart file by using the `// ignore: name_of_lint` and # `// ignore_for_file: name_of_lint` syntax on the line or in the file # producing the lint. rules: # avoid_print: false # Uncomment to disable the `avoid_print` rule # prefer_single_quotes: true # Uncomment to enable the `prefer_single_quotes` rule # Additional information about this file can be found at # https://dart.dev/guides/language/analysis-options ================================================ FILE: example/android/.gitignore ================================================ gradle-wrapper.jar /.gradle /captures/ /gradlew /gradlew.bat /local.properties GeneratedPluginRegistrant.java # Remember to never publicly share your keystore. # See https://flutter.dev/docs/deployment/android#reference-the-keystore-from-the-app key.properties **/*.keystore **/*.jks ================================================ FILE: example/android/app/build.gradle ================================================ def localProperties = new Properties() def localPropertiesFile = rootProject.file('local.properties') if (localPropertiesFile.exists()) { localPropertiesFile.withReader('UTF-8') { reader -> localProperties.load(reader) } } def flutterRoot = localProperties.getProperty('flutter.sdk') if (flutterRoot == null) { throw new GradleException("Flutter SDK not found. Define location with flutter.sdk in the local.properties file.") } def flutterVersionCode = localProperties.getProperty('flutter.versionCode') if (flutterVersionCode == null) { flutterVersionCode = '1' } def flutterVersionName = localProperties.getProperty('flutter.versionName') if (flutterVersionName == null) { flutterVersionName = '1.0' } apply plugin: 'com.android.application' //apply plugin: 'kotlin-android' apply from: "$flutterRoot/packages/flutter_tools/gradle/flutter.gradle" android { compileSdkVersion 33 ndkVersion flutter.ndkVersion compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } defaultConfig { // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html). applicationId "com.example.flutter_opengl_example" // You can update the following values to match your application needs. // For more information, see: https://docs.flutter.dev/deployment/android#reviewing-the-build-configuration. minSdkVersion 24 targetSdkVersion 33 versionCode flutterVersionCode.toInteger() versionName flutterVersionName multiDexEnabled true // Enables code shrinking, obfuscation, and optimization for only // your project's release build type. // minifyEnabled true // Enables resource shrinking, which is performed by the // Android Gradle plugin. // shrinkResources true } buildTypes { release { // TODO: Add your own signing config for the release build. // Signing with the debug keys for now, so `flutter run --release` works. signingConfig signingConfigs.debug } } } flutter { source '../..' } ================================================ FILE: example/android/app/src/debug/AndroidManifest.xml ================================================ ================================================ FILE: example/android/app/src/main/AndroidManifest.xml ================================================ ================================================ FILE: example/android/app/src/main/java/com/example/flutter_opengl_example/MainActivity.java ================================================ package com.example.flutter_opengl_example; import io.flutter.embedding.android.FlutterActivity; public class MainActivity extends FlutterActivity { } ================================================ FILE: example/android/app/src/main/kotlin/com/example/flutter_opengl_example/MainActivity.kt ================================================ package com.example.flutter_opengl_example import io.flutter.embedding.android.FlutterActivity class MainActivity: FlutterActivity() { } ================================================ FILE: example/android/app/src/main/res/drawable/launch_background.xml ================================================ ================================================ FILE: example/android/app/src/main/res/drawable-v21/launch_background.xml ================================================ ================================================ FILE: example/android/app/src/main/res/values/styles.xml ================================================ ================================================ FILE: example/android/app/src/main/res/values-night/styles.xml ================================================ ================================================ FILE: example/android/app/src/profile/AndroidManifest.xml ================================================ ================================================ FILE: example/android/build.gradle ================================================ buildscript { ext.kotlin_version = '1.6.10' repositories { google() mavenCentral() } dependencies { // classpath 'com.android.tools.build:gradle:7.2.2' classpath 'com.android.tools.build:gradle:7.3.1' classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" } } allprojects { repositories { google() mavenCentral() } } rootProject.buildDir = '../build' subprojects { project.buildDir = "${rootProject.buildDir}/${project.name}" } subprojects { project.evaluationDependsOn(':app') } task clean(type: Delete) { delete rootProject.buildDir } ================================================ FILE: example/android/gradle/wrapper/gradle-wrapper.properties ================================================ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists #distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-all.zip distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-all.zip ================================================ FILE: example/android/gradle.properties ================================================ org.gradle.jvmargs=-Xmx1536M android.useAndroidX=true android.enableJetifier=true ================================================ FILE: example/android/settings.gradle ================================================ include ':app' def localPropertiesFile = new File(rootProject.projectDir, "local.properties") def properties = new Properties() assert localPropertiesFile.exists() localPropertiesFile.withReader("UTF-8") { reader -> properties.load(reader) } def flutterSdkPath = properties.getProperty("flutter.sdk") assert flutterSdkPath != null, "flutter.sdk not set in local.properties" apply from: "$flutterSdkPath/packages/flutter_tools/gradle/app_plugin_loader.gradle" ================================================ FILE: example/ios/.gitignore ================================================ **/dgph *.mode1v3 *.mode2v3 *.moved-aside *.pbxuser *.perspectivev3 **/*sync/ .sconsign.dblite .tags* **/.vagrant/ **/DerivedData/ Icon? **/Pods/ **/.symlinks/ profile xcuserdata **/.generated/ Flutter/App.framework Flutter/Flutter.framework Flutter/Flutter.podspec Flutter/Generated.xcconfig Flutter/ephemeral/ Flutter/app.flx Flutter/app.zip Flutter/flutter_assets/ Flutter/flutter_export_environment.sh ServiceDefinitions.json Runner/GeneratedPluginRegistrant.* # Exceptions to above rules. !default.mode1v3 !default.mode2v3 !default.pbxuser !default.perspectivev3 ================================================ FILE: example/ios/Flutter/AppFrameworkInfo.plist ================================================ CFBundleDevelopmentRegion en CFBundleExecutable App CFBundleIdentifier io.flutter.flutter.app CFBundleInfoDictionaryVersion 6.0 CFBundleName App CFBundlePackageType FMWK CFBundleShortVersionString 1.0 CFBundleSignature ???? CFBundleVersion 1.0 MinimumOSVersion 11.0 ================================================ FILE: example/ios/Flutter/Debug.xcconfig ================================================ #include "Generated.xcconfig" ================================================ FILE: example/ios/Flutter/Release.xcconfig ================================================ #include "Generated.xcconfig" ================================================ FILE: example/ios/Runner/AppDelegate.swift ================================================ import UIKit import Flutter @UIApplicationMain @objc class AppDelegate: FlutterAppDelegate { override func application( _ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? ) -> Bool { GeneratedPluginRegistrant.register(with: self) return super.application(application, didFinishLaunchingWithOptions: launchOptions) } } ================================================ FILE: example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json ================================================ { "images" : [ { "size" : "20x20", "idiom" : "iphone", "filename" : "Icon-App-20x20@2x.png", "scale" : "2x" }, { "size" : "20x20", "idiom" : "iphone", "filename" : "Icon-App-20x20@3x.png", "scale" : "3x" }, { "size" : "29x29", "idiom" : "iphone", "filename" : "Icon-App-29x29@1x.png", "scale" : "1x" }, { "size" : "29x29", "idiom" : "iphone", "filename" : "Icon-App-29x29@2x.png", "scale" : "2x" }, { "size" : "29x29", "idiom" : "iphone", "filename" : "Icon-App-29x29@3x.png", "scale" : "3x" }, { "size" : "40x40", "idiom" : "iphone", "filename" : "Icon-App-40x40@2x.png", "scale" : "2x" }, { "size" : "40x40", "idiom" : "iphone", "filename" : "Icon-App-40x40@3x.png", "scale" : "3x" }, { "size" : "60x60", "idiom" : "iphone", "filename" : "Icon-App-60x60@2x.png", "scale" : "2x" }, { "size" : "60x60", "idiom" : "iphone", "filename" : "Icon-App-60x60@3x.png", "scale" : "3x" }, { "size" : "20x20", "idiom" : "ipad", "filename" : "Icon-App-20x20@1x.png", "scale" : "1x" }, { "size" : "20x20", "idiom" : "ipad", "filename" : "Icon-App-20x20@2x.png", "scale" : "2x" }, { "size" : "29x29", "idiom" : "ipad", "filename" : "Icon-App-29x29@1x.png", "scale" : "1x" }, { "size" : "29x29", "idiom" : "ipad", "filename" : "Icon-App-29x29@2x.png", "scale" : "2x" }, { "size" : "40x40", "idiom" : "ipad", "filename" : "Icon-App-40x40@1x.png", "scale" : "1x" }, { "size" : "40x40", "idiom" : "ipad", "filename" : "Icon-App-40x40@2x.png", "scale" : "2x" }, { "size" : "76x76", "idiom" : "ipad", "filename" : "Icon-App-76x76@1x.png", "scale" : "1x" }, { "size" : "76x76", "idiom" : "ipad", "filename" : "Icon-App-76x76@2x.png", "scale" : "2x" }, { "size" : "83.5x83.5", "idiom" : "ipad", "filename" : "Icon-App-83.5x83.5@2x.png", "scale" : "2x" }, { "size" : "1024x1024", "idiom" : "ios-marketing", "filename" : "Icon-App-1024x1024@1x.png", "scale" : "1x" } ], "info" : { "version" : 1, "author" : "xcode" } } ================================================ FILE: example/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json ================================================ { "images" : [ { "idiom" : "universal", "filename" : "LaunchImage.png", "scale" : "1x" }, { "idiom" : "universal", "filename" : "LaunchImage@2x.png", "scale" : "2x" }, { "idiom" : "universal", "filename" : "LaunchImage@3x.png", "scale" : "3x" } ], "info" : { "version" : 1, "author" : "xcode" } } ================================================ FILE: example/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md ================================================ # Launch Screen Assets You can customize the launch screen with your own desired assets by replacing the image files in this directory. You can also do it by opening your Flutter project's Xcode project with `open ios/Runner.xcworkspace`, selecting `Runner/Assets.xcassets` in the Project Navigator and dropping in the desired images. ================================================ FILE: example/ios/Runner/Base.lproj/LaunchScreen.storyboard ================================================ ================================================ FILE: example/ios/Runner/Base.lproj/Main.storyboard ================================================ ================================================ FILE: example/ios/Runner/Info.plist ================================================ CFBundleDevelopmentRegion $(DEVELOPMENT_LANGUAGE) CFBundleDisplayName Flutter Opengl CFBundleExecutable $(EXECUTABLE_NAME) CFBundleIdentifier $(PRODUCT_BUNDLE_IDENTIFIER) CFBundleInfoDictionaryVersion 6.0 CFBundleName flutter_opengl_example CFBundlePackageType APPL CFBundleShortVersionString $(FLUTTER_BUILD_NAME) CFBundleSignature ???? CFBundleVersion $(FLUTTER_BUILD_NUMBER) LSRequiresIPhoneOS UILaunchStoryboardName LaunchScreen UIMainStoryboardFile Main UISupportedInterfaceOrientations UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UISupportedInterfaceOrientations~ipad UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UIViewControllerBasedStatusBarAppearance CADisableMinimumFrameDurationOnPhone UIApplicationSupportsIndirectInputEvents ================================================ FILE: example/ios/Runner/Runner-Bridging-Header.h ================================================ #import "GeneratedPluginRegistrant.h" ================================================ FILE: example/ios/Runner.xcodeproj/project.pbxproj ================================================ // !$*UTF8*$! { archiveVersion = 1; classes = { }; objectVersion = 50; objects = { /* Begin PBXBuildFile section */ 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; }; 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; }; 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; }; 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; }; 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; }; 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; }; /* End PBXBuildFile section */ /* Begin PBXCopyFilesBuildPhase section */ 9705A1C41CF9048500538489 /* Embed Frameworks */ = { isa = PBXCopyFilesBuildPhase; buildActionMask = 2147483647; dstPath = ""; dstSubfolderSpec = 10; files = ( ); name = "Embed Frameworks"; runOnlyForDeploymentPostprocessing = 0; }; /* End PBXCopyFilesBuildPhase section */ /* Begin PBXFileReference section */ 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = ""; }; 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = ""; }; 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = ""; }; 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = ""; }; 74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = ""; }; 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = ""; }; 9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = ""; }; 97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; }; 97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = ""; }; 97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; 97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; 97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; /* End PBXFileReference section */ /* Begin PBXFrameworksBuildPhase section */ 97C146EB1CF9000F007C117D /* Frameworks */ = { isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = ( ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXFrameworksBuildPhase section */ /* Begin PBXGroup section */ 9740EEB11CF90186004384FC /* Flutter */ = { isa = PBXGroup; children = ( 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */, 9740EEB21CF90195004384FC /* Debug.xcconfig */, 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, 9740EEB31CF90195004384FC /* Generated.xcconfig */, ); name = Flutter; sourceTree = ""; }; 97C146E51CF9000F007C117D = { isa = PBXGroup; children = ( 9740EEB11CF90186004384FC /* Flutter */, 97C146F01CF9000F007C117D /* Runner */, 97C146EF1CF9000F007C117D /* Products */, ); sourceTree = ""; }; 97C146EF1CF9000F007C117D /* Products */ = { isa = PBXGroup; children = ( 97C146EE1CF9000F007C117D /* Runner.app */, ); name = Products; sourceTree = ""; }; 97C146F01CF9000F007C117D /* Runner */ = { isa = PBXGroup; children = ( 97C146FA1CF9000F007C117D /* Main.storyboard */, 97C146FD1CF9000F007C117D /* Assets.xcassets */, 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */, 97C147021CF9000F007C117D /* Info.plist */, 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */, 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */, 74858FAE1ED2DC5600515810 /* AppDelegate.swift */, 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */, ); path = Runner; sourceTree = ""; }; /* End PBXGroup section */ /* Begin PBXNativeTarget section */ 97C146ED1CF9000F007C117D /* Runner */ = { isa = PBXNativeTarget; buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */; buildPhases = ( 9740EEB61CF901F6004384FC /* Run Script */, 97C146EA1CF9000F007C117D /* Sources */, 97C146EB1CF9000F007C117D /* Frameworks */, 97C146EC1CF9000F007C117D /* Resources */, 9705A1C41CF9048500538489 /* Embed Frameworks */, 3B06AD1E1E4923F5004D2608 /* Thin Binary */, ); buildRules = ( ); dependencies = ( ); name = Runner; productName = Runner; productReference = 97C146EE1CF9000F007C117D /* Runner.app */; productType = "com.apple.product-type.application"; }; /* End PBXNativeTarget section */ /* Begin PBXProject section */ 97C146E61CF9000F007C117D /* Project object */ = { isa = PBXProject; attributes = { LastUpgradeCheck = 1300; ORGANIZATIONNAME = ""; TargetAttributes = { 97C146ED1CF9000F007C117D = { CreatedOnToolsVersion = 7.3.1; LastSwiftMigration = 1100; }; }; }; buildConfigurationList = 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */; compatibilityVersion = "Xcode 9.3"; developmentRegion = en; hasScannedForEncodings = 0; knownRegions = ( en, Base, ); mainGroup = 97C146E51CF9000F007C117D; productRefGroup = 97C146EF1CF9000F007C117D /* Products */; projectDirPath = ""; projectRoot = ""; targets = ( 97C146ED1CF9000F007C117D /* Runner */, ); }; /* End PBXProject section */ /* Begin PBXResourcesBuildPhase section */ 97C146EC1CF9000F007C117D /* Resources */ = { isa = PBXResourcesBuildPhase; buildActionMask = 2147483647; files = ( 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */, 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */, 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */, 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */, ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXResourcesBuildPhase section */ /* Begin PBXShellScriptBuildPhase section */ 3B06AD1E1E4923F5004D2608 /* Thin Binary */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; files = ( ); inputPaths = ( ); name = "Thin Binary"; outputPaths = ( ); runOnlyForDeploymentPostprocessing = 0; shellPath = /bin/sh; shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin"; }; 9740EEB61CF901F6004384FC /* Run Script */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; files = ( ); inputPaths = ( ); name = "Run Script"; outputPaths = ( ); runOnlyForDeploymentPostprocessing = 0; shellPath = /bin/sh; shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build"; }; /* End PBXShellScriptBuildPhase section */ /* Begin PBXSourcesBuildPhase section */ 97C146EA1CF9000F007C117D /* Sources */ = { isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */, 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXSourcesBuildPhase section */ /* Begin PBXVariantGroup section */ 97C146FA1CF9000F007C117D /* Main.storyboard */ = { isa = PBXVariantGroup; children = ( 97C146FB1CF9000F007C117D /* Base */, ); name = Main.storyboard; sourceTree = ""; }; 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */ = { isa = PBXVariantGroup; children = ( 97C147001CF9000F007C117D /* Base */, ); name = LaunchScreen.storyboard; sourceTree = ""; }; /* End PBXVariantGroup section */ /* Begin XCBuildConfiguration section */ 249021D3217E4FDB00AE95B9 /* Profile */ = { isa = XCBuildConfiguration; buildSettings = { ALWAYS_SEARCH_USER_PATHS = NO; CLANG_ANALYZER_NONNULL = YES; CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; CLANG_CXX_LIBRARY = "libc++"; CLANG_ENABLE_MODULES = YES; CLANG_ENABLE_OBJC_ARC = YES; CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; CLANG_WARN_BOOL_CONVERSION = YES; CLANG_WARN_COMMA = YES; CLANG_WARN_CONSTANT_CONVERSION = YES; CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; CLANG_WARN_EMPTY_BODY = YES; CLANG_WARN_ENUM_CONVERSION = YES; CLANG_WARN_INFINITE_RECURSION = YES; CLANG_WARN_INT_CONVERSION = YES; CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; CLANG_WARN_STRICT_PROTOTYPES = YES; CLANG_WARN_SUSPICIOUS_MOVE = YES; CLANG_WARN_UNREACHABLE_CODE = YES; CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; COPY_PHASE_STRIP = NO; DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; ENABLE_NS_ASSERTIONS = NO; ENABLE_STRICT_OBJC_MSGSEND = YES; GCC_C_LANGUAGE_STANDARD = gnu99; GCC_NO_COMMON_BLOCKS = YES; GCC_WARN_64_TO_32_BIT_CONVERSION = YES; GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; GCC_WARN_UNDECLARED_SELECTOR = YES; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_VARIABLE = YES; IPHONEOS_DEPLOYMENT_TARGET = 11.0; MTL_ENABLE_DEBUG_INFO = NO; SDKROOT = iphoneos; SUPPORTED_PLATFORMS = iphoneos; TARGETED_DEVICE_FAMILY = "1,2"; VALIDATE_PRODUCT = YES; }; name = Profile; }; 249021D4217E4FDB00AE95B9 /* Profile */ = { isa = XCBuildConfiguration; baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; INFOPLIST_FILE = Runner/Info.plist; LD_RUNPATH_SEARCH_PATHS = ( "$(inherited)", "@executable_path/Frameworks", ); PRODUCT_BUNDLE_IDENTIFIER = com.example.flutterOpenglExample; PRODUCT_NAME = "$(TARGET_NAME)"; SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; SWIFT_VERSION = 5.0; VERSIONING_SYSTEM = "apple-generic"; }; name = Profile; }; 97C147031CF9000F007C117D /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { ALWAYS_SEARCH_USER_PATHS = NO; CLANG_ANALYZER_NONNULL = YES; CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; CLANG_CXX_LIBRARY = "libc++"; CLANG_ENABLE_MODULES = YES; CLANG_ENABLE_OBJC_ARC = YES; CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; CLANG_WARN_BOOL_CONVERSION = YES; CLANG_WARN_COMMA = YES; CLANG_WARN_CONSTANT_CONVERSION = YES; CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; CLANG_WARN_EMPTY_BODY = YES; CLANG_WARN_ENUM_CONVERSION = YES; CLANG_WARN_INFINITE_RECURSION = YES; CLANG_WARN_INT_CONVERSION = YES; CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; CLANG_WARN_STRICT_PROTOTYPES = YES; CLANG_WARN_SUSPICIOUS_MOVE = YES; CLANG_WARN_UNREACHABLE_CODE = YES; CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; COPY_PHASE_STRIP = NO; DEBUG_INFORMATION_FORMAT = dwarf; ENABLE_STRICT_OBJC_MSGSEND = YES; ENABLE_TESTABILITY = YES; GCC_C_LANGUAGE_STANDARD = gnu99; GCC_DYNAMIC_NO_PIC = NO; GCC_NO_COMMON_BLOCKS = YES; GCC_OPTIMIZATION_LEVEL = 0; GCC_PREPROCESSOR_DEFINITIONS = ( "DEBUG=1", "$(inherited)", ); GCC_WARN_64_TO_32_BIT_CONVERSION = YES; GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; GCC_WARN_UNDECLARED_SELECTOR = YES; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_VARIABLE = YES; IPHONEOS_DEPLOYMENT_TARGET = 11.0; MTL_ENABLE_DEBUG_INFO = YES; ONLY_ACTIVE_ARCH = YES; SDKROOT = iphoneos; TARGETED_DEVICE_FAMILY = "1,2"; }; name = Debug; }; 97C147041CF9000F007C117D /* Release */ = { isa = XCBuildConfiguration; buildSettings = { ALWAYS_SEARCH_USER_PATHS = NO; CLANG_ANALYZER_NONNULL = YES; CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; CLANG_CXX_LIBRARY = "libc++"; CLANG_ENABLE_MODULES = YES; CLANG_ENABLE_OBJC_ARC = YES; CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; CLANG_WARN_BOOL_CONVERSION = YES; CLANG_WARN_COMMA = YES; CLANG_WARN_CONSTANT_CONVERSION = YES; CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; CLANG_WARN_EMPTY_BODY = YES; CLANG_WARN_ENUM_CONVERSION = YES; CLANG_WARN_INFINITE_RECURSION = YES; CLANG_WARN_INT_CONVERSION = YES; CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; CLANG_WARN_STRICT_PROTOTYPES = YES; CLANG_WARN_SUSPICIOUS_MOVE = YES; CLANG_WARN_UNREACHABLE_CODE = YES; CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; COPY_PHASE_STRIP = NO; DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; ENABLE_NS_ASSERTIONS = NO; ENABLE_STRICT_OBJC_MSGSEND = YES; GCC_C_LANGUAGE_STANDARD = gnu99; GCC_NO_COMMON_BLOCKS = YES; GCC_WARN_64_TO_32_BIT_CONVERSION = YES; GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; GCC_WARN_UNDECLARED_SELECTOR = YES; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_VARIABLE = YES; IPHONEOS_DEPLOYMENT_TARGET = 11.0; MTL_ENABLE_DEBUG_INFO = NO; SDKROOT = iphoneos; SUPPORTED_PLATFORMS = iphoneos; SWIFT_COMPILATION_MODE = wholemodule; SWIFT_OPTIMIZATION_LEVEL = "-O"; TARGETED_DEVICE_FAMILY = "1,2"; VALIDATE_PRODUCT = YES; }; name = Release; }; 97C147061CF9000F007C117D /* Debug */ = { isa = XCBuildConfiguration; baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; buildSettings = { ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; INFOPLIST_FILE = Runner/Info.plist; LD_RUNPATH_SEARCH_PATHS = ( "$(inherited)", "@executable_path/Frameworks", ); PRODUCT_BUNDLE_IDENTIFIER = com.example.flutterOpenglExample; PRODUCT_NAME = "$(TARGET_NAME)"; SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; SWIFT_OPTIMIZATION_LEVEL = "-Onone"; SWIFT_VERSION = 5.0; VERSIONING_SYSTEM = "apple-generic"; }; name = Debug; }; 97C147071CF9000F007C117D /* Release */ = { isa = XCBuildConfiguration; baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; INFOPLIST_FILE = Runner/Info.plist; LD_RUNPATH_SEARCH_PATHS = ( "$(inherited)", "@executable_path/Frameworks", ); PRODUCT_BUNDLE_IDENTIFIER = com.example.flutterOpenglExample; PRODUCT_NAME = "$(TARGET_NAME)"; SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; SWIFT_VERSION = 5.0; VERSIONING_SYSTEM = "apple-generic"; }; name = Release; }; /* End XCBuildConfiguration section */ /* Begin XCConfigurationList section */ 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */ = { isa = XCConfigurationList; buildConfigurations = ( 97C147031CF9000F007C117D /* Debug */, 97C147041CF9000F007C117D /* Release */, 249021D3217E4FDB00AE95B9 /* Profile */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */ = { isa = XCConfigurationList; buildConfigurations = ( 97C147061CF9000F007C117D /* Debug */, 97C147071CF9000F007C117D /* Release */, 249021D4217E4FDB00AE95B9 /* Profile */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; /* End XCConfigurationList section */ }; rootObject = 97C146E61CF9000F007C117D /* Project object */; } ================================================ FILE: example/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata ================================================ ================================================ FILE: example/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist ================================================ IDEDidComputeMac32BitWarning ================================================ FILE: example/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings ================================================ PreviewsEnabled ================================================ FILE: example/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme ================================================ ================================================ FILE: example/ios/Runner.xcworkspace/contents.xcworkspacedata ================================================ ================================================ FILE: example/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist ================================================ IDEDidComputeMac32BitWarning ================================================ FILE: example/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings ================================================ PreviewsEnabled ================================================ FILE: example/lib/controls/ShaderButtons.dart ================================================ import 'dart:io'; import 'dart:typed_data'; import 'package:file_picker/file_picker.dart'; import 'package:flutter/material.dart'; import 'package:flutter_opengl/flutter_opengl.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; import '../shadertoy.dart'; import '../states.dart'; /// Shader buttons (without texture) /// class ShaderButtons extends ConsumerWidget { const ShaderButtons({ Key? key, }) : super(key: key); @override Widget build(BuildContext context, WidgetRef ref) { final activeButtonId = ref.watch(stateShaderIndex); return Column( mainAxisSize: MainAxisSize.min, children: [ const Text('Shader examples'), Wrap( alignment: WrapAlignment.center, runSpacing: 4, spacing: 4, children: [ /// Build button for each fragments stored in [shaderToy] list /// Each button display also if a iChannelN is present /// displaying the iChannel number below the button number ...List.generate(shaderToy.length, (i) { bool hasIChannel0 = shaderToy[i]['fragment']!.contains('iChannel0'); bool hasIChannel1 = shaderToy[i]['fragment']!.contains('iChannel1'); bool hasIChannel2 = shaderToy[i]['fragment']!.contains('iChannel2'); bool hasIChannel3 = shaderToy[i]['fragment']!.contains('iChannel3'); return ElevatedButton( onPressed: () { ref.read(stateUrl.notifier).state = shaderToy[i]['url']!; OpenGLController().openglFFI.setShaderToy( shaderToy[i]['fragment']!, ); // Size size = OpenGLController().openglFFI.getTextureSize(); ref.read(stateShaderIndex.notifier).state = i; /// reset bottom TextureChooser ref.read(stateChannel0.notifier).state = TextureParams().copyWith(assetsImage: ''); ref.read(stateChannel1.notifier).state = TextureParams().copyWith(assetsImage: ''); ref.read(stateChannel2.notifier).state = TextureParams().copyWith(assetsImage: ''); ref.read(stateChannel3.notifier).state = TextureParams().copyWith(assetsImage: ''); /// stop capturing if (ref.read(stateCaptureRunning)) { OpenGLController().openglFFI.stopCapture(); ref.read(stateCaptureRunning.notifier).state = false; } }, style: ButtonStyle( fixedSize: const MaterialStatePropertyAll(Size(65, 45)), backgroundColor: i == activeButtonId ? const MaterialStatePropertyAll(Colors.green) : null, ), child: Column( mainAxisSize: MainAxisSize.min, mainAxisAlignment: MainAxisAlignment.center, children: [ Text('${i + 1}'), Row( mainAxisSize: MainAxisSize.min, children: [ if (hasIChannel0) const Text('0 ', textScaleFactor: 0.8), if (hasIChannel1) const Text('1 ', textScaleFactor: 0.8), if (hasIChannel2) const Text('2 ', textScaleFactor: 0.8), if (hasIChannel3) const Text('3', textScaleFactor: 0.8), ], ), ], ), ); }), ], ), ], ); } } ================================================ FILE: example/lib/controls/controls.dart ================================================ import 'dart:async'; import 'package:file_picker/file_picker.dart'; import 'package:flutter/material.dart'; import 'package:flutter_opengl/flutter_opengl.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; import '../states.dart'; import 'ShaderButtons.dart'; import 'texture_chooser.dart'; import 'texture_sizes.dart'; /// Tab page to test the plugin /// - create the texture id and use it in the Texture() widget /// - start/stop renderer /// - choose shader samples class Controls extends ConsumerWidget { Controls({ Key? key, }) : super(key: key); Timer? fpsTimer; @override Widget build(BuildContext context, WidgetRef ref) { final textureCreated = ref.watch(stateTextureCreated); return SingleChildScrollView( child: Column( mainAxisSize: MainAxisSize.min, children: [ /// CREATE TEXTURE Row( mainAxisAlignment: MainAxisAlignment.center, children: [ ElevatedButton( style: ButtonStyle( backgroundColor: textureCreated ? const MaterialStatePropertyAll(Colors.green) : const MaterialStatePropertyAll(Colors.red), ), onPressed: () async { fpsTimer?.cancel(); Size textureSize = ref.read(stateTextureSize); int id = await OpenGLController().openglPlugin.createSurface( textureSize.width.toInt(), textureSize.height.toInt(), ); ref.read(stateTextureCreated.notifier).state = OpenGLController().openglFFI.rendererStatus(); ref.read(stateTextureId.notifier).state = id; }, child: const Text('create texture'), ), const SizedBox(width: 16), /// START ElevatedButton( onPressed: () { OpenGLController().openglFFI.startThread(); fpsTimer?.cancel(); fpsTimer = Timer.periodic(const Duration(seconds: 1), (timer) { double fps = OpenGLController().openglFFI.getFps(); ref.read(stateFPS.notifier).state = fps; }); }, child: const Text('start'), ), const SizedBox(width: 8), /// STOP ElevatedButton( onPressed: () { fpsTimer?.cancel(); OpenGLController().openglFFI.stopThread(); ref.read(stateTextureCreated.notifier).state = false; ref.read(stateShaderIndex.notifier).state = -1; }, child: const Text('stop'), ), const SizedBox(width: 16), /// PICK VIDEO FILE ElevatedButton( onPressed: () async { FilePickerResult? result = await FilePicker.platform.pickFiles( type: FileType.video, ); if (result != null) { ref.read(statePickedVideo.notifier).state = result.files.single.path!; } else { // User canceled the picker } }, child: const Text('pick a\nvideo'), ), ], ), const SizedBox(height: 10), /// SET TEXTURE SIZE const TextureSize(), /// SHADERS BUTTONS const ShaderButtons(), const SizedBox(height: 10), /// CHOOSE TEXTURE const TextureChooser(), ], ), ); } } ================================================ FILE: example/lib/controls/texture_chooser.dart ================================================ import 'package:flutter/material.dart'; import 'package:flutter_opengl/flutter_opengl.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:star_menu/star_menu.dart'; import '../states.dart'; /// Row of 4 TextureWidget that represent the 4 iChannel[0-3] /// class TextureChooser extends ConsumerWidget { const TextureChooser({ Key? key, }) : super(key: key); @override Widget build(BuildContext context, WidgetRef ref) { int shaderIndex = ref.watch(stateShaderIndex); if (shaderIndex == -1) { return const SizedBox.shrink(); } return Row( mainAxisAlignment: MainAxisAlignment.center, children: List.generate(4, (index) => TextureWidget(channelId: index)), ); } } /// Widget that display the current binded texture /// class TextureWidget extends ConsumerWidget { final int channelId; final double? width; final double? height; const TextureWidget({ Key? key, required this.channelId, this.width = 80, this.height = 80, }) : super(key: key); @override Widget build(BuildContext context, WidgetRef ref) { final TextureParams texture; switch (channelId) { case 0: texture = ref.watch(stateChannel0); break; case 1: texture = ref.watch(stateChannel1); break; case 2: texture = ref.watch(stateChannel2); break; case 3: texture = ref.watch(stateChannel3); break; default: texture = ref.watch(stateChannel0); } return Column( children: [ Stack( children: [ /// STARMENU POPUP StarMenu( params: StarMenuParameters( backgroundParams: const BackgroundParams( animatedBlur: true, sigmaX: 12, sigmaY: 12), shape: MenuShape.linear, linearShapeParams: const LinearShapeParams( alignment: LinearAlignment.center, ), boundaryBackground: BoundaryBackground( color: const Color(0x800e0e0e), ), centerOffset: const Offset(0, -100)), items: _items(ref), onItemTapped: (index, controller) { controller.closeMenu!(); }, child: Container( width: width, height: height, margin: const EdgeInsets.all(6), decoration: BoxDecoration( color: Colors.black, borderRadius: const BorderRadius.all(Radius.circular(10)), border: Border.all(width: 3, color: Colors.white), image: texture.assetImage.isEmpty ? null : DecorationImage( fit: BoxFit.cover, image: AssetImage(texture.assetImage), ), ), ), ), /// REMOVE TEXTURE Positioned( right: 9, top: 9, child: GestureDetector( onTap: () { bool removed = OpenGLController() .openglFFI .removeUniform('iChannel$channelId'); if (removed) { StateController channelProvider; _clearTexture(ref); } }, child: const Icon(Icons.delete_outline, size: 24), ), ), /// STOP CAPTURE /// since only once instance of capture is available for now /// this is visible on all [TextureChooser] Visibility( visible: ref.watch(stateCaptureRunning), child: Positioned( left: 9, bottom: 9, child: GestureDetector( onTap: () { bool ret = OpenGLController().openglFFI.stopCapture(); ref.read(stateCaptureRunning.notifier).state = false; }, child: const Icon(Icons.stop_circle, size: 24), ), ), ), ], ), Text('iChannel$channelId'), ], ); } _clearTexture(WidgetRef ref) { switch (channelId) { case 0: ref.read(stateChannel0.notifier).state = TextureParams().copyWith(assetsImage: ''); break; case 1: ref.read(stateChannel1.notifier).state = TextureParams().copyWith(assetsImage: ''); break; case 2: ref.read(stateChannel2.notifier).state = TextureParams().copyWith(assetsImage: ''); break; case 3: ref.read(stateChannel3.notifier).state = TextureParams().copyWith(assetsImage: ''); break; } } List _items(WidgetRef ref) { return [ Item( channelId: channelId, assetImage: 'assets/dash.png', text: '1481x900'), Item( channelId: channelId, assetImage: 'assets/flutter.png', text: '512x512'), Item( channelId: channelId, assetImage: 'assets/rgba-noise-medium.png', text: '96x96'), Item( channelId: channelId, assetImage: 'assets/rgba-noise-small.png', text: '96x96'), Row( mainAxisSize: MainAxisSize.min, children: [ SizedBox( width: 64, height: 64, child: IconButton( onPressed: () { bool ret = OpenGLController().openglFFI.startCaptureOnSampler2D( 'iChannel$channelId', ref.read(statePickedVideo)); ref.read(stateCaptureRunning.notifier).state = true; _clearTexture(ref); }, icon: const Icon(Icons.ondemand_video_outlined, size: 64), ), ), const SizedBox(width: 30), SizedBox( width: 64, height: 64, child: IconButton( onPressed: () { bool ret = OpenGLController() .openglFFI .startCaptureOnSampler2D('iChannel$channelId', 'cam0'); ref.read(stateCaptureRunning.notifier).state = ret; _clearTexture(ref); }, icon: const Icon(Icons.camera, size: 64), ), ), ], ), ]; } } /// Entry for the menu /// /// It display the texture image and its resolution class Item extends ConsumerWidget { final int channelId; final String assetImage; final String text; const Item({ Key? key, required this.channelId, required this.assetImage, required this.text, }) : super(key: key); _setTexture(AddMethod method, WidgetRef ref) { var channelProvider; switch (channelId) { case 0: channelProvider = ref.read(stateChannel0.notifier); break; case 1: channelProvider = ref.read(stateChannel1.notifier); break; case 2: channelProvider = ref.read(stateChannel2.notifier); break; case 3: channelProvider = ref.read(stateChannel3.notifier); break; default: channelProvider = ref.read(stateChannel0.notifier); } OGLUtils.setAssetTexture('iChannel$channelId', assetImage, method: method) .then((value) { if (value) { channelProvider.state = TextureParams().copyWith(assetsImage: assetImage); } }); } @override Widget build(BuildContext context, WidgetRef ref) { return Padding( padding: const EdgeInsets.all(8.0), child: Container( decoration: BoxDecoration( color: const Color(0xFF3f3f3f), borderRadius: const BorderRadius.all(Radius.circular(10)), border: Border.all(width: 1, color: Colors.black), ), child: Row( mainAxisSize: MainAxisSize.min, children: [ Padding( padding: const EdgeInsets.all(2.0), child: Image.asset(assetImage, width: 80, height: 80), ), const SizedBox(width: 10), Text(text), const SizedBox(width: 10), IconButton( icon: const Icon(Icons.add), tooltip: 'add new', onPressed: () { _setTexture(AddMethod.add, ref); }, ), IconButton( icon: const Icon(Icons.find_replace), tooltip: 'replace different size', onPressed: () { _setTexture(AddMethod.replace, ref); }, ), IconButton( icon: const Icon(Icons.settings_overscan_outlined), tooltip: 'replace same size', onPressed: () { _setTexture(AddMethod.set, ref); }, ), ], ), ), ); } } ================================================ FILE: example/lib/controls/texture_sizes.dart ================================================ import 'package:flutter/material.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; import '../states.dart'; /// Texture radio button sizes to choose /// class TextureSize extends ConsumerWidget { const TextureSize({ Key? key, }) : super(key: key); @override Widget build(BuildContext context, WidgetRef ref) { final textureSizes = [ const Size(150, 84), const Size(300, 170), const Size(600, 338), const Size(1200, 676), ]; final textureSize = ref.watch(stateTextureSize); return Wrap( runSpacing: -25, children: List.generate(textureSizes.length, (n) { return SizedBox( height: 60, child: FittedBox( child: SizedBox( height: 80, child: Row( children: [ Checkbox( value: textureSize == textureSizes[n], onChanged: (val) { ref.read(stateTextureSize.notifier).state = textureSizes[n]; }, ), Text( '${textureSizes[n].width.toInt()} x ' '${textureSizes[n].height.toInt()}', textScaleFactor: 1.0, ), const SizedBox(width: 6), ], ), ), ), ); }), ); } } ================================================ FILE: example/lib/edit_shader.dart ================================================ import 'package:flutter/material.dart'; import 'package:flutter/services.dart'; import 'package:flutter_opengl/flutter_opengl.dart'; /// Page to edit and compile the shader /// /// In this example there is button to add a vec3 "TEST" uniform /// and other 2 button to increase/decrease its x value. /// To test this: /// - add into the fragment shader the new uniform "uniform vec3 TEST;" /// - use "TEST.x" somewhere in the code /// - press the "compile shader" button /// - press the "add TEST" button /// - try the behavior by pressing the increment/decrement TEST buttons class EditShader extends StatelessWidget { const EditShader({ Key? key, }) : super(key: key); @override Widget build(BuildContext context) { double test = 0.1; ValueNotifier compileError = ValueNotifier(''); String vs = OpenGLController().openglFFI.getVertexShader(); String fs = OpenGLController().openglFFI.getFragmentShader(); TextEditingController vsController = TextEditingController(text: vs); TextEditingController fsController = TextEditingController(text: fs); InputDecoration inputDecoration = const InputDecoration( contentPadding: EdgeInsets.all(8), border: OutlineInputBorder(), filled: true, fillColor: Colors.black, ); return Column( children: [ Wrap( runSpacing: 4, spacing: 4, children: [ const SizedBox(width: 12), /// Compile button ElevatedButton( style: const ButtonStyle( backgroundColor: MaterialStatePropertyAll(Colors.green)), onPressed: () { String err = OpenGLController().openglFFI.setShader( true, vsController.text, fsController.text, ); compileError.value = err; if (err.isNotEmpty) { ScaffoldMessenger.of(context).showSnackBar(const SnackBar( content: Text('Error compiling shader'), duration: Duration(seconds: 2), )); } else { // When compiling a new shader, the ShaderToy uniforms // are not set by default like [setShaderToy()] does. // So add them programmatically OpenGLController().openglFFI.addShaderToyUniforms(); } }, child: const Text('compile shader'), ), /// TEST ElevatedButton( onPressed: () { test = 0.0; OpenGLController().openglFFI.addVec3Uniform( 'TEST', [test, 0.2, 0.3], ); }, child: const Text('add "TEST" vec3'), ), ElevatedButton( onPressed: () { OpenGLController().openglFFI.setVec3Uniform( 'TEST', [test, 0.2, 0.3], ); test += 0.1; }, child: const Text('"TEST.x +=0.1"'), ), ElevatedButton( onPressed: () { OpenGLController().openglFFI.setVec3Uniform( 'TEST', [test, 0.2, 0.3], ); test -= 0.1; }, child: const Text('"TEST.x -=0.1"'), ), ], ), const SizedBox(height: 12), /// compile error ValueListenableBuilder( valueListenable: compileError, builder: (_, err, __) { if (err.isEmpty) return const SizedBox.shrink(); return Padding( padding: const EdgeInsets.only(bottom: 12.0), child: ColoredBox( color: Colors.red, child: Padding( padding: const EdgeInsets.all(8.0), child: Text( err, style: const TextStyle( color: Colors.white, fontWeight: FontWeight.bold, ), ), ), ), ); }, ), /// Vertex and fragment sources Expanded( child: SingleChildScrollView( child: Column( crossAxisAlignment: CrossAxisAlignment.start, children: [ const Text( 'Vertex shader', textScaleFactor: 1.5, style: TextStyle(fontWeight: FontWeight.bold), ), TextField( controller: vsController, decoration: inputDecoration, expands: false, minLines: 1, maxLines: null, style: const TextStyle(fontFamily: "JetBrainsMono-Regular.ttf"), ), const SizedBox(height: 12), const Text( 'Fragment shader', textScaleFactor: 1.5, style: TextStyle(fontWeight: FontWeight.bold), ), TextField( controller: fsController, decoration: inputDecoration, expands: false, minLines: 1, maxLines: null, style: const TextStyle(fontFamily: "JetBrainsMono-Regular.ttf"), ), ], ), ), ), ], ); } } ================================================ FILE: example/lib/main.dart ================================================ import 'package:flutter/material.dart'; import 'package:flutter_opengl/flutter_opengl.dart'; void main() { OpenGLController().initializeGL(); runApp(const MaterialApp( home: MyApp(), )); } class MyApp extends StatelessWidget { const MyApp({Key? key}) : super(key: key); final String fShader = ''' // https://www.shadertoy.com/view/XlfGRj // Star Nest by Pablo Roman Andrioli #define iterations 17 #define formuparam 0.53 #define volsteps 20 #define stepsize 0.1 #define zoom 0.800 #define tile 0.850 #define speed 0.010 #define brightness 0.0015 #define darkmatter 0.300 #define distfading 0.730 #define saturation 0.850 void mainImage( out vec4 fragColor, in vec2 fragCoord ) { //get coords and direction vec2 uv=fragCoord.xy/iResolution.xy-.5; uv.y*=iResolution.y/iResolution.x; vec3 dir=vec3(uv*zoom,1.); float time=iTime*speed+.25; //mouse rotation float a1=.5+iMouse.x/iResolution.x*2.; float a2=.8+iMouse.y/iResolution.y*2.; mat2 rot1=mat2(cos(a1),sin(a1),-sin(a1),cos(a1)); mat2 rot2=mat2(cos(a2),sin(a2),-sin(a2),cos(a2)); dir.xz*=rot1; dir.xy*=rot2; vec3 from=vec3(1.,.5,0.5); from+=vec3(time*2.,time,-2.); from.xz*=rot1; from.xy*=rot2; //volumetric rendering float s=0.1,fade=1.; vec3 v=vec3(0.); for (int r=0; r6) fade*=1.-dm; // dark matter, don't render near //v+=vec3(dm,dm*.5,0.); v+=fade; v+=vec3(s,s*s,s*s*s*s)*a*brightness*fade; // coloring based on distance fade*=distfading; // distance fading s+=stepsize; } v=mix(vec3(length(v)),v,saturation); //color adjust fragColor = vec4(v*.01,1.); } '''; @override Widget build(BuildContext context) { return Scaffold( body: Center( child: SizedBox( width: 400, height: 300, child: FutureBuilder( /// The surface size identifies the real texture size and /// it is not related to the above SizedBox size future: OpenGLController().openglPlugin.createSurface(300, 200), builder: (_, snapshot) { if (snapshot.hasError || !snapshot.hasData) { return const SizedBox.shrink(); } /// When the texture id is got, it will be possible /// to start renderer, set a shader and display it /// Start renderer thread OpenGLController().openglFFI.startThread(); /// Set the fragment shader OpenGLController().openglFFI.setShaderToy(fShader); /// build the texture widget return OpenGLTexture(id: snapshot.data!); }, ), ), ), ); } } ================================================ FILE: example/lib/main_in_deep.dart ================================================ import 'dart:io'; import 'package:flutter/gestures.dart'; import 'package:flutter/material.dart'; import 'package:flutter_opengl/flutter_opengl.dart'; import 'package:flutter_opengl_example/controls/controls.dart'; import 'package:flutter_opengl_example/edit_shader.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:permission_handler/permission_handler.dart'; import 'package:url_launcher/url_launcher.dart'; import 'states.dart'; import 'test_widget.dart'; void main() { OpenGLController().initializeGL(); runApp(const ProviderScope(child: MyApp())); } class MyApp extends StatelessWidget { const MyApp({super.key}); @override Widget build(BuildContext context) { return MaterialApp( theme: ThemeData( primarySwatch: Colors.blue, brightness: Brightness.dark, ), home: const TextureAndTabs(), ); } } class TextureAndTabs extends ConsumerWidget { const TextureAndTabs({ Key? key, }) : super(key: key); @override Widget build(BuildContext context, WidgetRef ref) { final textureSize = ref.watch(stateTextureSize); final textureId = ref.watch(stateTextureId); if (Platform.isAndroid) { WidgetsBinding.instance.addPostFrameCallback((timeStamp) async { var status = await Permission.camera.status; if (status.isDenied) { await Permission.camera.request(); } status = await Permission.videos.status; if (status.isDenied) { await Permission.videos.request(); } status = await Permission.mediaLibrary.status; if (status.isDenied) { await Permission.mediaLibrary.request(); } status = await Permission.accessMediaLocation.status; if (status.isDenied) { await Permission.accessMediaLocation.request(); } }); } return DefaultTabController( length: 4, child: Scaffold( key: GlobalKey(), body: Padding( padding: const EdgeInsets.all(8.0), child: Column( mainAxisSize: MainAxisSize.max, children: [ /// FPS and ShaderToy URL text const UpperText(), const SizedBox(height: 8), /// TEXTURE AspectRatio( aspectRatio: textureSize.width / textureSize.height, child: textureId == -1 ? const ColoredBox(color: Colors.red) : OpenGLTexture(id: textureId)), const SizedBox( height: 40, child: TabBar( isScrollable: true, tabs: [ Tab(text: 'shaders'), Tab(text: 'edit shader'), Tab(text: 'test 1'), Tab(text: 'test 2'), ], ), ), const SizedBox(height: 12), /// TABS Expanded( child: TabBarView( physics: const NeverScrollableScrollPhysics(), children: [ Controls(), const EditShader(), const TestWidget(shaderToyCode: 'ls3cDB'), const TestWidget(shaderToyCode: 'XdXGR7'), ], ), ), ], ), ), ), ); } } /// FPS, texture size and shader URL /// class UpperText extends ConsumerWidget { const UpperText({ Key? key, }) : super(key: key); @override Widget build(BuildContext context, WidgetRef ref) { final fps = ref.watch(stateFPS); final shaderUrl = ref.watch(stateUrl); final textureSize = ref.watch(stateTextureSize); return Row( mainAxisSize: MainAxisSize.min, children: [ Text( '${fps.toStringAsFixed(1)} FPS\n' '${textureSize.width.toInt()} x ' '${textureSize.height.toInt()}', textAlign: TextAlign.center, textScaleFactor: 1.2), const SizedBox(width: 30), RichText( text: TextSpan( children: [ TextSpan( text: shaderUrl, style: const TextStyle( decoration: TextDecoration.underline, fontWeight: FontWeight.bold), recognizer: TapGestureRecognizer() ..onTap = () { launchUrl(Uri.parse(shaderUrl)); }, ), ], ), ), ], ); } } ================================================ FILE: example/lib/shader_widget.dart ================================================ import 'package:flutter/material.dart'; import 'package:flutter_opengl/flutter_opengl.dart'; import 'package:image/image.dart' as img; import 'shadertoy.dart'; /// Example widget that takes a child to be grabbed and used as /// a texture to feed the given shader. /// /// The renderer is activated by touching it, another touch /// to interact with the shader and another touch to terminate the renderer class ShaderWidget extends StatefulWidget { final Widget child; final int shaderToyIndex; const ShaderWidget({ Key? key, required this.shaderToyIndex, required this.child, }) : super(key: key); @override State createState() => _ShaderWidgetState(); } class _ShaderWidgetState extends State { GlobalKey childKey = GlobalKey(); int nClicks = 0; @override Widget build(BuildContext context) { return GestureDetector( onTapDown: (event) { if (nClicks == 0) { setState(() {}); } nClicks++; }, onTapUp: (event) { // stop renderer if (nClicks > 2) { OpenGLController().openglFFI.stopThread(); setState(() { nClicks = 0; }); } }, child: Stack( children: [ RepaintBoundary( key: childKey, child: widget.child, ), if (nClicks == 1) RendererWidget( childKeyToCapture: childKey, shaderToyIndex: widget.shaderToyIndex, ), ], ), ); } } class RendererWidget extends StatelessWidget { final GlobalKey childKeyToCapture; final int shaderToyIndex; const RendererWidget({ Key? key, required this.childKeyToCapture, required this.shaderToyIndex, }) : super(key: key); @override Widget build(BuildContext context) { // 1 - capture the widget // 2 - create OpenGL texture with the widget size // 3 - start renderer // 4 - set shader return FutureBuilder( future: OGLUtils.captureWidget(childKeyToCapture), builder: (context, captured) { if (!captured.hasData || captured.hasError || ((captured.data?.size ?? Size.zero) == Size.zero)) { return const SizedBox.shrink(); } // flip image data vertically img.Image flipped = img.Image.fromBytes( width: captured.data!.size.width.toInt(), height: captured.data!.size.height.toInt(), bytes: captured.data!.byteData.buffer, numChannels: 4, ); flipped = img.flipVertical(flipped); return FutureBuilder( // get texture id future: OpenGLController().openglPlugin.createSurface( captured.data!.size.width.toInt(), captured.data!.size.height.toInt(), ), builder: (context, textureId) { if (!textureId.hasData || textureId.hasError) { return const SizedBox.shrink(); } // set the shader OpenGLController().openglFFI.setShaderToy( shaderToy[shaderToyIndex]['fragment']!, ); // start renderer OpenGLController().openglFFI.startThread(); // Seems that on Windows the textures must be sent after // Texture() widget has been drawn? Future.delayed(const Duration(milliseconds: 0), () { // add the grabbed widget as texture on iChannel0 uniform OpenGLController().openglFFI.addSampler2DUniform( 'iChannel0', captured.data!.size.width.toInt(), captured.data!.size.height.toInt(), flipped.getBytes(order: img.ChannelOrder.rgba), ); // set the 2nd texture uniform OGLUtils.setAssetTexture('iChannel1', 'assets/texture.png'); }); return SizedBox( width: captured.data!.size.width, height: captured.data!.size.height, child: OpenGLTexture( id: textureId.data!, ), ); }, ); }, ); } } ================================================ FILE: example/lib/shadertoy.dart ================================================ /// Shaders taken from ShaderToy.com /// These are only fragment shaders /// Many of the shaders can be copy/pasted. /// Also many of them are heavy for mobile devices (few FPS) /// "iMouse", "iTime", "iResolution", "iChannel0" and "iChannel1" uniforms /// are currently supported List> shaderToy = [ // { // 'url': 'TEXTURE TEST', // 'fragment': // ''' // void mainImage( out vec4 fragColor, in vec2 fragCoord ) // { // vec2 iR = iResolution.xy; // vec2 uv = fragCoord/iR; // // float n = .5; // if (uv.x >= n-0.01 && uv.x <= n+0.01) // fragColor = vec4(1., 1., 0., 1.0); // // else // if (uv.y >= n-0.01 && uv.y <= n+0.01) // fragColor = vec4(1., 1., 0., 1.0); // // else // if (uv.x < n) { // fragColor = texture(iChannel0, uv); // } else { // fragColor = texture(iChannel1, uv); // // fragColor = vec4(0.,0.,0.,0.); // } // } // ''' // }, { // https://www.shadertoy.com/view/XsjXW1 'url': 'https://www.shadertoy.com/view/XsjXW1', 'fragment': ''' mat3 m = mat3( 0.00, 0.80, 0.60, -0.80, 0.36, -0.48, -0.60, -0.48, 0.64 ); // the backbone of any noise, or really any chaotic/natural/random looking // shader. hash basically maps an input value n to a random location in [0..1] // this function does have a period of TWO_PI but because the scaling factor // is so large there's significant differences between e.g. hash(0) and hash(TWO_PI) // the float data-type is not precise enough to be able to show the pattern even // in minute scales // and we're sampling with n ranging in the hundreds and thousands - it's basically // a reproducable random float hash( float n ) { return fract(sin(n)*43758.5453123); } // some random noise function that i can't really parse // most noise functions are basically chaotic but // still continuous mappings whose behavior is complex enough // that humans can't see the pattern float noise( in vec3 x ) { vec3 p = floor(x); vec3 f = fract(x); f = f*f*(3.0-2.0*f); float n = p.x + p.y*57.0 + 113.0*p.z; float res = mix(mix(mix( hash(n+ 0.0), hash(n+ 1.0),f.x), mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y), mix(mix( hash(n+113.0), hash(n+114.0),f.x), mix( hash(n+170.0), hash(n+171.0),f.x),f.y),f.z); return res; } // return an interpolated height and position for the given input // height algorithm: // partition 2d space into a set of 1x1 squares // each square has 4 corners; each corner's coordinate is associated // with a random height (and with a variable a-d), such that the same corner on two different squares has // the same value. Interpolate between the corners // depending on where in the 1x1 square you are. Linear interpolation // creates discontinuities at the edges, instead use a cubic hermite spline with slope 0 at the tangents - this ensures smoothness // of 2 degrees. /* x+ +------------> | | a b y| +----------+ +| | | | | | v | | | | | | +----------+ c d */ vec3 noised( in vec2 x ) { vec2 p = floor(x); vec2 f = fract(x); vec2 u = f*f*(3.0-2.0*f); float n = p.x + p.y*54.0; // heights of the four corners float a = hash(n+ 0.0); float b = hash(n+ 1.0); float c = hash(n+ 54.0); float d = hash(n+ 55.0); return vec3(a+(b-a)*u.x+(c-a)*u.y+(a-b-c+d)*u.x*u.y, // scalar function: f*f*(f*(f-2.0)+1.0) = f^2*(f-1)^2 = hump shape from [0..1] (*30 = goes up to 1.875 in the middle) // any function can serve as the scalar as long as it 1) goes to 0 at the edges, and 2) is continuous (and preferably is smooth as well) // the scalar affects how smooth the terrain is; a higher value will make the mountains more sharp // the actual yz vec2 is another returned value that to add more flavor to the noise. // You can use it as the basis of another noise, or (in the case of the caller here), // modify the .x with the .yz. // the vec2 function should reference a,b,c,d such that the function evaluates to the // same value on either side of the edge of the 1x1 square /* * if the formula is F(x), the following invariants should hold: * (1) F().y = F().y, x is an integer * (2) F().x = F().x, y is an integer * in (1), the scalar makes the x component go to 0, so only the y components must * be equal. Similarly in (2), the y component is multiplied by 0, so only the x * components should be equal. * With the invariants, transitioning between two cells of the 1x1 grid will be continuous */ 30.0*f*f*(f*(f-2.0)+1.0)*(vec2(b-a,c-a)+(a-b-c+d)*u.yx)); } float noise( in vec2 x ) { vec2 p = floor(x); vec2 f = fract(x); f = f*f*(3.0-2.0*f); float n = p.x + p.y*57.0; float res = mix(mix( hash(n+ 0.0), hash(n+ 1.0),f.x), mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y); return res; } float fbm( vec3 p ) { float f = 0.0; f += 0.5000*noise( p ); p = m*p*2.02; f += 0.2500*noise( p ); p = m*p*2.03; f += 0.1250*noise( p ); p = m*p*2.01; f += 0.0625*noise( p ); return f/0.9375; } mat2 m2 = mat2(1.6,-1.2,1.2,1.6); // fbm is a more complex noise, again harmonic // that takes several layers of noise at differing // scales and adds them up -- basically a more interesting // noise float fbm( vec2 p ) { float f = 0.0; f += 0.5000*noise( p ); p = m2*p*2.02; f += 0.2500*noise( p ); p = m2*p*2.03; f += 0.1250*noise( p ); p = m2*p*2.01; f += 0.0625*noise( p ); return f/0.9375; } // the height of the terrain at the given xy location float terrain( in vec2 x ) { // scale world coordinates down a lot vec2 p = x*0.003; float a = 0.0; float b = 1.0; vec2 d = vec2(0.0); // sample a base noise at different locations 5 times // and accumulate the sample into the final height // this is the technique of taking a simple noise // and making more interesting noise out of it by // doing harmonic sampling? is that what it's called for(int i=0;i<5; i++) { // random n vec3 n = noised(p); // d represents some "distance" away from some origin d += n.yz; // b is the octave attenuation (1, 0.5, 0.25, etc) // add this octave, which is scaled by the attenuation // factor and also by the distance factor a += b*n.x/(1.0+dot(d,d)); b *= 0.5; // not sure what how this matrix acts on p // i believe it's more or less a twist + expand p=m2*p; } return 140.0*a; } // same as terrain but go for 9 more iterations // this produces a much more fine-grained terrain function // that has goes deeper into the smaller scales of the terrain // so if terrain( x ) returned some value like 100, // terrain2( x ) returns a slightly more detailed value like 100.125 // or something - it's a purturbed version of normal terrain // but the purtubations also exhibit the fractal landscape behavior // that is characterstic of the land float terrain2( in vec2 x ) { vec2 p = x*0.003; float a = 0.0; float b = 1.0; vec2 d = vec2(0.0); for(int i=0;i<14; i++) { vec3 n = noised(p); d += n.yz; a += b*n.x/(1.0+dot(d,d)); b *= 0.5; p=m2*p; } return 140.0*a; } // takes in a world location and returns how vertically // far away you are from the terrain there // when used within raymarching this means that as the ray // is marching, since the map is continuous, you'll eventually // get within some small epsilon value of the actual terrain, // at which point you can count it as a hit float map( in vec3 p ) { // the height of the terrain at the location's xz plane float h = terrain(p.xz); // some sort of postprocessing of the height here // to give it more jagged edges // not sure how it really works yet float ss = 0.03; float hh = h*ss; // scale the height down a lot, decompose it into its fractional // and whole parts float fh = fract(hh); float ih = floor(hh); // transform fh by pushing it up towards its sqrt // by some amount depending on the height of the terrain you're at // fh corresponds to a height of ~33 in the terrain // the effect of this is that regularly at 33 pixel intervals, // the middle area of the interval gets pushed up towards the top // this creates more of a plateau effect which is more realistic // of actual terrain fh = mix( sqrt(fh), fh, smoothstep(50.0,140.0,h) ); // reconstruct h with the new fractional part h = (ih+fh)/ss; return p.y - h; } // same as map but using terrain2 float map2( in vec3 p ) { float h = terrain2(p.xz); float ss = 0.03; float hh = h*ss; float fh = fract(hh); float ih = floor(hh); fh = mix( sqrt(fh), fh, smoothstep(50.0,140.0,h) ); h = (ih+fh)/ss; return p.y - h; } // return whether the ray starting at rO and pointing at rD // hit the map or not. If it did, the distance from the origin to the hit // will be stored in resT // assumes rD is normalized bool jinteresct(in vec3 rO, in vec3 rD, out float resT ) { float h = 0.0; float t = 0.0; // march the ray forward 120 times for( int j=0; j<120; j++ ) { //if( t>2000.0 ) break; vec3 p = rO + t*rD; // break out of the iteration if you've passed some vertical // plane which guarantees you won't hit the map // (assumes the map is below 300); it's for performance i think? if( p.y>300.0 ) break; h = map( p ); // if you're within .1 units, count that as a hit on the terrain if( h<0.1 ) { resT = t; return true; } // t controls where your ray has been marched to // what iq is saying here is that if the height is // still large (that is, the ray is still quite vertically // away from hitting the terrain), you can jump the // ray much farther forward // the invariant here is that the terrain's slope is less than 2 // the invariant is broken sometimes which is where the strange // aliased banding that moves with the camera comes from // this is really cool -- you're dynamically sampling the terrain // based on how far away you are from it t += max(0.1,0.5*h); } // if you've reached here, you've gone 120 iterations and still // not hit the terrain, OR you've hit y = 300 // if you're within 5 units of the floor, just say you hit // not sure why he does this if( h<5.0 ) { resT = t; return true; } return false; } // this is called starting at the original ray's intersection point + 20*light1, in the direction of light1 // it calculates a long-range shadow with a soft-edge float sinteresct(in vec3 rO, in vec3 rD ) { float res = 1.0; float t = 0.0; for( int j=0; j<50; j++ ) { //if( t>1000.0 ) break; // cast a ray towards the light vec3 p = rO + t*rD; // track how far from the ground you are float h = map( p ); // if you've hit the ground, you're completely in the shadow if( h<0.1 ) { return 0.0; } // 16 * h/t? // 16 is an arbitrary scalar // h/t is the difference in height divided by the distance the ray has travelled res = min( res, 16.0*h/t ); // adding h is another performance gain - move the ray based on how far you away you are now // because the terrain is mostly smooth // you can basically analyze this as t will at some point get placed very near the actual minimum distance // away between the ray and the terrain // at that point, res will be set to h/t -- so farther-away terrains will cast shadows with a larger gradient // basically emulates the diffusive quality of light, also realy cool t += h; } return clamp( res, 0.0, 1.0 ); } // approximate the gradient of the terrain at pos by // moving in a small epsilon in each of the three directions // the epsilon is scaled by t, the distance of the point from // the camera. This means that points farther away // have a smoother normal calculation // the choice of epsilon has a massive effect on the percieved // detail of the terrain // the difference is clearly noticable if you have a small epsilon // on faraway points - there is a lot of aliasing since the effective // distance between two adjacent pixels that are both far away // is quite large. This achieves the same effect as mip-mapping in terms // of detail. You do in fact want to scale by `t` otherwise pixels far away // don't look connected vec3 calcNormal( in vec3 pos, float t ) { float e = 0.001 * t; vec3 eps = vec3(e,0.0,0.0); vec3 nor; nor.x = map2(pos+eps.xyy) - map2(pos-eps.xyy); nor.y = map2(pos+eps.yxy) - map2(pos-eps.yxy); nor.z = map2(pos+eps.yyx) - map2(pos-eps.yyx); return normalize(nor); } vec3 camPath( float time ) { vec2 p = 600.0*vec2( cos(1.4+0.37*time), cos(3.2+0.31*time) ); return vec3( p.x, 0.0, p.y ); } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { // maps screen from (-1, -1) on bottom-left to (1, 1) on top-right vec2 xy = -1.0 + 2.0*fragCoord.xy / iResolution.xy; // correct aspect ratio; y goes from -1 to 1, x goes from -1.75 to 1.75 (the aspect ratio is hard-coded to be 1.75) vec2 s = xy*vec2(1.75,1.0); float time = iTime*0.15; // diretional light coming down from the top vec3 light1 = normalize( vec3( 0.4, 0.22, 0.6 ) ); // a second light, probably directional vec3 light2 = vec3( -0.707, 0.000, -0.707 ); // camera position is set using two cosines at different speeds vec3 campos = camPath( time ); // target's always looking forward -- this is cool vec3 camtar = camPath( time + 3.0 ); campos.y = terrain( campos.xz ) + 15.0; // the eye is always just looking down camtar.y = campos.y*0.5; // roll the camera float roll = 0.1*cos(0.1*time); // cp is an upwards pointing vector in world space that wiggles slightly // it controls the up vector of the camera vec3 cp = vec3(sin(roll), cos(roll),0.0); // the direction the camera's pointing at vec3 cw = normalize(camtar-campos); // points to the "right" in the camera vec3 cu = normalize(cross(cw,cp)); // points "up" in the camera, basically cp projected onto the camera's // viewing plane vec3 cv = normalize(cross(cu,cw)); // direction of the ray to cast for this pixel // it's made of 3 components in camera space - // an amount to go horizontally, // an amount to go vertically, // and an amount to go outwards // that cw vector is needed otherwise the rays are always // perpendicular to the camera's viewing angle // the cw factor more or less controls the fov // (a large factor zooms the whole frustum in, a small factor // expands the fov out) // this is shoddily recreating a frustum, i don't // believe this is the right way to do this vec3 rd = normalize( s.x*cu + s.y*cv + 1.6*cw ); float sundot = clamp(dot(rd,light1),0.0,1.0); vec3 col; float t; // if your ray doesn't hit the ground, this pixel is hitting // the sky instead -- render the sky if( !jinteresct(campos,rd,t) ) { // sky is very light blue scaled by the ray's y position, // which is how high up the ray is; higher up means higher up // in the sky means a darker blue; // the y never goes past some small threshold // so the sky always looks *mostly* blue, but you can still see // the gradient col = 0.9*vec3(0.97,.99,1.0)*(1.0-0.3*rd.y); // this line adds a small amount of red-orangish color // mostly in a ring shape around where the "sun" would be col += 0.2*vec3(0.8,0.7,0.5)*pow( sundot, 4.0 ); } else { // here's where you hit vec3 pos = campos + t*rd; // the terrain normal at this location vec3 nor = calcNormal( pos, t ); //basic diffuse light calculation float dif1 = clamp( dot( light1, nor ), 0.0, 1.0 ); // i think this basically produces some ambient light as well? float dif2 = clamp( 0.2 + 0.8*dot( light2, nor ), 0.0, 1.0 ); // shadow factor -- 1 = no long-range shadow, 0 = completely in shadow float sh = 1.0; // if light1 hits me if( dif1>0.001 ) sh = sinteresct(pos+light1*20.0,light1); // dif1v is the color contribution of the diffuse of the first light source vec3 dif1v = vec3(dif1); // sh = iMouse.x / iResolution.x; // soft-shadow has a red coloring to it dif1v *= vec3( sh, sh*sh*0.5+0.5*sh, sh*sh ); // apply a simple random noise factor on the base ground color // just to give it a bit more flavor float r = noise( 7.0*pos.xz ); // here we begin coloring the terrain. The base color mixes between // a dark brown base color and a slightly more colorful brown at the top // terrain2 is used here as just another random noise function whose input scales // are on the same magnitude as the position; it's used to give the vertical bands // in the terrain float heightMix = clamp(terrain2( vec2(pos.x,pos.y*48.0))/200.0,0.0,1.0); col = (r*0.25+0.75)*0.9*mix( vec3(0.10,0.05,0.03), vec3(0.13,0.10,0.08), heightMix ); // mix the color with a more reddish hue if the normal points more up (how flat it is) col = mix( col, 0.17*vec3(0.5,.23,0.04)*(0.50+0.50*r),smoothstep(0.70,0.9,nor.y) ); // and if they're *really* flat, give it some green for grass col = mix( col, 0.10*vec3(0.2,.30,0.00)*(0.25+0.75*r),smoothstep(0.95,1.0,nor.y) ); col *= 0.75; // snow #if 1 // height factor -- higher places have more snow (h=1), lower places have no snow (h=0) float h = smoothstep(55.0,80.0,pos.y + 25.0*fbm(0.01*pos.xz) ); // normal+cliff factor -- land that is flatter gets more snow, cliff-like land doesn't get much snow // normal+cliff factor is also scaled by height, aka higher up the slope factor is stronger float e = smoothstep(1.0-0.5*h,1.0-0.1*h,nor.y); // wind directional factor -- if you have a high x slope, put less snow. // so hilly terrain that is going up in one direction will have snow, // going down on the other side will have no snow float o = 0.3 + 0.7*smoothstep(0.0,0.1,nor.x+h*h); float s = h*e*o; s = smoothstep( 0.1, 0.9, s ); // mix color with dark grey color for snow col = mix( col, 0.4*vec3(0.6,0.65,0.7), s ); #endif // final light calculation // start with a slope factor -- cliffs will be shaded slightly darker // this is most apparent when the cliff meets the ground; emulates ambient occlusion // a little bit vec3 brdf = 2.0*vec3(0.17,0.19,0.20)*clamp(nor.y,0.0,1.0); // most of the lighting comes from dif1 brdf += 6.0*vec3(1.00,0.95,0.80)*dif1v; // a bit from dif2, which is just a small ambient secondary light to complement the first brdf += 2.0*vec3(0.20,0.20,0.20)*dif2; // add all of the light col *= brdf; // fog factor - 0 at close distances, goes to 1. Has a slightly s shaped curve float fo = 1.0-exp(-pow(0.0015*t,1.5)); // fog color -- base 0.7; if you're looking towards the sun, make the fog the color of the sun // when there's a lot of fog in the distance, the fog carries the color of the sun and blends // it in with the actual surface color. This emulates that behavior vec3 fco = vec3(0.7) + 0.6*vec3(0.8,0.7,0.5)*pow( sundot, 4.0 ); col = mix( col, fco, fo ); } // postprocess filter; basically a sqrt color curve that helps the dark parts look brighter // a bit like a compressor audio effect; makes things a bit warmer in general col = sqrt(col); // (0, 0) to (1, 1) vec2 uv = xy*0.5+0.5; //create a slight inset shadow on the top corners col *= 0.7 + 0.3*pow(16.0*uv.x*uv.y*(1.0-uv.x)*(1.0-uv.y),0.1); // and we're done! fragColor=vec4(col,1.0); } ''' }, { // https://www.shadertoy.com/view/ltffzl 'url': 'https://www.shadertoy.com/view/ltffzl', 'fragment': ''' // Heartfelt - by Martijn Steinrucken aka BigWings - 2017 // Email:countfrolic@gmail.com Twitter:@The_ArtOfCode // License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. // I revisited the rain effect I did for another shader. This one is better in multiple ways: // 1. The glass gets foggy. // 2. Drops cut trails in the fog on the glass. // 3. The amount of rain is adjustable (with Mouse.y) // To have full control over the rain, uncomment the HAS_HEART define // A video of the effect can be found here: // https://www.youtube.com/watch?v=uiF5Tlw22PI&feature=youtu.be // Music - Alone In The Dark - Vadim Kiselev // https://soundcloud.com/ahmed-gado-1/sad-piano-alone-in-the-dark // Rain sounds: // https://soundcloud.com/elirtmusic/sleeping-sound-rain-and-thunder-1-hours #define S(a, b, t) smoothstep(a, b, t) //#define CHEAP_NORMALS #define HAS_HEART #define USE_POST_PROCESSING vec3 N13(float p) { // from DAVE HOSKINS vec3 p3 = fract(vec3(p) * vec3(.1031,.11369,.13787)); p3 += dot(p3, p3.yzx + 19.19); return fract(vec3((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y, (p3.y+p3.z)*p3.x)); } vec4 N14(float t) { return fract(sin(t*vec4(123., 1024., 1456., 264.))*vec4(6547., 345., 8799., 1564.)); } float N(float t) { return fract(sin(t*12345.564)*7658.76); } float Saw(float b, float t) { return S(0., b, t)*S(1., b, t); } vec2 DropLayer2(vec2 uv, float t) { vec2 UV = uv; uv.y += t*0.75; vec2 a = vec2(6., 1.); vec2 grid = a*2.; vec2 id = floor(uv*grid); float colShift = N(id.x); uv.y += colShift; id = floor(uv*grid); vec3 n = N13(id.x*35.2+id.y*2376.1); vec2 st = fract(uv*grid)-vec2(.5, 0); float x = n.x-.5; float y = UV.y*20.; float wiggle = sin(y+sin(y)); x += wiggle*(.5-abs(x))*(n.z-.5); x *= .7; float ti = fract(t+n.z); y = (Saw(.85, ti)-.5)*.9+.5; vec2 p = vec2(x, y); float d = length((st-p)*a.yx); float mainDrop = S(.4, .0, d); float r = sqrt(S(1., y, st.y)); float cd = abs(st.x-x); float trail = S(.23*r, .15*r*r, cd); float trailFront = S(-.02, .02, st.y-y); trail *= trailFront*r*r; y = UV.y; float trail2 = S(.2*r, .0, cd); float droplets = max(0., (sin(y*(1.-y)*120.)-st.y))*trail2*trailFront*n.z; y = fract(y*10.)+(st.y-.5); float dd = length(st-vec2(x, y)); droplets = S(.3, 0., dd); float m = mainDrop+droplets*r*trailFront; //m += st.x>a.y*.45 || st.y>a.x*.165 ? 1.2 : 0.; return vec2(m, trail); } float StaticDrops(vec2 uv, float t) { uv *= 40.; vec2 id = floor(uv); uv = fract(uv)-.5; vec3 n = N13(id.x*107.45+id.y*3543.654); vec2 p = (n.xy-.5)*.7; float d = length(uv-p); float fade = Saw(.025, fract(t+n.z)); float c = S(.3, 0., d)*fract(n.z*10.)*fade; return c; } vec2 Drops(vec2 uv, float t, float l0, float l1, float l2) { float s = StaticDrops(uv, t)*l0; vec2 m1 = DropLayer2(uv, t)*l1; vec2 m2 = DropLayer2(uv*1.85, t)*l2; float c = s+m1.x+m2.x; c = S(.3, 1., c); return vec2(c, max(m1.y*l0, m2.y*l1)); } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { vec2 uv = (fragCoord.xy-.5*iResolution.xy) / iResolution.y; vec2 UV = fragCoord.xy/iResolution.xy; vec3 M = iMouse.xyz/iResolution.xyz; float T = iTime+M.x*2.; #ifdef HAS_HEART T = mod(iTime, 102.); T = mix(T, M.x*102., M.z>0.?1.:0.); #endif float t = T*.2; float rainAmount = iMouse.z>0. ? M.y : sin(T*.05)*.3+.7; float maxBlur = mix(3., 6., rainAmount); float minBlur = 2.; float story = 0.; float heart = 0.; #ifdef HAS_HEART story = S(0., 70., T); t = min(1., T/70.); // remap drop time so it goes slower when it freezes t = 1.-t; t = (1.-t*t)*70.; float zoom= mix(.3, 1.2, story); // slowly zoom out uv *=zoom; minBlur = 4.+S(.5, 1., story)*3.; // more opaque glass towards the end maxBlur = 6.+S(.5, 1., story)*1.5; vec2 hv = uv-vec2(.0, -.1); // build heart hv.x *= .5; float s = S(110., 70., T); // heart gets smaller and fades towards the end hv.y-=sqrt(abs(hv.x))*.5*s; heart = length(hv); heart = S(.4*s, .2*s, heart)*s; rainAmount = heart; // the rain is where the heart is maxBlur-=heart; // inside the heart slighly less foggy uv *= 1.5; // zoom out a bit more t *= .25; #else float zoom = -cos(T*.2); uv *= .7+zoom*.3; #endif UV = (UV-.5)*(.9+zoom*.1)+.5; float staticDrops = S(-.5, 1., rainAmount)*2.; float layer1 = S(.25, .75, rainAmount); float layer2 = S(.0, .5, rainAmount); vec2 c = Drops(uv, t, staticDrops, layer1, layer2); #ifdef CHEAP_NORMALS vec2 n = vec2(dFdx(c.x), dFdy(c.x));// cheap normals (3x cheaper, but 2 times shittier ;)) #else vec2 e = vec2(.001, 0.); float cx = Drops(uv+e, t, staticDrops, layer1, layer2).x; float cy = Drops(uv+e.yx, t, staticDrops, layer1, layer2).x; vec2 n = vec2(cx-c.x, cy-c.x); // expensive normals #endif #ifdef HAS_HEART n *= 1.-S(60., 85., T); c.y *= 1.-S(80., 100., T)*.8; #endif float focus = mix(maxBlur-c.y, minBlur, S(.1, .2, c.x)); vec3 col = textureLod(iChannel0, UV+n, focus).rgb; #ifdef USE_POST_PROCESSING t = (T+3.)*.5; // make time sync with first lightnoing float colFade = sin(t*.2)*.5+.5+story; col *= mix(vec3(1.), vec3(.8, .9, 1.3), colFade); // subtle color shift float fade = S(0., 10., T); // fade in at the start float lightning = sin(t*sin(t*10.)); // lighting flicker lightning *= pow(max(0., sin(t+sin(t))), 10.); // lightning flash col *= 1.+lightning*fade*mix(1., .1, story*story); // composite lightning col *= 1.-dot(UV-=.5, UV); // vignette #ifdef HAS_HEART col = mix(pow(col, vec3(1.2)), col, heart); fade *= S(102., 97., T); #endif col *= fade; // composite start and end fade #endif //col = vec3(heart); fragColor = vec4(col, 1.); } ''' }, { // https://www.shadertoy.com/view/ls3cDB 'url': 'https://www.shadertoy.com/view/ls3cDB', 'fragment': ''' #define pi 3.14159265359 #define radius .1 void mainImage( out vec4 fragColor, in vec2 fragCoord ) { float aspect = iResolution.x / iResolution.y; vec2 uv = fragCoord * vec2(aspect, 1.) / iResolution.xy; vec2 mouse = iMouse.xy * vec2(aspect, 1.) / iResolution.xy; vec2 mouseDir = normalize(abs(iMouse.zw) - iMouse.xy); vec2 origin = clamp(mouse - mouseDir * mouse.x / mouseDir.x, 0., 1.); float mouseDist = clamp(length(mouse - origin) + (aspect - (abs(iMouse.z) / iResolution.x) * aspect) / mouseDir.x, 0., aspect / mouseDir.x); if (mouseDir.x < 0.) { mouseDist = distance(mouse, origin); } float proj = dot(uv - origin, mouseDir); float dist = proj - mouseDist; vec2 linePoint = uv - dist * mouseDir; if (dist > radius) { fragColor = texture(iChannel1, uv * vec2(1. / aspect, 1.)); fragColor.rgb *= pow(clamp(dist - radius, 0., 1.) * 1.5, .2); } else if (dist >= 0.) { // map to cylinder point float theta = asin(dist / radius); vec2 p2 = linePoint + mouseDir * (pi - theta) * radius; vec2 p1 = linePoint + mouseDir * theta * radius; uv = (p2.x <= aspect && p2.y <= 1. && p2.x > 0. && p2.y > 0.) ? p2 : p1; fragColor = texture(iChannel0, uv * vec2(1. / aspect, 1.)); fragColor.rgb *= pow(clamp((radius - dist) / radius, 0., 1.), .2); } else { vec2 p = linePoint + mouseDir * (abs(dist) + pi * radius); uv = (p.x <= aspect && p.y <= 1. && p.x > 0. && p.y > 0.) ? p : uv; fragColor = texture(iChannel0, uv * vec2(1. / aspect, 1.)); } } ''' }, { // https://www.shadertoy.com/view/Xdl3D8 'url': 'https://www.shadertoy.com/view/Xdl3D8', 'fragment': ''' // The MIT License // Copyright © 2013 Javier Meseguer // 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. #define BLACK_AND_WHITE #define LINES_AND_FLICKER #define BLOTCHES #define GRAIN #define FREQUENCY 15.0 vec2 uv; float rand(vec2 co){ return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); } float rand(float c){ return rand(vec2(c,1.0)); } float randomLine(float seed) { float b = 0.01 * rand(seed); float a = rand(seed+1.0); float c = rand(seed+2.0) - 0.5; float mu = rand(seed+3.0); float l = 1.0; if ( mu > 0.2) l = pow( abs(a * uv.x + b * uv.y + c ), 1.0/8.0 ); else l = 2.0 - pow( abs(a * uv.x + b * uv.y + c), 1.0/8.0 ); return mix(0.5, 1.0, l); } // Generate some blotches. float randomBlotch(float seed) { float x = rand(seed); float y = rand(seed+1.0); float s = 0.01 * rand(seed+2.0); vec2 p = vec2(x,y) - uv; p.x *= iResolution.x / iResolution.y; float a = atan(p.y,p.x); float v = 1.0; float ss = s*s * (sin(6.2831*a*x)*0.1 + 1.0); if ( dot(p,p) < ss ) v = 0.2; else v = pow(dot(p,p) - ss, 1.0/16.0); return mix(0.3 + 0.2 * (1.0 - (s / 0.02)), 1.0, v); } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { uv = fragCoord.xy / iResolution.xy; if ( iMouse.z < 0.9 ) { // Set frequency of global effect to 15 variations per second float t = float(int(iTime * FREQUENCY)); // Get some image movement vec2 suv = uv + 0.002 * vec2( rand(t), rand(t + 23.0)); // Get the image vec3 image = texture( iChannel0, vec2(suv.x, suv.y) ).xyz; #ifdef BLACK_AND_WHITE // Convert it to B/W float luma = dot( vec3(0.2126, 0.7152, 0.0722), image ); vec3 oldImage = luma * vec3(0.7, 0.7, 0.7); #else vec3 oldImage = image; #endif // Create a time-varying vignetting effect float vI = 16.0 * (uv.x * (1.0-uv.x) * uv.y * (1.0-uv.y)); vI *= mix( 0.7, 1.0, rand(t + 0.5)); // Add additive flicker vI += 1.0 + 0.4 * rand(t+8.); // Add a fixed vignetting (independent of the flicker) vI *= pow(16.0 * uv.x * (1.0-uv.x) * uv.y * (1.0-uv.y), 0.4); // Add some random lines (and some multiplicative flicker. Oh well.) #ifdef LINES_AND_FLICKER int l = int(8.0 * rand(t+7.0)); if ( 0 < l ) vI *= randomLine( t+6.0+17.* float(0)); if ( 1 < l ) vI *= randomLine( t+6.0+17.* float(1)); if ( 2 < l ) vI *= randomLine( t+6.0+17.* float(2)); if ( 3 < l ) vI *= randomLine( t+6.0+17.* float(3)); if ( 4 < l ) vI *= randomLine( t+6.0+17.* float(4)); if ( 5 < l ) vI *= randomLine( t+6.0+17.* float(5)); if ( 6 < l ) vI *= randomLine( t+6.0+17.* float(6)); if ( 7 < l ) vI *= randomLine( t+6.0+17.* float(7)); #endif // Add some random blotches. #ifdef BLOTCHES int s = int( max(8.0 * rand(t+18.0) -2.0, 0.0 )); if ( 0 < s ) vI *= randomBlotch( t+6.0+19.* float(0)); if ( 1 < s ) vI *= randomBlotch( t+6.0+19.* float(1)); if ( 2 < s ) vI *= randomBlotch( t+6.0+19.* float(2)); if ( 3 < s ) vI *= randomBlotch( t+6.0+19.* float(3)); if ( 4 < s ) vI *= randomBlotch( t+6.0+19.* float(4)); if ( 5 < s ) vI *= randomBlotch( t+6.0+19.* float(5)); #endif // Show the image modulated by the defects fragColor.xyz = oldImage * vI; // Add some grain (thanks, Jose!) #ifdef GRAIN fragColor.xyz *= (1.0+(rand(uv+t*.01)-.2)*.15); #endif } else { fragColor = texture( iChannel0, uv ); } } ''' }, { // https://www.shadertoy.com/view/XdXGR7 'url': 'https://www.shadertoy.com/view/XdXGR7', 'fragment': ''' const float PI = 3.14159265359; #define time (-iTime*5.0) const vec3 eps = vec3(0.01, 0.0, 0.0); float genWave1(float len) { float wave = sin(8.0 * PI * len + time); wave = (wave + 1.0) * 0.5; // <0 ; 1> wave -= 0.3; wave *= wave * wave; return wave; } float genWave2(float len) { float wave = sin(7.0 * PI * len + time); float wavePow = 1.0 - pow(abs(wave*1.1), 0.8); wave = wavePow * wave; return wave; } float scene(float len) { // you can select type of waves return genWave1(len); } vec2 normal(float len) { float tg = (scene(len + eps.x) - scene(len)) / eps.x; return normalize(vec2(-tg, 1.0)); } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { vec2 uv = fragCoord.xy / iResolution.xy; vec2 so = iMouse.xy / iResolution.xy; vec2 pos2 = vec2(uv - so); //wave origin vec2 pos2n = normalize(pos2); float len = length(pos2); float wave = scene(len); vec2 uv2 = -pos2n * wave/(1.0 + 5.0 * len); fragColor = vec4(texture(iChannel0, uv + uv2)); } ''' }, { // https://www.shadertoy.com/view/XlfGRj 'url': 'https://www.shadertoy.com/view/XlfGRj', 'fragment': ''' /*-------------------------------------------------------------------------------------- License CC0 - http://creativecommons.org/publicdomain/zero/1.0/ To the extent possible under law, the author(s) have dedicated all copyright and related and neighboring rights to this software to the public domain worldwide. This software is distributed without any warranty. ---------------------------------------------------------------------------------------- ^ This means do ANYTHING YOU WANT with this code. Because we are programmers, not lawyers. -Otavio Good */ // ---------------- Config ---------------- // This is an option that lets you render high quality frames for screenshots. It enables // stochastic antialiasing and motion blur automatically for any shader. //#define NON_REALTIME_HQ_RENDER const float frameToRenderHQ = 50.0; // Time in seconds of frame to render const float antialiasingSamples = 16.0; // 16x antialiasing - too much might make the shader compiler angry. //#define MANUAL_CAMERA // -------------------------------------------------------- // These variables are for the non-realtime block renderer. float localTime = 0.0; float seed = 1.0; // Animation variables float fade = 1.0; vec3 sunDir; vec3 sunCol; float exposure = 1.0; vec3 skyCol, horizonCol; // other float marchCount = 0.0; // ---- noise functions ---- float v31(vec3 a) { return a.x + a.y * 37.0 + a.z * 521.0; } float v21(vec2 a) { return a.x + a.y * 37.0; } float Hash11(float a) { return fract(sin(a)*10403.9); } float Hash21(vec2 uv) { float f = uv.x + uv.y * 37.0; return fract(sin(f)*104003.9); } vec2 Hash22(vec2 uv) { float f = uv.x + uv.y * 37.0; return fract(cos(f)*vec2(10003.579, 37049.7)); } vec2 Hash12(float f) { return fract(cos(f)*vec2(10003.579, 37049.7)); } float Hash1d(float u) { return fract(sin(u)*143.9); // scale this down to kill the jitters } float Hash2d(vec2 uv) { float f = uv.x + uv.y * 37.0; return fract(sin(f)*104003.9); } float Hash3d(vec3 uv) { float f = uv.x + uv.y * 37.0 + uv.z * 521.0; return fract(sin(f)*110003.9); } float mixP(float f0, float f1, float a) { return mix(f0, f1, a*a*(3.0-2.0*a)); } const vec2 zeroOne = vec2(0.0, 1.0); float noise2d(vec2 uv) { vec2 fr = fract(uv.xy); vec2 fl = floor(uv.xy); float h00 = Hash2d(fl); float h10 = Hash2d(fl + zeroOne.yx); float h01 = Hash2d(fl + zeroOne); float h11 = Hash2d(fl + zeroOne.yy); return mixP(mixP(h00, h10, fr.x), mixP(h01, h11, fr.x), fr.y); } float noise(vec3 uv) { vec3 fr = fract(uv.xyz); vec3 fl = floor(uv.xyz); float h000 = Hash3d(fl); float h100 = Hash3d(fl + zeroOne.yxx); float h010 = Hash3d(fl + zeroOne.xyx); float h110 = Hash3d(fl + zeroOne.yyx); float h001 = Hash3d(fl + zeroOne.xxy); float h101 = Hash3d(fl + zeroOne.yxy); float h011 = Hash3d(fl + zeroOne.xyy); float h111 = Hash3d(fl + zeroOne.yyy); return mixP( mixP(mixP(h000, h100, fr.x), mixP(h010, h110, fr.x), fr.y), mixP(mixP(h001, h101, fr.x), mixP(h011, h111, fr.x), fr.y) , fr.z); } const float PI=3.14159265; vec3 saturate(vec3 a) { return clamp(a, 0.0, 1.0); } vec2 saturate(vec2 a) { return clamp(a, 0.0, 1.0); } float saturate(float a) { return clamp(a, 0.0, 1.0); } // This function basically is a procedural environment map that makes the sun vec3 GetSunColorSmall(vec3 rayDir, vec3 sunDir) { vec3 localRay = normalize(rayDir); float dist = 1.0 - (dot(localRay, sunDir) * 0.5 + 0.5); float sunIntensity = 0.05 / dist; sunIntensity += exp(-dist*150.0)*7000.0; sunIntensity = min(sunIntensity, 40000.0); return sunCol * sunIntensity*0.025; } vec3 GetEnvMap(vec3 rayDir, vec3 sunDir) { // fade the sky color, multiply sunset dimming vec3 finalColor = mix(horizonCol, skyCol, pow(saturate(rayDir.y), 0.47))*0.95; // make clouds - just a horizontal plane with noise float n = noise2d(rayDir.xz/rayDir.y*1.0); n += noise2d(rayDir.xz/rayDir.y*2.0)*0.5; n += noise2d(rayDir.xz/rayDir.y*4.0)*0.25; n += noise2d(rayDir.xz/rayDir.y*8.0)*0.125; n = pow(abs(n), 3.0); n = mix(n * 0.2, n, saturate(abs(rayDir.y * 8.0))); // fade clouds in distance finalColor = mix(finalColor, (vec3(1.0)+sunCol*10.0)*0.75*saturate((rayDir.y+0.2)*5.0), saturate(n*0.125)); // add the sun finalColor += GetSunColorSmall(rayDir, sunDir); return finalColor; } vec3 GetEnvMapSkyline(vec3 rayDir, vec3 sunDir, float height) { vec3 finalColor = GetEnvMap(rayDir, sunDir); // Make a skyscraper skyline reflection. float radial = atan(rayDir.z, rayDir.x)*4.0; float skyline = floor((sin(5.3456*radial) + sin(1.234*radial)+ sin(2.177*radial))*0.6); radial *= 4.0; skyline += floor((sin(5.0*radial) + sin(1.234*radial)+ sin(2.177*radial))*0.6)*0.1; float mask = saturate((rayDir.y*8.0 - skyline-2.5+height)*24.0); float vert = sign(sin(radial*32.0))*0.5+0.5; float hor = sign(sin(rayDir.y*256.0))*0.5+0.5; mask = saturate(mask + (1.0-hor*vert)*0.05); finalColor = mix(finalColor * vec3(0.1,0.07,0.05), finalColor, mask); return finalColor; } // min function that supports materials in the y component vec2 matmin(vec2 a, vec2 b) { if (a.x < b.x) return a; else return b; } // ---- shapes defined by distance fields ---- // See this site for a reference to more distance functions... // https://iquilezles.org/articles/distfunctions // signed box distance field float sdBox(vec3 p, vec3 radius) { vec3 dist = abs(p) - radius; return min(max(dist.x, max(dist.y, dist.z)), 0.0) + length(max(dist, 0.0)); } // capped cylinder distance field float cylCap(vec3 p, float r, float lenRad) { float a = length(p.xy) - r; a = max(a, abs(p.z) - lenRad); return a; } // k should be negative. -4.0 works nicely. // smooth blending function float smin(float a, float b, float k) { return log2(exp2(k*a)+exp2(k*b))/k; } float Repeat(float a, float len) { return mod(a, len) - 0.5 * len; } // Distance function that defines the car. // Basically it's 2 boxes smooth-blended together and a mirrored cylinder for the wheels. vec2 Car(vec3 baseCenter, float unique) { // bottom box float car = sdBox(baseCenter + vec3(0.0, -0.008, 0.001), vec3(0.01, 0.00225, 0.0275)); // top box smooth blended car = smin(car, sdBox(baseCenter + vec3(0.0, -0.016, 0.008), vec3(0.005, 0.0005, 0.01)), -160.0); // mirror the z axis to duplicate the cylinders for wheels vec3 wMirror = baseCenter + vec3(0.0, -0.005, 0.0); wMirror.z = abs(wMirror.z)-0.02; float wheels = cylCap((wMirror).zyx, 0.004, 0.0135); // Set materials vec2 distAndMat = vec2(wheels, 3.0); // car wheels // Car material is some big number that's unique to each car // so I can have each car be a different color distAndMat = matmin(distAndMat, vec2(car, 100000.0 + unique)); // car return distAndMat; } // How much space between voxel borders and geometry for voxel ray march optimization float voxelPad = 0.2; // p should be in [0..1] range on xz plane // pint is an integer pair saying which city block you are on vec2 CityBlock(vec3 p, vec2 pint) { // Get random numbers for this block by hashing the city block variable vec4 rand; rand.xy = Hash22(pint); rand.zw = Hash22(rand.xy); vec2 rand2 = Hash22(rand.zw); // Radius of the building float baseRad = 0.2 + (rand.x) * 0.1; baseRad = floor(baseRad * 20.0+0.5)/20.0; // try to snap this for window texture // make position relative to the middle of the block vec3 baseCenter = p - vec3(0.5, 0.0, 0.5); float height = rand.w*rand.z + 0.1; // height of first building block // Make the city skyline higher in the middle of the city. float downtown = saturate(4.0 / length(pint.xy)); height *= downtown; height *= 1.5+(baseRad-0.15)*20.0; height += 0.1; // minimum building height //height += sin(iTime + pint.x); // animate the building heights if you're feeling silly height = floor(height*20.0)*0.05; // height is in floor units - each floor is 0.05 high. float d = sdBox(baseCenter, vec3(baseRad, height, baseRad)); // large building piece // road d = min(d, p.y); //if (length(pint.xy) > 8.0) return vec2(d, mat); // Hack to LOD in the distance // height of second building section float height2 = max(0.0, rand.y * 2.0 - 1.0) * downtown; height2 = floor(height2*20.0)*0.05; // floor units rand2 = floor(rand2*20.0)*0.05; // floor units // size pieces of building d = min(d, sdBox(baseCenter - vec3(0.0, height, 0.0), vec3(baseRad, height2 - rand2.y, baseRad*0.4))); d = min(d, sdBox(baseCenter - vec3(0.0, height, 0.0), vec3(baseRad*0.4, height2 - rand2.x, baseRad))); // second building section if (rand2.y > 0.25) { d = min(d, sdBox(baseCenter - vec3(0.0, height, 0.0), vec3(baseRad*0.8, height2, baseRad*0.8))); // subtract off piece from top so it looks like there's a wall around the roof. float topWidth = baseRad; if (height2 > 0.0) topWidth = baseRad * 0.8; d = max(d, -sdBox(baseCenter - vec3(0.0, height+height2, 0.0), vec3(topWidth-0.0125, 0.015, topWidth-0.0125))); } else { // Cylinder top section of building if (height2 > 0.0) d = min(d, cylCap((baseCenter - vec3(0.0, height, 0.0)).xzy, baseRad*0.8, height2)); } // mini elevator shaft boxes on top of building d = min(d, sdBox(baseCenter - vec3((rand.x-0.5)*baseRad, height+height2, (rand.y-0.5)*baseRad), vec3(baseRad*0.3*rand.z, 0.1*rand2.y, baseRad*0.3*rand2.x+0.025))); // mirror another box (and scale it) so we get 2 boxes for the price of 1. vec3 boxPos = baseCenter - vec3((rand2.x-0.5)*baseRad, height+height2, (rand2.y-0.5)*baseRad); float big = sign(boxPos.x); boxPos.x = abs(boxPos.x)-0.02 - baseRad*0.3*rand.w; d = min(d, sdBox(boxPos, vec3(baseRad*0.3*rand.w, 0.07*rand.y, baseRad*0.2*rand.x + big*0.025))); // Put domes on some building tops for variety if (rand.y < 0.04) { d = min(d, length(baseCenter - vec3(0.0, height, 0.0)) - baseRad*0.8); } //d = max(d, p.y); // flatten the city for debugging cars // Need to make a material variable. vec2 distAndMat = vec2(d, 0.0); // sidewalk box with material distAndMat = matmin(distAndMat, vec2(sdBox(baseCenter, vec3(0.35, 0.005, 0.35)), 1.0)); return distAndMat; } // This is the distance function that defines all the scene's geometry. // The input is a position in space. // The output is the distance to the nearest surface and a material index. vec2 DistanceToObject(vec3 p) { //p.y += noise2d((p.xz)*0.0625)*8.0; // Hills vec3 rep = p; rep.xz = fract(p.xz); // [0..1] for representing the position in the city block vec2 distAndMat = CityBlock(rep, floor(p.xz)); // Set up the cars. This is doing a lot of mirroring and repeating because I // only want to do a single call to the car distance function for all the // cars in the scene. And there's a lot of traffic! vec3 p2 = p; rep.xyz = p2; float carTime = localTime*0.2; // Speed of car driving float crossStreet = 1.0; // whether we are north/south or east/west float repeatDist = 0.25; // Car density bumper to bumper // If we are going north/south instead of east/west (?) make cars that are // stopped in the street so we don't have collisions. if (abs(fract(rep.x)-0.5) < 0.35) { p2.x += 0.05; p2.xz = p2.zx * vec2(-1.0,1.0); // Rotate 90 degrees rep.xz = p2.xz; crossStreet = 0.0; repeatDist = 0.1; // Denser traffic on cross streets } rep.z += floor(p2.x); // shift so less repitition between parallel blocks rep.x = Repeat(p2.x - 0.5, 1.0); // repeat every block rep.z = rep.z*sign(rep.x); // mirror but keep cars facing the right way rep.x = (rep.x*sign(rep.x))-0.09; rep.z -= carTime * crossStreet; // make cars move float uniqueID = floor(rep.z/repeatDist); // each car gets a unique ID that we can use for colors rep.z = Repeat(rep.z, repeatDist); // repeat the line of cars every quarter block rep.x += (Hash11(uniqueID)*0.075-0.01); // nudge cars left and right to take both lanes float frontBack = Hash11(uniqueID*0.987)*0.18-0.09; frontBack *= sin(localTime*2.0 + uniqueID); rep.z += frontBack * crossStreet; // nudge cars forward back for variation vec2 carDist = Car(rep, uniqueID); // car distance function // Drop the cars in the scene with materials distAndMat = matmin(distAndMat, carDist); return distAndMat; } // This basically makes a procedural texture map for the sides of the buildings. // It makes a texture, a normal for normal mapping, and a mask for window reflection. void CalcWindows(vec2 block, vec3 pos, inout vec3 texColor, inout float windowRef, inout vec3 normal) { vec3 hue = vec3(Hash21(block)*0.8, Hash21(block*7.89)*0.4, Hash21(block*37.89)*0.5); texColor += hue*0.4; texColor *= 0.75; float window = 0.0; window = max(window, mix(0.2, 1.0, floor(fract(pos.y*20.0-0.35)*2.0+0.1))); if (pos.y < 0.05) window = 1.0; float winWidth = Hash21(block*4.321)*2.0; if ((winWidth < 1.3) && (winWidth >= 1.0)) winWidth = 1.3; window = max(window, mix(0.2, 1.0, floor(fract(pos.x * 40.0+0.05)*winWidth))); window = max(window, mix(0.2, 1.0, floor(fract(pos.z * 40.0+0.05)*winWidth))); if (window < 0.5) { windowRef += 1.0; } window *= Hash21(block*1.123); texColor *= window; float wave = floor(sin((pos.y*40.0-0.1)*PI)*0.505-0.5)+1.0; normal.y -= max(-1.0, min(1.0, -wave*0.5)); float pits = min(1.0, abs(sin((pos.z*80.0)*PI))*4.0)-1.0; normal.z += pits*0.25; pits = min(1.0, abs(sin((pos.x*80.0)*PI))*4.0)-1.0; normal.x += pits*0.25; } // Input is UV coordinate of pixel to render. // Output is RGB color. vec3 RayTrace(in vec2 fragCoord ) { marchCount = 0.0; // -------------------------------- animate --------------------------------------- sunCol = vec3(258.0, 248.0, 200.0) / 3555.0; sunDir = normalize(vec3(0.93, 1.0, 1.0)); horizonCol = vec3(1.0, 0.95, 0.85)*0.9; skyCol = vec3(0.3,0.5,0.95); exposure = 1.0; fade = 1.0; vec3 camPos, camUp, camLookat; // ------------------- Set up the camera rays for ray marching -------------------- // Map uv to [-1.0..1.0] vec2 uv = fragCoord.xy/iResolution.xy * 2.0 - 1.0; uv /= 2.0; // zoom in #ifdef MANUAL_CAMERA // Camera up vector. camUp=vec3(0,1,0); // Camera lookat. camLookat=vec3(0,0.0,0); // debugging camera float mx=-iMouse.x/iResolution.x*PI*2.0;// + localTime * 0.05; float my=iMouse.y/iResolution.y*3.14*0.5 + PI/2.0;// + sin(localTime * 0.3)*0.8+0.1;//*PI/2.01; camPos = vec3(cos(my)*cos(mx),sin(my),cos(my)*sin(mx))*7.35;//7.35 #else // Do the camera fly-by animation and different scenes. // Time variables for start and end of each scene const float t0 = 0.0; const float t1 = 8.0; const float t2 = 14.0; const float t3 = 24.0; const float t4 = 38.0; const float t5 = 56.0; const float t6 = 58.0; /*const float t0 = 0.0; const float t1 = 0.0; const float t2 = 0.0; const float t3 = 0.0; const float t4 = 0.0; const float t5 = 16.0; const float t6 = 18.0;*/ // Repeat the animation after time t6 localTime = fract(localTime / t6) * t6; if (localTime < t1) { float time = localTime - t0; float alpha = time / (t1 - t0); fade = saturate(time); fade *= saturate(t1 - localTime); camPos = vec3(13.0, 3.3, -3.5); camPos.x -= smoothstep(0.0, 1.0, alpha) * 4.8; camUp=vec3(0,1,0); camLookat=vec3(0,1.5,1.5); } else if (localTime < t2) { float time = localTime - t1; float alpha = time / (t2 - t1); fade = saturate(time); fade *= saturate(t2 - localTime); camPos = vec3(26.0, 0.05+smoothstep(0.0, 1.0, alpha)*0.4, 2.0); camPos.z -= alpha * 2.8; camUp=vec3(0,1,0); camLookat=vec3(camPos.x-0.3,-8.15,-40.0); sunDir = normalize(vec3(0.95, 0.6, 1.0)); sunCol = vec3(258.0, 248.0, 160.0) / 3555.0; exposure *= 0.7; skyCol *= 1.5; } else if (localTime < t3) { float time = localTime - t2; float alpha = time / (t3 - t2); fade = saturate(time); fade *= saturate(t3 - localTime); camPos = vec3(12.0, 6.3, -0.5); camPos.y -= alpha * 5.5; camPos.x = cos(alpha*1.0) * 5.2; camPos.z = sin(alpha*1.0) * 5.2; camUp=normalize(vec3(0,1,-0.5 + alpha * 0.5)); camLookat=vec3(0,1.0,-0.5); } else if (localTime < t4) { float time = localTime - t3; float alpha = time / (t4 - t3); fade = saturate(time); fade *= saturate(t4 - localTime); camPos = vec3(2.15-alpha*0.5, 0.02, -1.0-alpha*0.2); camPos.y += smoothstep(0.0,1.0,alpha*alpha) * 3.4; camUp=normalize(vec3(0,1,0.0)); camLookat=vec3(0,0.5+alpha,alpha*5.0); } else if (localTime < t5) { float time = localTime - t4; float alpha = time / (t5 - t4); fade = saturate(time); fade *= saturate(t5 - localTime); camPos = vec3(-2.0, 1.3- alpha*1.2, -10.5-alpha*0.5); camUp=normalize(vec3(0,1,0.0)); camLookat=vec3(-2.0,0.3+alpha,-0.0); sunDir = normalize(vec3(0.5-alpha*0.6, 0.3-alpha*0.3, 1.0)); sunCol = vec3(258.0, 148.0, 60.0) / 3555.0; localTime *= 16.0; exposure *= 0.4; horizonCol = vec3(1.0, 0.5, 0.35)*2.0; skyCol = vec3(0.75,0.5,0.95); } else if (localTime < t6) { fade = 0.0; camPos = vec3(26.0, 100.0, 2.0); camUp=vec3(0,1,0); camLookat=vec3(0.3,0.15,0.0); } #endif // Camera setup for ray tracing / marching vec3 camVec=normalize(camLookat - camPos); vec3 sideNorm=normalize(cross(camUp, camVec)); vec3 upNorm=cross(camVec, sideNorm); vec3 worldFacing=(camPos + camVec); vec3 worldPix = worldFacing + uv.x * sideNorm * (iResolution.x/iResolution.y) + uv.y * upNorm; vec3 rayVec = normalize(worldPix - camPos); // ----------------------------- Ray march the scene ------------------------------ vec2 distAndMat; // Distance and material float t = 0.05;// + Hash2d(uv)*0.1; // random dither-fade things close to the camera const float maxDepth = 45.0; // farthest distance rays will travel vec3 pos = vec3(0.0); const float smallVal = 0.000625; // ray marching time for (int i = 0; i < 250; i++) // This is the count of the max times the ray actually marches. { marchCount+=1.0; // Step along the ray. pos = (camPos + rayVec * t); // This is _the_ function that defines the "distance field". // It's really what makes the scene geometry. The idea is that the // distance field returns the distance to the closest object, and then // we know we are safe to "march" along the ray by that much distance // without hitting anything. We repeat this until we get really close // and then break because we have effectively hit the object. distAndMat = DistanceToObject(pos); // 2d voxel walk through the city blocks. // The distance function is not continuous at city block boundaries, // so we have to pause our ray march at each voxel boundary. float walk = distAndMat.x; float dx = -fract(pos.x); if (rayVec.x > 0.0) dx = fract(-pos.x); float dz = -fract(pos.z); if (rayVec.z > 0.0) dz = fract(-pos.z); float nearestVoxel = min(fract(dx/rayVec.x), fract(dz/rayVec.z))+voxelPad; nearestVoxel = max(voxelPad, nearestVoxel);// hack that assumes streets and sidewalks are this wide. //nearestVoxel = max(nearestVoxel, t * 0.02); // hack to stop voxel walking in the distance. walk = min(walk, nearestVoxel); // move down the ray a safe amount t += walk; // If we are very close to the object, let's call it a hit and exit this loop. if ((t > maxDepth) || (abs(distAndMat.x) < smallVal)) break; } // Ray trace a ground plane to infinity float alpha = -camPos.y / rayVec.y; if ((t > maxDepth) && (rayVec.y < -0.0)) { pos.xz = camPos.xz + rayVec.xz * alpha; pos.y = -0.0; t = alpha; distAndMat.y = 0.0; distAndMat.x = 0.0; } // -------------------------------------------------------------------------------- // Now that we have done our ray marching, let's put some color on this geometry. vec3 finalColor = vec3(0.0); // If a ray actually hit the object, let's light it. if ((t <= maxDepth) || (t == alpha)) { float dist = distAndMat.x; // calculate the normal from the distance field. The distance field is a volume, so if you // sample the current point and neighboring points, you can use the difference to get // the normal. vec3 smallVec = vec3(smallVal, 0, 0); vec3 normalU = vec3(dist - DistanceToObject(pos - smallVec.xyy).x, dist - DistanceToObject(pos - smallVec.yxy).x, dist - DistanceToObject(pos - smallVec.yyx).x); vec3 normal = normalize(normalU); // calculate 2 ambient occlusion values. One for global stuff and one // for local stuff float ambientS = 1.0; ambientS *= saturate(DistanceToObject(pos + normal * 0.0125).x*80.0); ambientS *= saturate(DistanceToObject(pos + normal * 0.025).x*40.0); ambientS *= saturate(DistanceToObject(pos + normal * 0.05).x*20.0); ambientS *= saturate(DistanceToObject(pos + normal * 0.1).x*10.0); ambientS *= saturate(DistanceToObject(pos + normal * 0.2).x*5.0); ambientS *= saturate(DistanceToObject(pos + normal * 0.4).x*2.5); //ambientS *= saturate(DistanceToObject(pos + normal * 0.8).x*1.25); float ambient = ambientS;// * saturate(DistanceToObject(pos + normal * 1.6).x*1.25*0.5); //ambient *= saturate(DistanceToObject(pos + normal * 3.2)*1.25*0.25); //ambient *= saturate(DistanceToObject(pos + normal * 6.4)*1.25*0.125); ambient = max(0.025, pow(ambient, 0.5)); // tone down ambient with a pow and min clamp it. ambient = saturate(ambient); // calculate the reflection vector for highlights vec3 ref = reflect(rayVec, normal); // Trace a ray toward the sun for sun shadows float sunShadow = 1.0; float iter = 0.01; vec3 nudgePos = pos + normal*0.002; // don't start tracing too close or inside the object for (int i = 0; i < 40; i++) { vec3 shadowPos = nudgePos + sunDir * iter; float tempDist = DistanceToObject(shadowPos).x; sunShadow *= saturate(tempDist*150.0); // Shadow hardness if (tempDist <= 0.0) break; float walk = tempDist; float dx = -fract(shadowPos.x); if (sunDir.x > 0.0) dx = fract(-shadowPos.x); float dz = -fract(shadowPos.z); if (sunDir.z > 0.0) dz = fract(-shadowPos.z); float nearestVoxel = min(fract(dx/sunDir.x), fract(dz/sunDir.z))+smallVal; nearestVoxel = max(0.2, nearestVoxel);// hack that assumes streets and sidewalks are this wide. walk = min(walk, nearestVoxel); iter += max(0.01, walk); if (iter > 4.5) break; } sunShadow = saturate(sunShadow); // make a few frequencies of noise to give it some texture float n =0.0; n += noise(pos*32.0); n += noise(pos*64.0); n += noise(pos*128.0); n += noise(pos*256.0); n += noise(pos*512.0); n = mix(0.7, 0.95, n); // ------ Calculate texture color ------ vec2 block = floor(pos.xz); vec3 texColor = vec3(0.95, 1.0, 1.0); texColor *= 0.8; float windowRef = 0.0; // texture map the sides of buildings if ((normal.y < 0.1) && (distAndMat.y == 0.0)) { vec3 posdx = dFdx(pos); vec3 posdy = dFdy(pos); vec3 posGrad = posdx * Hash21(uv) + posdy * Hash21(uv*7.6543); // Quincunx antialias the building texture and normal map. // I guess procedural textures are hard to mipmap. vec3 colTotal = vec3(0.0); vec3 colTemp = texColor; vec3 nTemp = vec3(0.0); CalcWindows(block, pos, colTemp, windowRef, nTemp); colTotal = colTemp; colTemp = texColor; CalcWindows(block, pos + posdx * 0.666, colTemp, windowRef, nTemp); colTotal += colTemp; colTemp = texColor; CalcWindows(block, pos + posdx * 0.666 + posdy * 0.666, colTemp, windowRef, nTemp); colTotal += colTemp; colTemp = texColor; CalcWindows(block, pos + posdy * 0.666, colTemp, windowRef, nTemp); colTotal += colTemp; colTemp = texColor; CalcWindows(block, pos + posdx * 0.333 + posdy * 0.333, colTemp, windowRef, nTemp); colTotal += colTemp; texColor = colTotal * 0.2; windowRef *= 0.2; normal = normalize(normal + nTemp * 0.2); } else { // Draw the road float xroad = abs(fract(pos.x+0.5)-0.5); float zroad = abs(fract(pos.z+0.5)-0.5); float road = saturate((min(xroad, zroad)-0.143)*480.0); texColor *= 1.0-normal.y*0.95*Hash21(block*9.87)*road; // change rooftop color texColor *= mix(0.1, 1.0, road); // double yellow line in middle of road float yellowLine = saturate(1.0-(min(xroad, zroad)-0.002)*480.0); yellowLine *= saturate((min(xroad, zroad)-0.0005)*480.0); yellowLine *= saturate((xroad*xroad+zroad*zroad-0.05)*880.0); texColor = mix(texColor, vec3(1.0, 0.8, 0.3), yellowLine); // white dashed lines on road float whiteLine = saturate(1.0-(min(xroad, zroad)-0.06)*480.0); whiteLine *= saturate((min(xroad, zroad)-0.056)*480.0); whiteLine *= saturate((xroad*xroad+zroad*zroad-0.05)*880.0); whiteLine *= saturate(1.0-(fract(zroad*8.0)-0.5)*280.0); // dotted line whiteLine *= saturate(1.0-(fract(xroad*8.0)-0.5)*280.0); texColor = mix(texColor, vec3(0.5), whiteLine); whiteLine = saturate(1.0-(min(xroad, zroad)-0.11)*480.0); whiteLine *= saturate((min(xroad, zroad)-0.106)*480.0); whiteLine *= saturate((xroad*xroad+zroad*zroad-0.06)*880.0); texColor = mix(texColor, vec3(0.5), whiteLine); // crosswalk float crossWalk = saturate(1.0-(fract(xroad*40.0)-0.5)*280.0); crossWalk *= saturate((zroad-0.15)*880.0); crossWalk *= saturate((-zroad+0.21)*880.0)*(1.0-road); crossWalk *= n*n; texColor = mix(texColor, vec3(0.25), crossWalk); crossWalk = saturate(1.0-(fract(zroad*40.0)-0.5)*280.0); crossWalk *= saturate((xroad-0.15)*880.0); crossWalk *= saturate((-xroad+0.21)*880.0)*(1.0-road); crossWalk *= n*n; texColor = mix(texColor, vec3(0.25), crossWalk); { // sidewalk cracks float sidewalk = 1.0; vec2 blockSize = vec2(100.0); if (pos.y > 0.1) blockSize = vec2(10.0, 50); //sidewalk *= pow(abs(sin(pos.x*blockSize)), 0.025); //sidewalk *= pow(abs(sin(pos.z*blockSize)), 0.025); sidewalk *= saturate(abs(sin(pos.z*blockSize.x)*800.0/blockSize.x)); sidewalk *= saturate(abs(sin(pos.x*blockSize.y)*800.0/blockSize.y)); sidewalk = saturate(mix(0.7, 1.0, sidewalk)); sidewalk = saturate((1.0-road) + sidewalk); texColor *= sidewalk; } } // Car tires are almost black to not call attention to their ugly. if (distAndMat.y == 3.0) { texColor = vec3(0.05); } // apply noise texColor *= vec3(1.0)*n*0.05; texColor *= 0.7; texColor = saturate(texColor); float windowMask = 0.0; if (distAndMat.y >= 100.0) { // car texture and windows texColor = vec3(Hash11(distAndMat.y)*1.0, Hash11(distAndMat.y*8.765), Hash11(distAndMat.y*17.731))*0.1; texColor = pow(abs(texColor), vec3(0.2)); // bias toward white texColor = max(vec3(0.25), texColor); // not too saturated color. texColor.z = min(texColor.y, texColor.z); // no purple cars. just not realistic. :) texColor *= Hash11(distAndMat.y*0.789) * 0.15; windowMask = saturate( max(0.0, abs(pos.y - 0.0175)*3800.0)-10.0); vec2 dirNorm = abs(normalize(normal.xz)); float pillars = saturate(1.0-max(dirNorm.x, dirNorm.y)); pillars = pow(max(0.0, pillars-0.15), 0.125); windowMask = max(windowMask, pillars); texColor *= windowMask; } // ------ Calculate lighting color ------ // Start with sun color, standard lighting equation, and shadow vec3 lightColor = vec3(100.0)*sunCol * saturate(dot(sunDir, normal)) * sunShadow; // weighted average the near ambient occlusion with the far for just the right look float ambientAvg = (ambient*3.0 + ambientS) * 0.25; // Add sky color with ambient acclusion lightColor += (skyCol * saturate(normal.y *0.5+0.5))*pow(ambientAvg, 0.35)*2.5; lightColor *= 4.0; // finally, apply the light to the texture. finalColor = texColor * lightColor; // Reflections for cars if (distAndMat.y >= 100.0) { float yfade = max(0.01, min(1.0, ref.y*100.0)); // low-res way of making lines at the edges of car windows. Not sure I like it. yfade *= (saturate(1.0-abs(dFdx(windowMask)*dFdy(windowMask))*250.995)); finalColor += GetEnvMapSkyline(ref, sunDir, pos.y-1.5)*0.3*yfade*max(0.4,sunShadow); //finalColor += saturate(texture(iChannel0, ref).xyz-0.35)*0.15*max(0.2,sunShadow); } // reflections for building windows if (windowRef != 0.0) { finalColor *= mix(1.0, 0.6, windowRef); float yfade = max(0.01, min(1.0, ref.y*100.0)); finalColor += GetEnvMapSkyline(ref, sunDir, pos.y-0.5)*0.6*yfade*max(0.6,sunShadow)*windowRef;//*(windowMask*0.5+0.5); //finalColor += saturate(texture(iChannel0, ref).xyz-0.35)*0.15*max(0.25,sunShadow)*windowRef; } finalColor *= 0.9; // fog that fades to reddish plus the sun color so that fog is brightest towards sun vec3 rv2 = rayVec; rv2.y *= saturate(sign(rv2.y)); vec3 fogColor = GetEnvMap(rv2, sunDir); fogColor = min(vec3(9.0), fogColor); finalColor = mix(fogColor, finalColor, exp(-t*0.02)); // visualize length of gradient of distance field to check distance field correctness //finalColor = vec3(0.5) * (length(normalU) / smallVec.x); //finalColor = vec3(marchCount)/255.0; } else { // Our ray trace hit nothing, so draw sky. finalColor = GetEnvMap(rayVec, sunDir); } // vignette? finalColor *= vec3(1.0) * saturate(1.0 - length(uv/2.5)); finalColor *= 1.3*exposure; // output the final color without gamma correction - will do gamma later. return vec3(clamp(finalColor, 0.0, 1.0)*saturate(fade+0.2)); } #ifdef NON_REALTIME_HQ_RENDER // This function breaks the image down into blocks and scans // through them, rendering 1 block at a time. It's for non- // realtime things that take a long time to render. // This is the frame rate to render at. Too fast and you will // miss some blocks. const float blockRate = 20.0; void BlockRender(in vec2 fragCoord) { // blockSize is how much it will try to render in 1 frame. // adjust this smaller for more complex scenes, bigger for // faster render times. const float blockSize = 64.0; // Make the block repeatedly scan across the image based on time. float frame = floor(iTime * blockRate); vec2 blockRes = floor(iResolution.xy / blockSize) + vec2(1.0); // ugly bug with mod. //float blockX = mod(frame, blockRes.x); float blockX = fract(frame / blockRes.x) * blockRes.x; //float blockY = mod(floor(frame / blockRes.x), blockRes.y); float blockY = fract(floor(frame / blockRes.x) / blockRes.y) * blockRes.y; // Don't draw anything outside the current block. if ((fragCoord.x - blockX * blockSize >= blockSize) || (fragCoord.x - (blockX - 1.0) * blockSize < blockSize) || (fragCoord.y - blockY * blockSize >= blockSize) || (fragCoord.y - (blockY - 1.0) * blockSize < blockSize)) { discard; } } #endif void mainImage( out vec4 fragColor, in vec2 fragCoord ) { #ifdef NON_REALTIME_HQ_RENDER // Optionally render a non-realtime scene with high quality BlockRender(fragCoord); #endif // Do a multi-pass render vec3 finalColor = vec3(0.0); #ifdef NON_REALTIME_HQ_RENDER for (float i = 0.0; i < antialiasingSamples; i++) { const float motionBlurLengthInSeconds = 1.0 / 60.0; // Set this to the time in seconds of the frame to render. localTime = frameToRenderHQ; // This line will motion-blur the renders localTime += Hash11(v21(fragCoord + seed)) * motionBlurLengthInSeconds; // Jitter the pixel position so we get antialiasing when we do multiple passes. vec2 jittered = fragCoord.xy + vec2( Hash21(fragCoord + seed), Hash21(fragCoord*7.234567 + seed) ); // don't antialias if only 1 sample. if (antialiasingSamples == 1.0) jittered = fragCoord; // Accumulate one pass of raytracing into our pixel value finalColor += RayTrace(jittered); // Change the random seed for each pass. seed *= 1.01234567; } // Average all accumulated pixel intensities finalColor /= antialiasingSamples; #else // Regular real-time rendering localTime = iTime; finalColor = RayTrace(fragCoord); #endif fragColor = vec4(sqrt(clamp(finalColor, 0.0, 1.0)),1.0); } ''', }, { // https://www.shadertoy.com/view/XlfGRj 'url': 'https://www.shadertoy.com/view/XlfGRj', 'fragment': ''' // Star Nest by Pablo Roman Andrioli #define iterations 17 #define formuparam 0.53 #define volsteps 20 #define stepsize 0.1 #define zoom 0.800 #define tile 0.850 #define speed 0.010 #define brightness 0.0015 #define darkmatter 0.300 #define distfading 0.730 #define saturation 0.850 void mainImage( out vec4 fragColor, in vec2 fragCoord ) { //get coords and direction vec2 uv=fragCoord.xy/iResolution.xy-.5; uv.y*=iResolution.y/iResolution.x; vec3 dir=vec3(uv*zoom,1.); float time=iTime*speed+.25; //mouse rotation float a1=.5+iMouse.x/iResolution.x*2.; float a2=.8+iMouse.y/iResolution.y*2.; mat2 rot1=mat2(cos(a1),sin(a1),-sin(a1),cos(a1)); mat2 rot2=mat2(cos(a2),sin(a2),-sin(a2),cos(a2)); dir.xz*=rot1; dir.xy*=rot2; vec3 from=vec3(1.,.5,0.5); from+=vec3(time*2.,time,-2.); from.xz*=rot1; from.xy*=rot2; //volumetric rendering float s=0.1,fade=1.; vec3 v=vec3(0.); for (int r=0; r6) fade*=1.-dm; // dark matter, don't render near //v+=vec3(dm,dm*.5,0.); v+=fade; v+=vec3(s,s*s,s*s*s*s)*a*brightness*fade; // coloring based on distance fade*=distfading; // distance fading s+=stepsize; } v=mix(vec3(length(v)),v,saturation); //color adjust fragColor = vec4(v*.01,1.); } ''', }, { // https://www.shadertoy.com/view/Xs2XDV 'url': 'https://www.shadertoy.com/view/Xs2XDV', 'fragment': ''' #define resolution (iResolution.xy) #define t (iTime * .3) // Simplest Lambert+Phong material shading model parameters struct mat_t { vec3 diffuse; vec4 specular; }; // There are two separate distance fields, each consists of 6 metaballs and a plane. #define N 6 vec3 b1[N]; vec3 b2[N]; // Four lights with their positions and colors vec3 l1pos = 1.*vec3(6., 3., -7.); vec3 l2pos = 1.*vec3(-7., 1., 6.); vec3 l3pos = 1.*vec3(7., -4., 7.); vec3 l4pos = vec3(0.,5.,25.); vec3 l1color = 40.*vec3(1.,.7,.7); vec3 l2color = 20.*vec3(.7,.7,1.); vec3 l3color = 60.*vec3(.7,1.,.7); vec3 l4color = vec3(100.); // Distance function approximation for the first field only float t1(vec3 p) { float v = 0.; for (int i = 0; i < N; ++i) { vec3 b = p - b1[i]; // metaball field used here is a simple sum of inverse-square distances to metaballs centers // all numeric constants are empirically tuned v += 5. / dot(b, b); } // add top y=12 (red) plane float d = 12. - p.y; v += 3. / (d*d); return v; } // Second field distance function is basically the same, but uses b2[] metaballs centers and y=-12 plane float t2(vec3 p) { float v = 0.; for (int i = 0; i < N; ++i) { vec3 b = p - b2[i]; v += 5. / dot(b, b); } float d = 12. + p.y; v += 3. / (d*d); return v; } // "Repulsive" distance functions which account for both fields float w1(vec3 p) { return 1. - t1(p) + t2(p); } float w2(vec3 p) { return 1. + t1(p) - t2(p); } // Combined world function that picks whichever field is the closest one float world(vec3 p) { return min(w1(p), w2(p)); } vec3 normal(vec3 p) { vec2 e = vec2(.001,0.); return normalize(vec3( world(p+e.xyy) - world(p-e.xyy), world(p+e.yxy) - world(p-e.yxy), world(p+e.yyx) - world(p-e.yyx))); } // Material is picked based on which field's distance function is the smallest mat_t material(vec3 p) { mat_t m; m.diffuse = vec3(0.); m.specular = vec4(0.); if (w1(p) < w2(p)) { m.diffuse = vec3(.92, .027, .027); m.specular = vec4(mix(vec3(1.),m.diffuse,.7), 2000.); } else { m.diffuse = vec3(.14, .17, 1.57); m.specular = vec4(mix(vec3(1.),m.diffuse,.5), 100.); } return m; } float iter = 0.; // Raymarcher float trace(in vec3 O, in vec3 D, in float L, in float Lmax) { // The usual "step along the ray" loop float Lp = L; for (int i = 0; i < 40; ++i) { iter = float(i); float d = world(O + D * L); if (d < .01*L || L > Lmax) break; // Store previous point (see below) Lp = L; // Overstep a bit to find intersetion faster (metaball fields aren't cheap) L += d * 1.5; } if (L < Lmax) { // Binary search for more exact intersestion position // Needed to fix artifacts due to overstep for (int i = 0; i < 5; ++i) { float Lm = (Lp + L) * .5; if (world(O + D * Lm) < .01*Lm) L = Lm; else Lp = Lm; } } iter /= 32.; return L; } // Simpler tracing function that tries to determine whether the point is in shadow float shadowtrace(vec3 p, vec3 d, float lmax) { float v = .02; // Take a few samples between the point and the light position and chech // whether they are "inside" geometry for (int i = 1; i < 9; ++i) { v = min(v, world(p+d*lmax*float(i)/12.)); } return smoothstep(.0, .02, v); } // Compute shading color from a single light vec3 enlight(vec3 p, vec3 v, vec3 n, mat_t m, vec3 lpos, vec3 lcolor) { vec3 ldir = lpos - p; // direction from the point to the light source float ldist2 = dot(ldir, ldir); // square distance to the light source float ldist = sqrt(ldist2); // distance ldir /= ldist; // ldir is now normalized float shadow = shadowtrace(p, ldir, ldist-.2); // whether the point is in shadow return shadow * lcolor * ( // Diffuse term (simple Lambert) m.diffuse * max(0., dot(n,ldir)) // Specular term (Phong-ish) + m.specular.rgb * pow(max(0.,dot(normalize(ldir-v), n)), m.specular.w) // Specular energy conservation? (or something, it was 3 years ago :D) * (m.specular.w + 2.) * (m.specular.w + 4.) / (24. * (m.specular.w + pow(2., -m.specular.w/2.))) ) / ldist2; } // A ridiculous hack to display light sources // Basic idea is to check whether the ray is "close enough" to the light source position in screen space // Which is done by calculating the angle between the actual pixel ray and a vector from origin to the light source vec3 lightball(vec3 lpos, vec3 lcolor, vec3 O, vec3 D, float L) { vec3 ldir = lpos-O; float ldist = length(ldir); if (ldist > L) return vec3(0.); float pw = pow(max(0.,dot(normalize(ldir),D)), 20000.); return (normalize(lcolor)+vec3(1.)) * pw; } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { // Calculate metaball trajectories (all empirical) for (int i = 0; i < N; ++i) { float fi = float(i)*.7; b1[i] = vec3(3.7*sin(t+fi), 1.+10.*cos(t*1.1+fi), 2.3*sin(t*2.3+fi)); fi = float(i)*1.2; b2[i] = vec3(4.4*cos(t*.4+fi),-1.-10.*cos(t*0.7+fi), -2.1*sin(t*1.3+fi)); } vec2 uv = fragCoord.xy / resolution.xy * 2. - 1.; uv.x *= resolution.x / resolution.y; vec3 O = vec3(0.,0.,20.); vec3 D = normalize(vec3(uv,-1.6)); if (iMouse.z > 0.) { vec2 m = iMouse.xy/iResolution.xy*2.-1.; float a = - m.x * 2. * 3.1415926; float s = sin(a), c = cos(a); O = vec3(s*20.,-m.y*10.,c*20.); vec3 fw = normalize(vec3(0.) - O); vec3 rg = cross(fw,vec3(0.,1.,0.)); D = normalize(mat3(rg, cross(rg, fw), -fw) * D); } // Raymarch float L = trace(O, D, 0., 40.); vec3 color = vec3(0.); if (L < 40.) { // If a hit is detected, then get the position vec3 p = O + D * L; // And normal vec3 n = normal(p); // And material mat_t m = material(p); // Ambient term (I don't think it is visible much) color = .001 * m.diffuse * n; // Shade for all lights color += enlight(p, D, n, m, l1pos, l1color); color += enlight(p, D, n, m, l2pos, l2color); color += enlight(p, D, n, m, l3pos, l3color); color += enlight(p, D, n, m, l4pos, l4color); // Fog-like hack-ish attenuation, so the only the center of the scene is visible color *= (1. - smoothstep(10., 20., length(p))); } else L = 100.; // Add light sources hack color += lightball(l1pos, l1color, O, D, L); color += lightball(l2pos, l2color, O, D, L); color += lightball(l3pos, l3color, O, D, L); color += lightball(l4pos, l4color, O, D, L); // Gamma correct and out fragColor = vec4(pow(color,vec3(.7)),1.0); } ''', }, { // https://www.shadertoy.com/view/3l23Rh 'url': 'https://www.shadertoy.com/view/3l23Rh', 'fragment': ''' // Protean clouds by nimitz (twitter: @stormoid) // https://www.shadertoy.com/view/3l23Rh // License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License // Contact the author for other licensing options /* Technical details: The main volume noise is generated from a deformed periodic grid, which can produce a large range of noise-like patterns at very cheap evalutation cost. Allowing for multiple fetches of volume gradient computation for improved lighting. To further accelerate marching, since the volume is smooth, more than half the the density information isn't used to rendering or shading but only as an underlying volume distance to determine dynamic step size, by carefully selecting an equation (polynomial for speed) to step as a function of overall density (not necessarily rendered) the visual results can be the same as a naive implementation with ~40% increase in rendering performance. Since the dynamic marching step size is even less uniform due to steps not being rendered at all the fog is evaluated as the difference of the fog integral at each rendered step. */ mat2 rot(in float a){float c = cos(a), s = sin(a);return mat2(c,s,-s,c);} const mat3 m3 = mat3(0.33338, 0.56034, -0.71817, -0.87887, 0.32651, -0.15323, 0.15162, 0.69596, 0.61339)*1.93; float mag2(vec2 p){return dot(p,p);} float linstep(in float mn, in float mx, in float x){ return clamp((x - mn)/(mx - mn), 0., 1.); } float prm1 = 0.; vec2 bsMo = vec2(0); vec2 disp(float t){ return vec2(sin(t*0.22)*1., cos(t*0.175)*1.)*2.; } vec2 map(vec3 p) { vec3 p2 = p; p2.xy -= disp(p.z).xy; p.xy *= rot(sin(p.z+iTime)*(0.1 + prm1*0.05) + iTime*0.09); float cl = mag2(p2.xy); float d = 0.; p *= .61; float z = 1.; float trk = 1.; float dspAmp = 0.1 + prm1*0.2; for(int i = 0; i < 5; i++) { p += sin(p.zxy*0.75*trk + iTime*trk*.8)*dspAmp; d -= abs(dot(cos(p), sin(p.yzx))*z); z *= 0.57; trk *= 1.4; p = p*m3; } d = abs(d + prm1*3.)+ prm1*.3 - 2.5 + bsMo.y; return vec2(d + cl*.2 + 0.25, cl); } vec4 render( in vec3 ro, in vec3 rd, float time ) { vec4 rez = vec4(0); const float ldst = 8.; vec3 lpos = vec3(disp(time + ldst)*0.5, time + ldst); float t = 1.5; float fogT = 0.; for(int i=0; i<130; i++) { if(rez.a > 0.99)break; vec3 pos = ro + t*rd; vec2 mpv = map(pos); float den = clamp(mpv.x-0.3,0.,1.)*1.12; float dn = clamp((mpv.x + 2.),0.,3.); vec4 col = vec4(0); if (mpv.x > 0.6) { col = vec4(sin(vec3(5.,0.4,0.2) + mpv.y*0.1 +sin(pos.z*0.4)*0.5 + 1.8)*0.5 + 0.5,0.08); col *= den*den*den; col.rgb *= linstep(4.,-2.5, mpv.x)*2.3; float dif = clamp((den - map(pos+.8).x)/9., 0.001, 1. ); dif += clamp((den - map(pos+.35).x)/2.5, 0.001, 1. ); col.xyz *= den*(vec3(0.005,.045,.075) + 1.5*vec3(0.033,0.07,0.03)*dif); } float fogC = exp(t*0.2 - 2.2); col.rgba += vec4(0.06,0.11,0.11, 0.1)*clamp(fogC-fogT, 0., 1.); fogT = fogC; rez = rez + col*(1. - rez.a); t += clamp(0.5 - dn*dn*.05, 0.09, 0.3); } return clamp(rez, 0.0, 1.0); } float getsat(vec3 c) { float mi = min(min(c.x, c.y), c.z); float ma = max(max(c.x, c.y), c.z); return (ma - mi)/(ma+ 1e-7); } //from my "Will it blend" shader (https://www.shadertoy.com/view/lsdGzN) vec3 iLerp(in vec3 a, in vec3 b, in float x) { vec3 ic = mix(a, b, x) + vec3(1e-6,0.,0.); float sd = abs(getsat(ic) - mix(getsat(a), getsat(b), x)); vec3 dir = normalize(vec3(2.*ic.x - ic.y - ic.z, 2.*ic.y - ic.x - ic.z, 2.*ic.z - ic.y - ic.x)); float lgt = dot(vec3(1.0), ic); float ff = dot(dir, normalize(ic)); ic += 1.5*dir*sd*ff*lgt; return clamp(ic,0.,1.); } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { vec2 q = fragCoord.xy/iResolution.xy; vec2 p = (gl_FragCoord.xy - 0.5*iResolution.xy)/iResolution.y; bsMo = (iMouse.xy - 0.5*iResolution.xy)/iResolution.y; float time = iTime*3.; vec3 ro = vec3(0,0,time); ro += vec3(sin(iTime)*0.5,sin(iTime*1.)*0.,0); float dspAmp = .85; ro.xy += disp(ro.z)*dspAmp; float tgtDst = 3.5; vec3 target = normalize(ro - vec3(disp(time + tgtDst)*dspAmp, time + tgtDst)); ro.x -= bsMo.x*2.; vec3 rightdir = normalize(cross(target, vec3(0,1,0))); vec3 updir = normalize(cross(rightdir, target)); rightdir = normalize(cross(updir, target)); vec3 rd=normalize((p.x*rightdir + p.y*updir)*1. - target); rd.xy *= rot(-disp(time + 3.5).x*0.2 + bsMo.x); prm1 = smoothstep(-0.4, 0.4,sin(iTime*0.3)); vec4 scn = render(ro, rd, time); vec3 col = scn.rgb; col = iLerp(col.bgr, col.rgb, clamp(1.-prm1,0.05,1.)); col = pow(col, vec3(.55,0.65,0.6))*vec3(1.,.97,.9); col *= pow( 16.0*q.x*q.y*(1.0-q.x)*(1.0-q.y), 0.12)*0.7+0.3; //Vign fragColor = vec4( col, 1.0 ); } ''', }, { // https://www.shadertoy.com/view/Ms2SD1 'url': 'https://www.shadertoy.com/view/Ms2SD1', 'fragment': ''' /* * "Seascape" by Alexander Alekseev aka TDM - 2014 * License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. * Contact: tdmaav@gmail.com */ const int NUM_STEPS = 8; const float PI = 3.141592; const float EPSILON = 1e-3; #define EPSILON_NRM (0.1 / iResolution.x) #define AA // sea const int ITER_GEOMETRY = 3; const int ITER_FRAGMENT = 5; const float SEA_HEIGHT = 0.6; const float SEA_CHOPPY = 4.0; const float SEA_SPEED = 0.8; const float SEA_FREQ = 0.16; const vec3 SEA_BASE = vec3(0.0,0.09,0.18); const vec3 SEA_WATER_COLOR = vec3(0.8,0.9,0.6)*0.6; #define SEA_TIME (1.0 + iTime * SEA_SPEED) const mat2 octave_m = mat2(1.6,1.2,-1.2,1.6); // math mat3 fromEuler(vec3 ang) { vec2 a1 = vec2(sin(ang.x),cos(ang.x)); vec2 a2 = vec2(sin(ang.y),cos(ang.y)); vec2 a3 = vec2(sin(ang.z),cos(ang.z)); mat3 m; m[0] = vec3(a1.y*a3.y+a1.x*a2.x*a3.x,a1.y*a2.x*a3.x+a3.y*a1.x,-a2.y*a3.x); m[1] = vec3(-a2.y*a1.x,a1.y*a2.y,a2.x); m[2] = vec3(a3.y*a1.x*a2.x+a1.y*a3.x,a1.x*a3.x-a1.y*a3.y*a2.x,a2.y*a3.y); return m; } float hash( vec2 p ) { float h = dot(p,vec2(127.1,311.7)); return fract(sin(h)*43758.5453123); } float noise( in vec2 p ) { vec2 i = floor( p ); vec2 f = fract( p ); vec2 u = f*f*(3.0-2.0*f); return -1.0+2.0*mix( mix( hash( i + vec2(0.0,0.0) ), hash( i + vec2(1.0,0.0) ), u.x), mix( hash( i + vec2(0.0,1.0) ), hash( i + vec2(1.0,1.0) ), u.x), u.y); } // lighting float diffuse(vec3 n,vec3 l,float p) { return pow(dot(n,l) * 0.4 + 0.6,p); } float specular(vec3 n,vec3 l,vec3 e,float s) { float nrm = (s + 8.0) / (PI * 8.0); return pow(max(dot(reflect(e,n),l),0.0),s) * nrm; } // sky vec3 getSkyColor(vec3 e) { e.y = (max(e.y,0.0)*0.8+0.2)*0.8; return vec3(pow(1.0-e.y,2.0), 1.0-e.y, 0.6+(1.0-e.y)*0.4) * 1.1; } // sea float sea_octave(vec2 uv, float choppy) { uv += noise(uv); vec2 wv = 1.0-abs(sin(uv)); vec2 swv = abs(cos(uv)); wv = mix(wv,swv,wv); return pow(1.0-pow(wv.x * wv.y,0.65),choppy); } float map(vec3 p) { float freq = SEA_FREQ; float amp = SEA_HEIGHT; float choppy = SEA_CHOPPY; vec2 uv = p.xz; uv.x *= 0.75; float d, h = 0.0; for(int i = 0; i < ITER_GEOMETRY; i++) { d = sea_octave((uv+SEA_TIME)*freq,choppy); d += sea_octave((uv-SEA_TIME)*freq,choppy); h += d * amp; uv *= octave_m; freq *= 1.9; amp *= 0.22; choppy = mix(choppy,1.0,0.2); } return p.y - h; } float map_detailed(vec3 p) { float freq = SEA_FREQ; float amp = SEA_HEIGHT; float choppy = SEA_CHOPPY; vec2 uv = p.xz; uv.x *= 0.75; float d, h = 0.0; for(int i = 0; i < ITER_FRAGMENT; i++) { d = sea_octave((uv+SEA_TIME)*freq,choppy); d += sea_octave((uv-SEA_TIME)*freq,choppy); h += d * amp; uv *= octave_m; freq *= 1.9; amp *= 0.22; choppy = mix(choppy,1.0,0.2); } return p.y - h; } vec3 getSeaColor(vec3 p, vec3 n, vec3 l, vec3 eye, vec3 dist) { float fresnel = clamp(1.0 - dot(n,-eye), 0.0, 1.0); fresnel = pow(fresnel,3.0) * 0.5; vec3 reflected = getSkyColor(reflect(eye,n)); vec3 refracted = SEA_BASE + diffuse(n,l,80.0) * SEA_WATER_COLOR * 0.12; vec3 color = mix(refracted,reflected,fresnel); float atten = max(1.0 - dot(dist,dist) * 0.001, 0.0); color += SEA_WATER_COLOR * (p.y - SEA_HEIGHT) * 0.18 * atten; color += vec3(specular(n,l,eye,60.0)); return color; } // tracing vec3 getNormal(vec3 p, float eps) { vec3 n; n.y = map_detailed(p); n.x = map_detailed(vec3(p.x+eps,p.y,p.z)) - n.y; n.z = map_detailed(vec3(p.x,p.y,p.z+eps)) - n.y; n.y = eps; return normalize(n); } float heightMapTracing(vec3 ori, vec3 dir, out vec3 p) { float tm = 0.0; float tx = 1000.0; float hx = map(ori + dir * tx); if(hx > 0.0) { p = ori + dir * tx; return tx; } float hm = map(ori + dir * tm); float tmid = 0.0; for(int i = 0; i < NUM_STEPS; i++) { tmid = mix(tm,tx, hm/(hm-hx)); p = ori + dir * tmid; float hmid = map(p); if(hmid < 0.0) { tx = tmid; hx = hmid; } else { tm = tmid; hm = hmid; } } return tmid; } vec3 getPixel(in vec2 coord, float time) { vec2 uv = coord / iResolution.xy; uv = uv * 2.0 - 1.0; uv.x *= iResolution.x / iResolution.y; // ray vec3 ang = vec3(sin(time*3.0)*0.1,sin(time)*0.2+0.3,time); vec3 ori = vec3(0.0,3.5,time*5.0); vec3 dir = normalize(vec3(uv.xy,-2.0)); dir.z += length(uv) * 0.14; dir = normalize(dir) * fromEuler(ang); // tracing vec3 p; heightMapTracing(ori,dir,p); vec3 dist = p - ori; vec3 n = getNormal(p, dot(dist,dist) * EPSILON_NRM); vec3 light = normalize(vec3(0.0,1.0,0.8)); // color return mix( getSkyColor(dir), getSeaColor(p,n,light,dir,dist), pow(smoothstep(0.0,-0.02,dir.y),0.2)); } // main void mainImage( out vec4 fragColor, in vec2 fragCoord ) { float time = iTime * 0.3 + iMouse.x*0.01; #ifdef AA vec3 color = vec3(0.0); for(int i = -1; i <= 1; i++) { for(int j = -1; j <= 1; j++) { vec2 uv = fragCoord+vec2(i,j)/3.0; color += getPixel(uv, time); } } color /= 9.0; #else vec3 color = getPixel(fragCoord, time); #endif // post fragColor = vec4(pow(color,vec3(0.65)), 1.0); } ''', }, { // https://www.shadertoy.com/view/tsXBzS 'url': 'https://www.shadertoy.com/view/tsXBzS', 'fragment': ''' vec3 palette(float d){ return mix(vec3(0.2,0.7,0.9),vec3(1.,0.,1.),d); } vec2 rotate(vec2 p,float a){ float c = cos(a); float s = sin(a); return p*mat2(c,s,-s,c); } float map(vec3 p){ for( int i = 0; i<8; ++i){ float t = iTime*0.2; p.xz =rotate(p.xz,t); p.xy =rotate(p.xy,t*1.89); p.xz = abs(p.xz); p.xz-=.5; } return dot(sign(p),p)/5.; } vec4 rm (vec3 ro, vec3 rd){ float t = 0.; vec3 col = vec3(0.); float d; for(float i =0.; i<64.; i++){ vec3 p = ro + rd*t; d = map(p)*.5; if(d<0.02){ break; } if(d>100.){ break; } //col+=vec3(0.6,0.8,0.8)/(400.*(d)); col+=palette(length(p)*.1)/(400.*(d)); t+=d; } return vec4(col,1./(d*100.)); } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { vec2 uv = (fragCoord-(iResolution.xy/2.))/iResolution.x; vec3 ro = vec3(0.,0.,-50.); ro.xz = rotate(ro.xz,iTime); vec3 cf = normalize(-ro); vec3 cs = normalize(cross(cf,vec3(0.,1.,0.))); vec3 cu = normalize(cross(cf,cs)); vec3 uuv = ro+cf*3. + uv.x*cs + uv.y*cu; vec3 rd = normalize(uuv-ro); vec4 col = rm(ro,rd); fragColor = col; } /** SHADERDATA { "title": "fractal pyramid", "description": "", "model": "car" } */ ''', }, { // https://www.shadertoy.com/view/4ds3zn 'url': 'https://www.shadertoy.com/view/4ds3zn', 'fragment': ''' // Created by inigo quilez - iq/2013 // https://www.youtube.com/c/InigoQuilez // https://iquilezles.org/ // I am the sole copyright owner of this Work. // You cannot host, display, distribute or share this Work neither // as it is or altered, here on Shadertoy or anywhere else, in any // form including physical and digital. You cannot use this Work in any // commercial or non-commercial product, website or project. You cannot // sell this Work and you cannot mint an NFTs of it or train a neural // network with it without permission. I share this Work for educational // purposes, and you can link to it, through an URL, proper attribution // and unmodified screenshot, as part of your educational material. If // these conditions are too restrictive please contact me and we'll // definitely work it out. // I can't recall where I learnt about this fractal. // // Coloring and fake occlusions are done by orbit trapping, as usual. // Antialiasing level #if HW_PERFORMANCE==0 #define AA 1 #else #define AA 2 // Make it 3 if you have a fast machine #endif vec4 orb; float map( vec3 p, float s ) { float scale = 1.0; orb = vec4(1000.0); for( int i=0; i<8;i++ ) { p = -1.0 + 2.0*fract(0.5*p+0.5); float r2 = dot(p,p); orb = min( orb, vec4(abs(p),r2) ); float k = s/r2; p *= k; scale *= k; } return 0.25*abs(p.y)/scale; } float trace( in vec3 ro, in vec3 rd, float s ) { float maxd = 30.0; float t = 0.01; for( int i=0; i<512; i++ ) { float precis = 0.001 * t; float h = map( ro+rd*t, s ); if( hmaxd ) break; t += h; } if( t>maxd ) t=-1.0; return t; } vec3 calcNormal( in vec3 pos, in float t, in float s ) { float precis = 0.001 * t; vec2 e = vec2(1.0,-1.0)*precis; return normalize( e.xyy*map( pos + e.xyy, s ) + e.yyx*map( pos + e.yyx, s ) + e.yxy*map( pos + e.yxy, s ) + e.xxx*map( pos + e.xxx, s ) ); } vec3 render( in vec3 ro, in vec3 rd, in float anim ) { // trace vec3 col = vec3(0.0); float t = trace( ro, rd, anim ); if( t>0.0 ) { vec4 tra = orb; vec3 pos = ro + t*rd; vec3 nor = calcNormal( pos, t, anim ); // lighting vec3 light1 = vec3( 0.577, 0.577, -0.577 ); vec3 light2 = vec3( -0.707, 0.000, 0.707 ); float key = clamp( dot( light1, nor ), 0.0, 1.0 ); float bac = clamp( 0.2 + 0.8*dot( light2, nor ), 0.0, 1.0 ); float amb = (0.7+0.3*nor.y); float ao = pow( clamp(tra.w*2.0,0.0,1.0), 1.2 ); vec3 brdf = 1.0*vec3(0.40,0.40,0.40)*amb*ao; brdf += 1.0*vec3(1.00,1.00,1.00)*key*ao; brdf += 1.0*vec3(0.40,0.40,0.40)*bac*ao; // material vec3 rgb = vec3(1.0); rgb = mix( rgb, vec3(1.0,0.80,0.2), clamp(6.0*tra.y,0.0,1.0) ); rgb = mix( rgb, vec3(1.0,0.55,0.0), pow(clamp(1.0-2.0*tra.z,0.0,1.0),8.0) ); // color col = rgb*brdf*exp(-0.2*t); } return sqrt(col); } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { float time = iTime*0.25; float anim = 1.1 + 0.5*smoothstep( -0.3, 0.3, cos(0.1*iTime) ); vec3 tot = vec3(0.0); #if AA>1 for( int jj=0; jj> 1) & 1, (i >> 1) & 1, i & 1) - 1.); n += e * map(p + e * h).d; } return NM(n); } float shadow(vec3 p, vec3 lp) { float d, s = 1., t = .1, mxt = length(p - lp); vec3 ld = NM(lp - p); for (float i = Z0; i < 40.; i++) { d = map(t * ld + p).d; s = min(s, 15. * d / t); t += max(.1, d); if (mxt - t < .5 || s < .001) break; } return S01(s); } float ao(vec3 p, vec3 n, float h) { return map(h * n + p).d / h; } float fog(vec3 v) { return exp(dot(v, v) * -.001); } vec3 lights(vec3 p, vec3 rd, float d, Hit h) { vec3 c, ld = NM(vec3(6, 3, -10) - p), n = N(p, d); float spe = 1.; if (h.id == 3) { c = vec3(.4, .35, .3); n.y += n31(h.uv * 10.); n = NM(n); } else if (h.id == 2) c = mix(vec3(.16, .08, .07), vec3(.6), pow(n31(h.uv * 10.), 3.)); else if (h.id == 4) c = vec3(.6, 1, 4); else { spe = .1; c = vec3(.6); n.x += sin((p.x + p.z * n.z) * 8.) * .1; n = NM(n); } float ao = mix(ao(p, n, .2), ao(p, n, 2.), .7); return mix((sat(.1 + .9 * dot(ld, n)) * (.1 + .9 * shadow(p, vec3(6, 3, -10))) * (.3 + .7 * ao) + (sat(.1 + .9 * dot(ld * vec3(-1, 0, -1), n)) * .3 + pow(sat(dot(rd, reflect(ld, n))), 10.) * spe) * ao) * c * vec3(1.85, .5, .08), vec3(1.85, .5, .08), S(.7, 1., 1. + dot(rd, n)) * .1); } vec4 march(inout vec3 p, vec3 rd, float s, float mx) { float i, d = .01; Hit h; for (i = Z0; i < s; i++) { h = map(p); if (abs(h.d) < .0015) break; d += h.d; if (d > mx) return vec4(0); p += h.d * rd; } return vec4(lights(p, rd, d, h), h.id); } vec3 scene(vec3 rd) { t = mod(iTime, 30.); vec3 c, p = vec3(0); vec4 col = march(p, rd, 180., 64.); float f = 1., x = n31(rd + vec3(-t * 2., -t * .4, t)); if (col.w == 0.) c = mix(vec3(.5145, .147, .0315), vec3(.22, .06, .01), sat(rd.y * 3.)); else { c = col.rgb; f = fog(p * (.7 + .3 * x)); } f *= 1. - x * x * x * .4; return mix(vec3(.49, .14, .03), c, sat(f)); } #define rgba(col) vec4(pow(max(vec3(0), col), vec3(.45)) * sat(t), 0) void mainVR(out vec4 fragColor, vec2 fc, vec3 ro, vec3 rd) { rd.xz *= mat2(1, 0, 0, -1); fragColor = rgba(scene(rd)); } void mainImage(out vec4 fragColor, vec2 fc) { vec2 uv = (fc - .5 * R.xy) / R.y, q = fc.xy / R.xy; vec3 r = NM(cross(vec3(0, 1, 0), vec3(0, 0, 1))), col = scene(NM(vec3(0, 0, 1) + r * uv.x + cross(vec3(0, 0, 1), r) * uv.y)); col *= .5 + .5 * pow(16. * q.x * q.y * (1. - q.x) * (1. - q.y), .4); fragColor = rgba(col) * sat(30. - t); } ''' }, { // https://www.shadertoy.com/view/NtlSDs 'url': 'https://www.shadertoy.com/view/NtlSDs', 'fragment': ''' // Copyright Inigo Quilez, 2021 - https://iquilezles.org/ // I am the sole copyright owner of this Work. // You cannot host, display, distribute or share this Work neither // as it is or altered, here on Shadertoy or anywhere else, in any // form including physical and digital. You cannot use this Work in any // commercial or non-commercial product, website or project. You cannot // sell this Work and you cannot mint an NFTs of it or train a neural // network with it without permission. I share this Work for educational // purposes, and you can link to it, through an URL, proper attribution // and unmodified screenshot, as part of your educational material. If // these conditions are too restrictive please contact me and we'll // definitely work it out. // ------------------------------------------------------- // I made this shader in 2008 for the Euskal Party // competition in Spain. The original Pouet entry is // here: https://www.pouet.net/prod.php?which=51074 // It's a raymarched SDF, and while I had raymarched some // fractal SDFs back in 2005, this was the first time I // used the technique to produce art-directed content and // "paint with maths" (as opposed to doing "mathematical art"). // This is also the shader where I first used the now // popular ambient occlusion estimation. You'll also find // my first attemtps at smooth-minumum (used to blend the // creature's head and tentacles together), and soft // shadows (still not as good as the ones we use today). // You'll find most of the other usual Shadertoy/raymarching // stuff - domain repetition, Value Noise, box SDFs and of // course the raymarching machinery. // Surprisngly, copying the code from my original project // to Shadertoy here required very little modifications. #define AA 1 // iFrame not supported here // #define ZERO min(iFrame,0) #define ZERO 0 float dot2( in vec3 v ) { return dot(v,v); } // https://iquilezles.org/articles/sfrand float sfrand( inout int mirand ) { mirand = mirand*0x343fd+0x269ec3; float res = uintBitsToFloat((uint(mirand)>>9)|0x40000000u ); return( res-3.0 ); } // hash by Hugo Elias uint ihash( uint n ) { n = (n << 13) ^ n; n = (n*(n*n*15731u+789221u)+1376312589u)&0x7fffffffu; return n; } // hash by Hugo Elias float hash( int n ) { n = (n << 13) ^ n; n = (n*(n*n*15731+789221)+1376312589)&0x7fffffff; return 1.0 - float(n)*(1.0/1073741824.0); } float noise( vec3 p ) { ivec3 ip = ivec3(floor(p)); vec3 fp = fract(p); vec3 w = fp*fp*(3.0-2.0*fp); int n = ip.x + ip.y*57 + 113*ip.z; return mix(mix(mix( hash(n+(0+57*0+113*0)), hash(n+(1+57*0+113*0)),w.x), mix( hash(n+(0+57*1+113*0)), hash(n+(1+57*1+113*0)),w.x),w.y), mix(mix( hash(n+(0+57*0+113*1)), hash(n+(1+57*0+113*1)),w.x), mix( hash(n+(0+57*1+113*1)), hash(n+(1+57*1+113*1)),w.x),w.y),w.z); } // https://iquilezles.org/articles/fbm float fbm( vec3 p ) { #if 0 // original code return 0.5000*noise( p*1.0 ) + 0.2500*noise( p*2.0 ) + 0.1250*noise( p*4.0 ) + 0.0625*noise( p*8.0 ); #else // equivalent code, but compiles MUCH faster float f = 0.0; float s = 0.5; for( int i=ZERO; i<4; i++ ) { f += s*noise( p ); s *= 0.5; p *= 2.0; } return f; #endif } // https://iquilezles.org/articles/distfunctions float sdBox( in vec3 p, in vec3 b ) { vec3 q = abs(p) - b; return min(max(q.x,max(q.y,q.z)),0.0) + length(max(q,0.0)); } // https://iquilezles.org/articles/distfunctions float udSqBox( vec3 p, vec3 b ) { float di = 0.0; float dx = abs(p.x)-b.x; if( dx>0.0 ) di+=dx*dx; float dy = abs(p.y)-b.y; if( dy>0.0 ) di+=dy*dy; float dz = abs(p.z)-b.z; if( dz>0.0 ) di+=dz*dz; return di; } //------------------------------------------------------------------------------- float columna( vec3 pos, float offx ) { float x = pos.x; float y = pos.y; float z = pos.z; float y2=y-0.40; float y3=y-0.35; float y4=y-1.00; float di = udSqBox( vec3(x, y , z), vec3(0.10, 1.00, 0.10) ); di = min( di, udSqBox( vec3(x, y , z), vec3(0.12, 0.40, 0.12) ) ); di = min( di, udSqBox( vec3(x, y , z), vec3(0.05, 0.35, 0.14) ) ); di = min( di, udSqBox( vec3(x, y , z), vec3(0.14, 0.35, 0.05) ) ); di = min( di, udSqBox( vec3(x, y4, z), vec3(0.14, 0.02, 0.14) ) ); di = min( di, udSqBox( vec3((x-y2)*0.7071, (y2+x)*0.7071, z), vec3(0.10*0.7071, 0.10*0.7071, 0.12) ) ); di = min( di, udSqBox( vec3(x, (y2+z)*0.7071, (z-y2)*0.7071), vec3(0.12, 0.10*0.7071, 0.1*0.7071) ) ); di = min( di, udSqBox( vec3((x-y3)*0.7071, (y3+x)*0.7071, z), vec3(0.10*0.7071, 0.10*0.7071, 0.14) ) ); di = min( di, udSqBox( vec3(x, (y3+z)*0.7071, (z-y3)*0.7071), vec3(0.14, 0.10*0.7071, 0.10*0.7071) ) ); #if 1 float fb = fbm(vec3(10.1*x+offx,10.1*y,10.1*z)); if( fb>0.0 ) di = di + 0.00000003*fb; #endif return sqrt(di); } float bicho( vec3 pos, float mindist ) { pos -= vec3(0.64,0.50,1.5); float r2 = dot2(pos); float sa = smoothstep(0.0,0.5,r2); pos *= vec3(0.75,0.80,0.75) + sa*vec3(0.25,0.20,0.25); r2 = dot2(pos); if( r2>5.0 ) return mindist; if( pos.y >0.5 ) return mindist; if( pos.y>-0.2 && dot(pos.xz,pos.xz)>0.6 ) return mindist; if( r2>(1.7+mindist)*(1.7+mindist) ) return mindist; // algo ayuda, poco, pero algo oiga float r = sqrt(r2); if( r<0.75 ) { float a1 = 1.0-smoothstep( 0.0, 0.75, r ); a1 *= 0.6; vec2 sico = vec2( sin(a1), cos(a1) ); float nx = pos.x; float ny = pos.y; pos.x = nx*sico.y - ny*sico.x; pos.y = nx*sico.x + ny*sico.y; } #define TENTACURA 0.045 float mindist2 = 100000.0; vec3 p = pos; float rr = 0.05+length(pos.xz); float ca = (0.5-TENTACURA*0.75) -6.0*rr*exp2(-10.0*rr); for( int j=1+ZERO; j<7; j++ ) { float an = (6.2831/7.0) * float(j); float aa = an + 0.40*rr*noise(vec3(4.0*rr, 2.5, an)) + 0.29; float rc = cos(aa); float rs = sin(aa); vec3 q = vec3( p.x*rc-p.z*rs, p.y+ca, p.x*rs+p.z*rc ); float dd = dot(q.yz,q.yz); if( q.x>0.0 && q.x<1.5 && dd>10)&7u)>6u ); float peld = max(fract(ax),fract(az)); peld = smoothstep( 0.975, 1.0, peld ); if( ba ) peld = 1.0; dis += 0.005*peld; mindist = dis; if( peld>0.0000001 ) sid = 2u; else sid = 0u; } //----------------------- // techo //----------------------- if( pos.y>1.0 ) { float dis = techo2( fract(pos.x), pos.y, fract(pos.z) ); if( distMax ) break; } resSurface = 666u; } vec3 calcNormal( vec3 pos ) { #if 0 // original code const float eps = 0.0002; uint kk, kk2; vec3 nor = vec3( map( pos.x+eps, pos.y, pos.z, kk, kk2 ) - map( pos.x-eps, pos.y, pos.z, kk, kk2 ), map( pos.x, pos.y+eps, pos.z, kk, kk2 ) - map( pos.x, pos.y-eps, pos.z, kk, kk2 ), map( pos.x, pos.y, pos.z+eps, kk, kk2 ) - map( pos.x, pos.y, pos.z-eps, kk, kk2 )); return normalize(nor); #else // inspired by tdhooper and klems - a way to prevent the compiler from inlining map() 4 times vec3 n = vec3(0.0); for( int i=ZERO; i<4; i++ ) { uint kk, kk2; vec3 e = 0.5773*(2.0*vec3((((i+3)>>1)&1),((i>>1)&1),(i&1))-1.0); n += e*map(pos+0.0002*e, kk, kk2); if( n.x+n.y+n.z>100.0 ) break; } return normalize(n); #endif } vec3 shade( vec3 pos, vec3 rd, uint matID, uint subMatID, float dis ) { if( matID==666u ) return vec3(0.0,0.0,0.0); vec3 col = vec3(0.1*dis); // calc normal vec3 nor = calcNormal( pos ); // bump mapping #if 1 const float kke = 0.0001; float bumpa = 0.0075; if( matID!=5u ) bumpa *= 0.75; if( matID==4u ) bumpa *= 0.50; bumpa /= kke; float kk = fbm( 32.0*pos ); nor.x += bumpa*(fbm( 32.0*vec3(pos.x+kke, pos.y, pos.z) )-kk); nor.y += bumpa*(fbm( 32.0*vec3(pos.x, pos.y+kke, pos.z) )-kk); nor.z += bumpa*(fbm( 32.0*vec3(pos.x, pos.y, pos.z+kke) )-kk); nor = normalize(nor); #endif // light float spe = 0.0; vec3 lig = vec3( 0.5, 0.8, 1.5 ) - pos; float llig = dot2(lig); float im = 1.0/sqrt(llig); lig *= im; float dif = dot( nor, lig ); if( matID==4u ) dif = 0.5+0.5*dif; else dif = 0.10+0.90*dif; dif = max( dif, 0.0 ); dif *= 2.5*exp2( -1.75*llig ); float dif2 = (nor.x+nor.y)*0.075; // materials if( matID==0u ) { float xoff = 13.1 * float(subMatID&255u); float fb = fbm( 16.0*vec3(pos.x+xoff, pos.y, pos.z) ); col = 0.7 + vec3(0.20,0.22,0.25)*fb; float baldscale = float((subMatID>>9)&15u)/14.0; baldscale = 0.51 + 0.34*baldscale; col *= baldscale; float fx = 1.0; if( (subMatID&256u)!=0u ) fx = -1.0; float m = sin( 64.0*pos.z*fx + 64.0*pos.x + 4.0*fb ); m = smoothstep( 0.25, 0.5, m ) - smoothstep( 0.5, 0.75, m ); col += m*0.15; } else if( matID==2u ) { col = vec3(0.0,0.0,0.0); } else if( matID==1u ) { float fb = fbm( 16.0*pos ); float m = sin( 64.0*pos.z + 64.0*pos.x + 4.0*fb ); m = smoothstep( 0.3, 0.5, m ) - smoothstep( 0.5, 0.7, m ); col = 0.59 + fb*vec3(0.17,0.18,0.21) + m*0.15 + dif2; } else if( matID==4u ) { float ft = fbm( 16.0*pos ); col = vec3(0.82,0.73,0.65) + ft*vec3(0.10,0.10,0.15); float fs = 0.90+0.10*fbm( 32.0*pos ); col *= fs; float fre = -dot( nor, rd ); if( fre<0.0 ) fre=0.0; fre = fre*fre*0.45; col -= fre; spe = (nor.y-nor.z)*0.707; spe = spe*spe; spe = spe*spe; spe = spe*spe; spe = spe*spe; spe = spe*spe; spe *= 0.20; } // techo else //if( matID==5 ) { float fb = fbm( 16.0*pos ); col = vec3(0.64,0.61,0.59) + fb*vec3(0.21,0.19,0.19) + dif2; } // AO float ao; #if 1 float totao = 0.0; float sca = 10.0; for( int aoi=ZERO; aoi<5; aoi++ ) { float hr = 0.01 + 0.015*float(aoi*aoi); vec3 aopos = pos + hr*nor; uint kk, kk2; float dd = map( aopos, kk, kk2 ); ao = -(dd-hr); totao += ao*sca; sca *= 0.5; //if( totao>1000.0+sin(iTime) ) break; } ao = 1.0 - clamp( totao, 0.0, 1.0 ); #else ao = 1.0; #endif // shadow #if 1 float so = 0.0; for( int i=ZERO; i<6; i++ ) { float h = float(i)/6.0; float hr = 0.01 + 1.0*h; vec3 aopos = pos + hr*lig; uint kk, kk2; float dd = map( aopos, kk, kk2 ); so += (1.0-h)*dd*20.0/6.0; //if( so>1000.0+iTime ) break; } dif *= clamp( (so-0.40)*1.5, 0.0, 1.0 ); #endif // shade float ao2 = 0.05 + 0.95*ao; col *= vec3(0.25,0.30,0.35)*ao + dif*ao2*vec3(1.95,1.65,1.05); col += spe; col *= exp2( -0.40*pos.z ); return col; } vec3 post( vec3 col, vec2 p ) { // flare float rr = (p.x+0.10)*(p.x+0.10) + (p.y-0.40)*(p.y-0.40); col += vec3( 1.0, 0.95, 0.90 )*0.75*exp2( -64.0*rr ); // color correct col = sqrt(col)*0.3 + 0.7*col; col *= vec3(0.83,1.00,0.83); // vignetting col *= 0.25 + 0.75*clamp( 0.60*abs(p.x-1.77)*abs(p.x+1.77), 0.0, 1.0 ); return clamp( col, 0.0, 1.0 ); } vec3 computePixel( vec2 p, vec2 res, float time ) { vec2 s = (2.0*p-res)/res.y; // fisheye distortion float r2 = s.x*s.x*0.32 + s.y*s.y; float tt = (7.0-sqrt(37.5-11.5*r2))/(r2+1.0); // create camera and ray vec2 d = s*tt; #if 0 vec3 ro = vec3( 0.195, 0.5, 0.0 ); vec3 rd = normalize( vec3( d.x*0.955336 + 0.29552, d.y, 0.955336 - d.x*0.29552 ) ); #else float an = 4.4 + 0.2*sin(0.4*time); vec3 ta = vec3(0.64,0.50,1.5); vec3 ro = ta + 1.55*vec3( cos(an), 0.0, sin(an)); vec3 ww = normalize( ta-ro ); vec3 vv = vec3(0.0,1.0,0.0); vec3 uu = normalize(cross(vv,ww)); vec3 rd = normalize( uu*d.x + vv*d.y + 1.0*ww ); #endif float t; uint matID, sumMatID; vec3 xyz; // raycast raycast( ro, rd, 0.5, 24.0, t, xyz, matID, sumMatID ); // shade vec3 col = shade( xyz, rd, matID, sumMatID, t ); // postprocess col = post( col, s ); return col; } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { #if AA<2 vec3 col = computePixel(fragCoord, iResolution.xy, iTime ); #else vec3 col = vec3(0.0); for( int j=0; j((ref) => 0.0); /// shader URL changed when pressing a button in controls.dart final stateUrl = StateProvider((ref) => ''); final stateTextureCreated = StateProvider((ref) => false); final stateTextureSize = StateProvider((ref) => const Size(600, 337)); final stateTextureId = StateProvider((ref) => -1); /// current index in the shaderToy list final stateShaderIndex = StateProvider((ref) => -1); /// Absolute video file path final statePickedVideo = StateProvider((ref) => ''); /// The VideoCapture state final stateCaptureRunning = StateProvider((ref) => false); enum TextureFilter { nearest, linear, mipmap, } enum TextureWrap { clamp, repeat, } class TextureParams { final String assetImage; final TextureFilter filter; final TextureWrap wrap; final bool vFlip; TextureParams({ this.assetImage = '', this.filter = TextureFilter.linear, this.wrap = TextureWrap.repeat, this.vFlip = false, }); TextureParams copyWith({ String? assetsImage, TextureFilter? filter, TextureWrap? wrap, bool? vFlip, }) { return TextureParams( assetImage: assetsImage ?? this.assetImage, filter: filter ?? this.filter, wrap: wrap ?? this.wrap, vFlip: vFlip ?? this.vFlip, ); } } final stateChannel0 = StateProvider((ref) => TextureParams()); final stateChannel1 = StateProvider((ref) => TextureParams()); final stateChannel2 = StateProvider((ref) => TextureParams()); final stateChannel3 = StateProvider((ref) => TextureParams()); ================================================ FILE: example/lib/test_widget.dart ================================================ import 'package:flutter/material.dart'; import 'shader_widget.dart'; import 'shadertoy.dart'; /// A widget that uses [ShaderWidget] by grabbing it /// and passing the image to the shader as a texture class TestWidget extends StatelessWidget { /// the ShaderToy code (the last string in the URL) final String shaderToyCode; const TestWidget({ Key? key, required this.shaderToyCode, }) : super(key: key); @override Widget build(BuildContext context) { int shaderToyIndex = shaderToy.indexWhere((element) => element['url']!.contains(shaderToyCode)); return Padding( padding: const EdgeInsets.all(30.0), child: ShaderWidget( shaderToyIndex: shaderToyIndex, child: Container( padding: const EdgeInsets.all(22), decoration: BoxDecoration( color: const Color(0xffececec), border: Border.all(width: 2, color: const Color(0xFF2F87EC)), ), child: Column( mainAxisSize: MainAxisSize.min, children: [ Column( children: [ Image.asset('assets/dash.png', height: 100), const SizedBox(height: 12), const Text( 'Lorem ipsum dolor sit amet, consectetur adipisici elit, ' 'sed eiusmod tempor incidunt ut labore et dolore magna ' 'aliqua. Ut enim ad minim veniam, quis nostrud ', style: TextStyle(color: Colors.black), ), ], ), const SizedBox(height: 30), Row( mainAxisAlignment: MainAxisAlignment.spaceEvenly, children: [ ElevatedButton( onPressed: () {}, child: const Text('Cancel'), ), ElevatedButton( onPressed: () {}, child: const Text('OK'), ), ], ) ], ), ), ), ); } } ================================================ FILE: example/linux/.gitignore ================================================ flutter/ephemeral ================================================ FILE: example/linux/CMakeLists.txt ================================================ # Project-level configuration. cmake_minimum_required(VERSION 3.10) project(runner LANGUAGES CXX) # The name of the executable created for the application. Change this to change # the on-disk name of your application. set(BINARY_NAME "flutter_opengl_example") # The unique GTK application identifier for this application. See: # https://wiki.gnome.org/HowDoI/ChooseApplicationID set(APPLICATION_ID "com.example.flutter_opengl") # Explicitly opt in to modern CMake behaviors to avoid warnings with recent # versions of CMake. cmake_policy(SET CMP0063 NEW) # Load bundled libraries from the lib/ directory relative to the binary. set(CMAKE_INSTALL_RPATH "$ORIGIN/lib") # Root filesystem for cross-building. if(FLUTTER_TARGET_PLATFORM_SYSROOT) set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT}) set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT}) set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) endif() # Define build configuration options. if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Flutter build mode" FORCE) set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Profile" "Release") endif() # Compilation settings that should be applied to most targets. # # Be cautious about adding new options here, as plugins use this function by # default. In most cases, you should add new options to specific targets instead # of modifying this function. function(APPLY_STANDARD_SETTINGS TARGET) target_compile_features(${TARGET} PUBLIC cxx_std_14) target_compile_options(${TARGET} PRIVATE -Wall -Werror) target_compile_options(${TARGET} PRIVATE "$<$>:-O3>") target_compile_definitions(${TARGET} PRIVATE "$<$>:NDEBUG>") endfunction() # Flutter library and tool build rules. set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") add_subdirectory(${FLUTTER_MANAGED_DIR}) # System-level dependencies. find_package(PkgConfig REQUIRED) pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}") # Define the application target. To change its name, change BINARY_NAME above, # not the value here, or `flutter run` will no longer work. # # Any new source files that you add to the application should be added here. add_executable(${BINARY_NAME} "main.cc" "my_application.cc" "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" ) # Apply the standard set of build settings. This can be removed for applications # that need different build settings. apply_standard_settings(${BINARY_NAME}) # Add dependency libraries. Add any application-specific dependencies here. target_link_libraries(${BINARY_NAME} PRIVATE flutter) target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK) # Run the Flutter tool portions of the build. This must not be removed. add_dependencies(${BINARY_NAME} flutter_assemble) # Only the install-generated bundle's copy of the executable will launch # correctly, since the resources must in the right relative locations. To avoid # people trying to run the unbundled copy, put it in a subdirectory instead of # the default top-level location. set_target_properties(${BINARY_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run" ) # Generated plugin build rules, which manage building the plugins and adding # them to the application. include(flutter/generated_plugins.cmake) # === Installation === # By default, "installing" just makes a relocatable bundle in the build # directory. set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle") if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) endif() # Start with a clean build bundle directory every time. install(CODE " file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\") " COMPONENT Runtime) set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib") install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" COMPONENT Runtime) install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" COMPONENT Runtime) foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES}) install(FILES "${bundled_library}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" COMPONENT Runtime) endforeach(bundled_library) # Fully re-copy the assets directory on each build to avoid having stale files # from a previous install. set(FLUTTER_ASSET_DIR_NAME "flutter_assets") install(CODE " file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") " COMPONENT Runtime) install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) # Install the AOT library on non-Debug builds only. if(NOT CMAKE_BUILD_TYPE MATCHES "Debug") install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" COMPONENT Runtime) endif() ================================================ FILE: example/linux/flutter/CMakeLists.txt ================================================ # This file controls Flutter-level build steps. It should not be edited. cmake_minimum_required(VERSION 3.10) set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") # Configuration provided via flutter tool. include(${EPHEMERAL_DIR}/generated_config.cmake) # TODO: Move the rest of this into files in ephemeral. See # https://github.com/flutter/flutter/issues/57146. # Serves the same purpose as list(TRANSFORM ... PREPEND ...), # which isn't available in 3.10. function(list_prepend LIST_NAME PREFIX) set(NEW_LIST "") foreach(element ${${LIST_NAME}}) list(APPEND NEW_LIST "${PREFIX}${element}") endforeach(element) set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE) endfunction() # === Flutter Library === # System-level dependencies. find_package(PkgConfig REQUIRED) pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0) pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0) set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so") # Published to parent scope for install step. set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE) list(APPEND FLUTTER_LIBRARY_HEADERS "fl_basic_message_channel.h" "fl_binary_codec.h" "fl_binary_messenger.h" "fl_dart_project.h" "fl_engine.h" "fl_json_message_codec.h" "fl_json_method_codec.h" "fl_message_codec.h" "fl_method_call.h" "fl_method_channel.h" "fl_method_codec.h" "fl_method_response.h" "fl_plugin_registrar.h" "fl_plugin_registry.h" "fl_standard_message_codec.h" "fl_standard_method_codec.h" "fl_string_codec.h" "fl_value.h" "fl_view.h" "flutter_linux.h" ) list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/") add_library(flutter INTERFACE) target_include_directories(flutter INTERFACE "${EPHEMERAL_DIR}" ) target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}") target_link_libraries(flutter INTERFACE PkgConfig::GTK PkgConfig::GLIB PkgConfig::GIO ) add_dependencies(flutter flutter_assemble) # === Flutter tool backend === # _phony_ is a non-existent file to force this command to run every time, # since currently there's no way to get a full input/output list from the # flutter tool. add_custom_command( OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} ${CMAKE_CURRENT_BINARY_DIR}/_phony_ COMMAND ${CMAKE_COMMAND} -E env ${FLUTTER_TOOL_ENVIRONMENT} "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh" ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE} VERBATIM ) add_custom_target(flutter_assemble DEPENDS "${FLUTTER_LIBRARY}" ${FLUTTER_LIBRARY_HEADERS} ) ================================================ FILE: example/linux/flutter/generated_plugin_registrant.cc ================================================ // // Generated file. Do not edit. // // clang-format off #include "generated_plugin_registrant.h" #include #include void fl_register_plugins(FlPluginRegistry* registry) { g_autoptr(FlPluginRegistrar) flutter_opengl_registrar = fl_plugin_registry_get_registrar_for_plugin(registry, "FlutterOpenglPlugin"); flutter_opengl_plugin_register_with_registrar(flutter_opengl_registrar); g_autoptr(FlPluginRegistrar) url_launcher_linux_registrar = fl_plugin_registry_get_registrar_for_plugin(registry, "UrlLauncherPlugin"); url_launcher_plugin_register_with_registrar(url_launcher_linux_registrar); } ================================================ FILE: example/linux/flutter/generated_plugin_registrant.h ================================================ // // Generated file. Do not edit. // // clang-format off #ifndef GENERATED_PLUGIN_REGISTRANT_ #define GENERATED_PLUGIN_REGISTRANT_ #include // Registers Flutter plugins. void fl_register_plugins(FlPluginRegistry* registry); #endif // GENERATED_PLUGIN_REGISTRANT_ ================================================ FILE: example/linux/flutter/generated_plugins.cmake ================================================ # # Generated file, do not edit. # list(APPEND FLUTTER_PLUGIN_LIST flutter_opengl url_launcher_linux ) list(APPEND FLUTTER_FFI_PLUGIN_LIST ) set(PLUGIN_BUNDLED_LIBRARIES) foreach(plugin ${FLUTTER_PLUGIN_LIST}) add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin}) target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) list(APPEND PLUGIN_BUNDLED_LIBRARIES $) list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) endforeach(plugin) foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin}) list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) endforeach(ffi_plugin) ================================================ FILE: example/linux/main.cc ================================================ #include "my_application.h" int main(int argc, char** argv) { g_autoptr(MyApplication) app = my_application_new(); return g_application_run(G_APPLICATION(app), argc, argv); } ================================================ FILE: example/linux/my_application.cc ================================================ #include "my_application.h" #include #ifdef GDK_WINDOWING_X11 #include #endif #include "flutter/generated_plugin_registrant.h" struct _MyApplication { GtkApplication parent_instance; char** dart_entrypoint_arguments; }; G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION) // Implements GApplication::activate. static void my_application_activate(GApplication* application) { MyApplication* self = MY_APPLICATION(application); GtkWindow* window = GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application))); // Use a header bar when running in GNOME as this is the common style used // by applications and is the setup most users will be using (e.g. Ubuntu // desktop). // If running on X and not using GNOME then just use a traditional title bar // in case the window manager does more exotic layout, e.g. tiling. // If running on Wayland assume the header bar will work (may need changing // if future cases occur). gboolean use_header_bar = TRUE; #ifdef GDK_WINDOWING_X11 GdkScreen* screen = gtk_window_get_screen(window); if (GDK_IS_X11_SCREEN(screen)) { const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen); if (g_strcmp0(wm_name, "GNOME Shell") != 0) { use_header_bar = FALSE; } } #endif if (use_header_bar) { GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new()); gtk_widget_show(GTK_WIDGET(header_bar)); gtk_header_bar_set_title(header_bar, "flutter_opengl_example"); gtk_header_bar_set_show_close_button(header_bar, TRUE); gtk_window_set_titlebar(window, GTK_WIDGET(header_bar)); } else { gtk_window_set_title(window, "flutter_opengl_example"); } gtk_window_set_default_size(window, 550, 900); gtk_widget_show(GTK_WIDGET(window)); g_autoptr(FlDartProject) project = fl_dart_project_new(); fl_dart_project_set_dart_entrypoint_arguments(project, self->dart_entrypoint_arguments); FlView* view = fl_view_new(project); gtk_widget_show(GTK_WIDGET(view)); gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view)); fl_register_plugins(FL_PLUGIN_REGISTRY(view)); gtk_widget_grab_focus(GTK_WIDGET(view)); } // Implements GApplication::local_command_line. static gboolean my_application_local_command_line(GApplication* application, gchar*** arguments, int* exit_status) { MyApplication* self = MY_APPLICATION(application); // Strip out the first argument as it is the binary name. self->dart_entrypoint_arguments = g_strdupv(*arguments + 1); g_autoptr(GError) error = nullptr; if (!g_application_register(application, nullptr, &error)) { g_warning("Failed to register: %s", error->message); *exit_status = 1; return TRUE; } g_application_activate(application); *exit_status = 0; return TRUE; } // Implements GObject::dispose. static void my_application_dispose(GObject* object) { MyApplication* self = MY_APPLICATION(object); g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev); G_OBJECT_CLASS(my_application_parent_class)->dispose(object); } static void my_application_class_init(MyApplicationClass* klass) { G_APPLICATION_CLASS(klass)->activate = my_application_activate; G_APPLICATION_CLASS(klass)->local_command_line = my_application_local_command_line; G_OBJECT_CLASS(klass)->dispose = my_application_dispose; } static void my_application_init(MyApplication* self) {} MyApplication* my_application_new() { return MY_APPLICATION(g_object_new(my_application_get_type(), "application-id", APPLICATION_ID, "flags", G_APPLICATION_NON_UNIQUE, nullptr)); } ================================================ FILE: example/linux/my_application.h ================================================ #ifndef FLUTTER_MY_APPLICATION_H_ #define FLUTTER_MY_APPLICATION_H_ #include G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION, GtkApplication) /** * my_application_new: * * Creates a new Flutter-based application. * * Returns: a new #MyApplication. */ MyApplication* my_application_new(); #endif // FLUTTER_MY_APPLICATION_H_ ================================================ FILE: example/macos/.gitignore ================================================ # Flutter-related **/Flutter/ephemeral/ **/Pods/ # Xcode-related **/dgph **/xcuserdata/ ================================================ FILE: example/macos/Flutter/Flutter-Debug.xcconfig ================================================ #include "ephemeral/Flutter-Generated.xcconfig" ================================================ FILE: example/macos/Flutter/Flutter-Release.xcconfig ================================================ #include "ephemeral/Flutter-Generated.xcconfig" ================================================ FILE: example/macos/Flutter/GeneratedPluginRegistrant.swift ================================================ // // Generated file. Do not edit. // import FlutterMacOS import Foundation import flutter_opengl import url_launcher_macos func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) { FlutterOpenglPlugin.register(with: registry.registrar(forPlugin: "FlutterOpenglPlugin")) UrlLauncherPlugin.register(with: registry.registrar(forPlugin: "UrlLauncherPlugin")) } ================================================ FILE: example/macos/Runner/AppDelegate.swift ================================================ import Cocoa import FlutterMacOS @NSApplicationMain class AppDelegate: FlutterAppDelegate { override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { return true } } ================================================ FILE: example/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json ================================================ { "images" : [ { "size" : "16x16", "idiom" : "mac", "filename" : "app_icon_16.png", "scale" : "1x" }, { "size" : "16x16", "idiom" : "mac", "filename" : "app_icon_32.png", "scale" : "2x" }, { "size" : "32x32", "idiom" : "mac", "filename" : "app_icon_32.png", "scale" : "1x" }, { "size" : "32x32", "idiom" : "mac", "filename" : "app_icon_64.png", "scale" : "2x" }, { "size" : "128x128", "idiom" : "mac", "filename" : "app_icon_128.png", "scale" : "1x" }, { "size" : "128x128", "idiom" : "mac", "filename" : "app_icon_256.png", "scale" : "2x" }, { "size" : "256x256", "idiom" : "mac", "filename" : "app_icon_256.png", "scale" : "1x" }, { "size" : "256x256", "idiom" : "mac", "filename" : "app_icon_512.png", "scale" : "2x" }, { "size" : "512x512", "idiom" : "mac", "filename" : "app_icon_512.png", "scale" : "1x" }, { "size" : "512x512", "idiom" : "mac", "filename" : "app_icon_1024.png", "scale" : "2x" } ], "info" : { "version" : 1, "author" : "xcode" } } ================================================ FILE: example/macos/Runner/Base.lproj/MainMenu.xib ================================================ ================================================ FILE: example/macos/Runner/Configs/AppInfo.xcconfig ================================================ // Application-level settings for the Runner target. // // This may be replaced with something auto-generated from metadata (e.g., pubspec.yaml) in the // future. If not, the values below would default to using the project name when this becomes a // 'flutter create' template. // The application's name. By default this is also the title of the Flutter window. PRODUCT_NAME = flutter_opengl_example // The application's bundle identifier PRODUCT_BUNDLE_IDENTIFIER = com.example.flutterOpenglExample // The copyright displayed in application information PRODUCT_COPYRIGHT = Copyright © 2022 com.example. All rights reserved. ================================================ FILE: example/macos/Runner/Configs/Debug.xcconfig ================================================ #include "../../Flutter/Flutter-Debug.xcconfig" #include "Warnings.xcconfig" ================================================ FILE: example/macos/Runner/Configs/Release.xcconfig ================================================ #include "../../Flutter/Flutter-Release.xcconfig" #include "Warnings.xcconfig" ================================================ FILE: example/macos/Runner/Configs/Warnings.xcconfig ================================================ WARNING_CFLAGS = -Wall -Wconditional-uninitialized -Wnullable-to-nonnull-conversion -Wmissing-method-return-type -Woverlength-strings GCC_WARN_UNDECLARED_SELECTOR = YES CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY = YES CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE CLANG_WARN__DUPLICATE_METHOD_MATCH = YES CLANG_WARN_PRAGMA_PACK = YES CLANG_WARN_STRICT_PROTOTYPES = YES CLANG_WARN_COMMA = YES GCC_WARN_STRICT_SELECTOR_MATCH = YES CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK = YES CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES GCC_WARN_SHADOW = YES CLANG_WARN_UNREACHABLE_CODE = YES ================================================ FILE: example/macos/Runner/DebugProfile.entitlements ================================================ com.apple.security.app-sandbox com.apple.security.cs.allow-jit com.apple.security.network.server ================================================ FILE: example/macos/Runner/Info.plist ================================================ CFBundleDevelopmentRegion $(DEVELOPMENT_LANGUAGE) CFBundleExecutable $(EXECUTABLE_NAME) CFBundleIconFile CFBundleIdentifier $(PRODUCT_BUNDLE_IDENTIFIER) CFBundleInfoDictionaryVersion 6.0 CFBundleName $(PRODUCT_NAME) CFBundlePackageType APPL CFBundleShortVersionString $(FLUTTER_BUILD_NAME) CFBundleVersion $(FLUTTER_BUILD_NUMBER) LSMinimumSystemVersion $(MACOSX_DEPLOYMENT_TARGET) NSHumanReadableCopyright $(PRODUCT_COPYRIGHT) NSMainNibFile MainMenu NSPrincipalClass NSApplication ================================================ FILE: example/macos/Runner/MainFlutterWindow.swift ================================================ import Cocoa import FlutterMacOS class MainFlutterWindow: NSWindow { override func awakeFromNib() { let flutterViewController = FlutterViewController.init() let windowFrame = self.frame self.contentViewController = flutterViewController self.setFrame(windowFrame, display: true) RegisterGeneratedPlugins(registry: flutterViewController) super.awakeFromNib() } } ================================================ FILE: example/macos/Runner/Release.entitlements ================================================ com.apple.security.app-sandbox ================================================ FILE: example/macos/Runner.xcodeproj/project.pbxproj ================================================ // !$*UTF8*$! { archiveVersion = 1; classes = { }; objectVersion = 51; objects = { /* Begin PBXAggregateTarget section */ 33CC111A2044C6BA0003C045 /* Flutter Assemble */ = { isa = PBXAggregateTarget; buildConfigurationList = 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */; buildPhases = ( 33CC111E2044C6BF0003C045 /* ShellScript */, ); dependencies = ( ); name = "Flutter Assemble"; productName = FLX; }; /* End PBXAggregateTarget section */ /* Begin PBXBuildFile section */ 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */ = {isa = PBXBuildFile; fileRef = 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */; }; 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC10F02044A3C60003C045 /* AppDelegate.swift */; }; 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F22044A3C60003C045 /* Assets.xcassets */; }; 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F42044A3C60003C045 /* MainMenu.xib */; }; 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */; }; /* End PBXBuildFile section */ /* Begin PBXContainerItemProxy section */ 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */ = { isa = PBXContainerItemProxy; containerPortal = 33CC10E52044A3C60003C045 /* Project object */; proxyType = 1; remoteGlobalIDString = 33CC111A2044C6BA0003C045; remoteInfo = FLX; }; /* End PBXContainerItemProxy section */ /* Begin PBXCopyFilesBuildPhase section */ 33CC110E2044A8840003C045 /* Bundle Framework */ = { isa = PBXCopyFilesBuildPhase; buildActionMask = 2147483647; dstPath = ""; dstSubfolderSpec = 10; files = ( ); name = "Bundle Framework"; runOnlyForDeploymentPostprocessing = 0; }; /* End PBXCopyFilesBuildPhase section */ /* Begin PBXFileReference section */ 333000ED22D3DE5D00554162 /* Warnings.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Warnings.xcconfig; sourceTree = ""; }; 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GeneratedPluginRegistrant.swift; sourceTree = ""; }; 33CC10ED2044A3C60003C045 /* flutter_opengl_example.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "flutter_opengl_example.app"; sourceTree = BUILT_PRODUCTS_DIR; }; 33CC10F02044A3C60003C045 /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; 33CC10F22044A3C60003C045 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Assets.xcassets; path = Runner/Assets.xcassets; sourceTree = ""; }; 33CC10F52044A3C60003C045 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/MainMenu.xib; sourceTree = ""; }; 33CC10F72044A3C60003C045 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = Info.plist; path = Runner/Info.plist; sourceTree = ""; }; 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MainFlutterWindow.swift; sourceTree = ""; }; 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Debug.xcconfig"; sourceTree = ""; }; 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Release.xcconfig"; sourceTree = ""; }; 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = "Flutter-Generated.xcconfig"; path = "ephemeral/Flutter-Generated.xcconfig"; sourceTree = ""; }; 33E51913231747F40026EE4D /* DebugProfile.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = DebugProfile.entitlements; sourceTree = ""; }; 33E51914231749380026EE4D /* Release.entitlements */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.entitlements; path = Release.entitlements; sourceTree = ""; }; 33E5194F232828860026EE4D /* AppInfo.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = AppInfo.xcconfig; sourceTree = ""; }; 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = ""; }; 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = ""; }; /* End PBXFileReference section */ /* Begin PBXFrameworksBuildPhase section */ 33CC10EA2044A3C60003C045 /* Frameworks */ = { isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = ( ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXFrameworksBuildPhase section */ /* Begin PBXGroup section */ 33BA886A226E78AF003329D5 /* Configs */ = { isa = PBXGroup; children = ( 33E5194F232828860026EE4D /* AppInfo.xcconfig */, 9740EEB21CF90195004384FC /* Debug.xcconfig */, 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, 333000ED22D3DE5D00554162 /* Warnings.xcconfig */, ); path = Configs; sourceTree = ""; }; 33CC10E42044A3C60003C045 = { isa = PBXGroup; children = ( 33FAB671232836740065AC1E /* Runner */, 33CEB47122A05771004F2AC0 /* Flutter */, 33CC10EE2044A3C60003C045 /* Products */, D73912EC22F37F3D000D13A0 /* Frameworks */, ); sourceTree = ""; }; 33CC10EE2044A3C60003C045 /* Products */ = { isa = PBXGroup; children = ( 33CC10ED2044A3C60003C045 /* flutter_opengl_example.app */, ); name = Products; sourceTree = ""; }; 33CC11242044D66E0003C045 /* Resources */ = { isa = PBXGroup; children = ( 33CC10F22044A3C60003C045 /* Assets.xcassets */, 33CC10F42044A3C60003C045 /* MainMenu.xib */, 33CC10F72044A3C60003C045 /* Info.plist */, ); name = Resources; path = ..; sourceTree = ""; }; 33CEB47122A05771004F2AC0 /* Flutter */ = { isa = PBXGroup; children = ( 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */, 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */, 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */, 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */, ); path = Flutter; sourceTree = ""; }; 33FAB671232836740065AC1E /* Runner */ = { isa = PBXGroup; children = ( 33CC10F02044A3C60003C045 /* AppDelegate.swift */, 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */, 33E51913231747F40026EE4D /* DebugProfile.entitlements */, 33E51914231749380026EE4D /* Release.entitlements */, 33CC11242044D66E0003C045 /* Resources */, 33BA886A226E78AF003329D5 /* Configs */, ); path = Runner; sourceTree = ""; }; D73912EC22F37F3D000D13A0 /* Frameworks */ = { isa = PBXGroup; children = ( ); name = Frameworks; sourceTree = ""; }; /* End PBXGroup section */ /* Begin PBXNativeTarget section */ 33CC10EC2044A3C60003C045 /* Runner */ = { isa = PBXNativeTarget; buildConfigurationList = 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */; buildPhases = ( 33CC10E92044A3C60003C045 /* Sources */, 33CC10EA2044A3C60003C045 /* Frameworks */, 33CC10EB2044A3C60003C045 /* Resources */, 33CC110E2044A8840003C045 /* Bundle Framework */, 3399D490228B24CF009A79C7 /* ShellScript */, ); buildRules = ( ); dependencies = ( 33CC11202044C79F0003C045 /* PBXTargetDependency */, ); name = Runner; productName = Runner; productReference = 33CC10ED2044A3C60003C045 /* flutter_opengl_example.app */; productType = "com.apple.product-type.application"; }; /* End PBXNativeTarget section */ /* Begin PBXProject section */ 33CC10E52044A3C60003C045 /* Project object */ = { isa = PBXProject; attributes = { LastSwiftUpdateCheck = 0920; LastUpgradeCheck = 1300; ORGANIZATIONNAME = ""; TargetAttributes = { 33CC10EC2044A3C60003C045 = { CreatedOnToolsVersion = 9.2; LastSwiftMigration = 1100; ProvisioningStyle = Automatic; SystemCapabilities = { com.apple.Sandbox = { enabled = 1; }; }; }; 33CC111A2044C6BA0003C045 = { CreatedOnToolsVersion = 9.2; ProvisioningStyle = Manual; }; }; }; buildConfigurationList = 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */; compatibilityVersion = "Xcode 9.3"; developmentRegion = en; hasScannedForEncodings = 0; knownRegions = ( en, Base, ); mainGroup = 33CC10E42044A3C60003C045; productRefGroup = 33CC10EE2044A3C60003C045 /* Products */; projectDirPath = ""; projectRoot = ""; targets = ( 33CC10EC2044A3C60003C045 /* Runner */, 33CC111A2044C6BA0003C045 /* Flutter Assemble */, ); }; /* End PBXProject section */ /* Begin PBXResourcesBuildPhase section */ 33CC10EB2044A3C60003C045 /* Resources */ = { isa = PBXResourcesBuildPhase; buildActionMask = 2147483647; files = ( 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */, 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */, ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXResourcesBuildPhase section */ /* Begin PBXShellScriptBuildPhase section */ 3399D490228B24CF009A79C7 /* ShellScript */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; files = ( ); inputFileListPaths = ( ); inputPaths = ( ); outputFileListPaths = ( ); outputPaths = ( ); runOnlyForDeploymentPostprocessing = 0; shellPath = /bin/sh; shellScript = "echo \"$PRODUCT_NAME.app\" > \"$PROJECT_DIR\"/Flutter/ephemeral/.app_filename && \"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh embed\n"; }; 33CC111E2044C6BF0003C045 /* ShellScript */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; files = ( ); inputFileListPaths = ( Flutter/ephemeral/FlutterInputs.xcfilelist, ); inputPaths = ( Flutter/ephemeral/tripwire, ); outputFileListPaths = ( Flutter/ephemeral/FlutterOutputs.xcfilelist, ); outputPaths = ( ); runOnlyForDeploymentPostprocessing = 0; shellPath = /bin/sh; shellScript = "\"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh && touch Flutter/ephemeral/tripwire"; }; /* End PBXShellScriptBuildPhase section */ /* Begin PBXSourcesBuildPhase section */ 33CC10E92044A3C60003C045 /* Sources */ = { isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */, 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */, 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXSourcesBuildPhase section */ /* Begin PBXTargetDependency section */ 33CC11202044C79F0003C045 /* PBXTargetDependency */ = { isa = PBXTargetDependency; target = 33CC111A2044C6BA0003C045 /* Flutter Assemble */; targetProxy = 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */; }; /* End PBXTargetDependency section */ /* Begin PBXVariantGroup section */ 33CC10F42044A3C60003C045 /* MainMenu.xib */ = { isa = PBXVariantGroup; children = ( 33CC10F52044A3C60003C045 /* Base */, ); name = MainMenu.xib; path = Runner; sourceTree = ""; }; /* End PBXVariantGroup section */ /* Begin XCBuildConfiguration section */ 338D0CE9231458BD00FA5F75 /* Profile */ = { isa = XCBuildConfiguration; baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { ALWAYS_SEARCH_USER_PATHS = NO; CLANG_ANALYZER_NONNULL = YES; CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; CLANG_CXX_LIBRARY = "libc++"; CLANG_ENABLE_MODULES = YES; CLANG_ENABLE_OBJC_ARC = YES; CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; CLANG_WARN_BOOL_CONVERSION = YES; CLANG_WARN_CONSTANT_CONVERSION = YES; CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; CLANG_WARN_DOCUMENTATION_COMMENTS = YES; CLANG_WARN_EMPTY_BODY = YES; CLANG_WARN_ENUM_CONVERSION = YES; CLANG_WARN_INFINITE_RECURSION = YES; CLANG_WARN_INT_CONVERSION = YES; CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; CLANG_WARN_SUSPICIOUS_MOVE = YES; CODE_SIGN_IDENTITY = "-"; COPY_PHASE_STRIP = NO; DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; ENABLE_NS_ASSERTIONS = NO; ENABLE_STRICT_OBJC_MSGSEND = YES; GCC_C_LANGUAGE_STANDARD = gnu11; GCC_NO_COMMON_BLOCKS = YES; GCC_WARN_64_TO_32_BIT_CONVERSION = YES; GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_VARIABLE = YES; MACOSX_DEPLOYMENT_TARGET = 10.11; MTL_ENABLE_DEBUG_INFO = NO; SDKROOT = macosx; SWIFT_COMPILATION_MODE = wholemodule; SWIFT_OPTIMIZATION_LEVEL = "-O"; }; name = Profile; }; 338D0CEA231458BD00FA5F75 /* Profile */ = { isa = XCBuildConfiguration; baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; buildSettings = { ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; CLANG_ENABLE_MODULES = YES; CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; CODE_SIGN_STYLE = Automatic; COMBINE_HIDPI_IMAGES = YES; INFOPLIST_FILE = Runner/Info.plist; LD_RUNPATH_SEARCH_PATHS = ( "$(inherited)", "@executable_path/../Frameworks", ); PROVISIONING_PROFILE_SPECIFIER = ""; SWIFT_VERSION = 5.0; }; name = Profile; }; 338D0CEB231458BD00FA5F75 /* Profile */ = { isa = XCBuildConfiguration; buildSettings = { CODE_SIGN_STYLE = Manual; PRODUCT_NAME = "$(TARGET_NAME)"; }; name = Profile; }; 33CC10F92044A3C60003C045 /* Debug */ = { isa = XCBuildConfiguration; baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; buildSettings = { ALWAYS_SEARCH_USER_PATHS = NO; CLANG_ANALYZER_NONNULL = YES; CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; CLANG_CXX_LIBRARY = "libc++"; CLANG_ENABLE_MODULES = YES; CLANG_ENABLE_OBJC_ARC = YES; CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; CLANG_WARN_BOOL_CONVERSION = YES; CLANG_WARN_CONSTANT_CONVERSION = YES; CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; CLANG_WARN_DOCUMENTATION_COMMENTS = YES; CLANG_WARN_EMPTY_BODY = YES; CLANG_WARN_ENUM_CONVERSION = YES; CLANG_WARN_INFINITE_RECURSION = YES; CLANG_WARN_INT_CONVERSION = YES; CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; CLANG_WARN_SUSPICIOUS_MOVE = YES; CODE_SIGN_IDENTITY = "-"; COPY_PHASE_STRIP = NO; DEBUG_INFORMATION_FORMAT = dwarf; ENABLE_STRICT_OBJC_MSGSEND = YES; ENABLE_TESTABILITY = YES; GCC_C_LANGUAGE_STANDARD = gnu11; GCC_DYNAMIC_NO_PIC = NO; GCC_NO_COMMON_BLOCKS = YES; GCC_OPTIMIZATION_LEVEL = 0; GCC_PREPROCESSOR_DEFINITIONS = ( "DEBUG=1", "$(inherited)", ); GCC_WARN_64_TO_32_BIT_CONVERSION = YES; GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_VARIABLE = YES; MACOSX_DEPLOYMENT_TARGET = 10.11; MTL_ENABLE_DEBUG_INFO = YES; ONLY_ACTIVE_ARCH = YES; SDKROOT = macosx; SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; SWIFT_OPTIMIZATION_LEVEL = "-Onone"; }; name = Debug; }; 33CC10FA2044A3C60003C045 /* Release */ = { isa = XCBuildConfiguration; baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { ALWAYS_SEARCH_USER_PATHS = NO; CLANG_ANALYZER_NONNULL = YES; CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; CLANG_CXX_LIBRARY = "libc++"; CLANG_ENABLE_MODULES = YES; CLANG_ENABLE_OBJC_ARC = YES; CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; CLANG_WARN_BOOL_CONVERSION = YES; CLANG_WARN_CONSTANT_CONVERSION = YES; CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; CLANG_WARN_DOCUMENTATION_COMMENTS = YES; CLANG_WARN_EMPTY_BODY = YES; CLANG_WARN_ENUM_CONVERSION = YES; CLANG_WARN_INFINITE_RECURSION = YES; CLANG_WARN_INT_CONVERSION = YES; CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; CLANG_WARN_SUSPICIOUS_MOVE = YES; CODE_SIGN_IDENTITY = "-"; COPY_PHASE_STRIP = NO; DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; ENABLE_NS_ASSERTIONS = NO; ENABLE_STRICT_OBJC_MSGSEND = YES; GCC_C_LANGUAGE_STANDARD = gnu11; GCC_NO_COMMON_BLOCKS = YES; GCC_WARN_64_TO_32_BIT_CONVERSION = YES; GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_VARIABLE = YES; MACOSX_DEPLOYMENT_TARGET = 10.11; MTL_ENABLE_DEBUG_INFO = NO; SDKROOT = macosx; SWIFT_COMPILATION_MODE = wholemodule; SWIFT_OPTIMIZATION_LEVEL = "-O"; }; name = Release; }; 33CC10FC2044A3C60003C045 /* Debug */ = { isa = XCBuildConfiguration; baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; buildSettings = { ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; CLANG_ENABLE_MODULES = YES; CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; CODE_SIGN_STYLE = Automatic; COMBINE_HIDPI_IMAGES = YES; INFOPLIST_FILE = Runner/Info.plist; LD_RUNPATH_SEARCH_PATHS = ( "$(inherited)", "@executable_path/../Frameworks", ); PROVISIONING_PROFILE_SPECIFIER = ""; SWIFT_OPTIMIZATION_LEVEL = "-Onone"; SWIFT_VERSION = 5.0; }; name = Debug; }; 33CC10FD2044A3C60003C045 /* Release */ = { isa = XCBuildConfiguration; baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; buildSettings = { ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; CLANG_ENABLE_MODULES = YES; CODE_SIGN_ENTITLEMENTS = Runner/Release.entitlements; CODE_SIGN_STYLE = Automatic; COMBINE_HIDPI_IMAGES = YES; INFOPLIST_FILE = Runner/Info.plist; LD_RUNPATH_SEARCH_PATHS = ( "$(inherited)", "@executable_path/../Frameworks", ); PROVISIONING_PROFILE_SPECIFIER = ""; SWIFT_VERSION = 5.0; }; name = Release; }; 33CC111C2044C6BA0003C045 /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { CODE_SIGN_STYLE = Manual; PRODUCT_NAME = "$(TARGET_NAME)"; }; name = Debug; }; 33CC111D2044C6BA0003C045 /* Release */ = { isa = XCBuildConfiguration; buildSettings = { CODE_SIGN_STYLE = Automatic; PRODUCT_NAME = "$(TARGET_NAME)"; }; name = Release; }; /* End XCBuildConfiguration section */ /* Begin XCConfigurationList section */ 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */ = { isa = XCConfigurationList; buildConfigurations = ( 33CC10F92044A3C60003C045 /* Debug */, 33CC10FA2044A3C60003C045 /* Release */, 338D0CE9231458BD00FA5F75 /* Profile */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */ = { isa = XCConfigurationList; buildConfigurations = ( 33CC10FC2044A3C60003C045 /* Debug */, 33CC10FD2044A3C60003C045 /* Release */, 338D0CEA231458BD00FA5F75 /* Profile */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */ = { isa = XCConfigurationList; buildConfigurations = ( 33CC111C2044C6BA0003C045 /* Debug */, 33CC111D2044C6BA0003C045 /* Release */, 338D0CEB231458BD00FA5F75 /* Profile */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; /* End XCConfigurationList section */ }; rootObject = 33CC10E52044A3C60003C045 /* Project object */; } ================================================ FILE: example/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist ================================================ IDEDidComputeMac32BitWarning ================================================ FILE: example/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme ================================================ ================================================ FILE: example/macos/Runner.xcworkspace/contents.xcworkspacedata ================================================ ================================================ FILE: example/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist ================================================ IDEDidComputeMac32BitWarning ================================================ FILE: example/pubspec.yaml ================================================ name: flutter_opengl_example description: Demonstrates how to use the flutter_opengl plugin. publish_to: 'none' # Remove this line if you wish to publish to pub.dev environment: sdk: '>=2.18.4 <3.0.0' dependencies: flutter: sdk: flutter flutter_opengl: path: ../ cupertino_icons: ^1.0.2 #https://pub.dev/packages/flutter_riverpod flutter_riverpod: ^2.1.3 #https://pub.dev/packages/url_launcher url_launcher: ^6.1.7 #https://pub.dev/packages/star_menu star_menu: ^3.1.3 #https://pub.dev/packages/file_picker file_picker: ^5.2.5 dev_dependencies: flutter_test: sdk: flutter flutter_lints: ^2.0.0 flutter: uses-material-design: true assets: - assets/ fonts: - family: JetBrains fonts: - asset: assets/JetBrainsMono-Regular.ttf ================================================ FILE: example/test/widget_test.dart ================================================ // This is a basic Flutter widget test. // // To perform an interaction with a widget in your test, use the WidgetTester // utility in the flutter_test package. For example, you can send tap and scroll // gestures. You can also use WidgetTester to find child widgets in the widget // tree, read text, and verify that the values of widget properties are correct. import 'package:flutter/material.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:flutter_opengl_example/main.dart'; void main() { testWidgets('Verify Platform version', (WidgetTester tester) async { // Build our app and trigger a frame. await tester.pumpWidget(const MyApp()); // Verify that platform version is retrieved. expect( find.byWidgetPredicate( (Widget widget) => widget is Text && widget.data!.startsWith('Running on:'), ), findsOneWidget, ); }); } ================================================ FILE: example/windows/.gitignore ================================================ flutter/ephemeral/ # Visual Studio user-specific files. *.suo *.user *.userosscache *.sln.docstates # Visual Studio build-related files. x64/ x86/ # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !*.[Cc]ache/ ================================================ FILE: example/windows/CMakeLists.txt ================================================ # Project-level configuration. cmake_minimum_required(VERSION 3.14) project(flutter_opengl_example LANGUAGES CXX) # The name of the executable created for the application. Change this to change # the on-disk name of your application. set(BINARY_NAME "flutter_opengl_example") # Explicitly opt in to modern CMake behaviors to avoid warnings with recent # versions of CMake. cmake_policy(SET CMP0063 NEW) # Define build configuration option. get_property(IS_MULTICONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) if(IS_MULTICONFIG) set(CMAKE_CONFIGURATION_TYPES "Debug;Profile;Release" CACHE STRING "" FORCE) else() if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Flutter build mode" FORCE) set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Profile" "Release") endif() endif() # Define settings for the Profile build mode. set(CMAKE_EXE_LINKER_FLAGS_PROFILE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}") set(CMAKE_SHARED_LINKER_FLAGS_PROFILE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}") set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE}") set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE}") # Use Unicode for all projects. add_definitions(-DUNICODE -D_UNICODE) # Compilation settings that should be applied to most targets. # # Be cautious about adding new options here, as plugins use this function by # default. In most cases, you should add new options to specific targets instead # of modifying this function. function(APPLY_STANDARD_SETTINGS TARGET) target_compile_features(${TARGET} PUBLIC cxx_std_17) target_compile_options(${TARGET} PRIVATE /W4 /WX /wd"4100") target_compile_options(${TARGET} PRIVATE /EHsc) target_compile_definitions(${TARGET} PRIVATE "_HAS_EXCEPTIONS=0") target_compile_definitions(${TARGET} PRIVATE "$<$:_DEBUG>") endfunction() # Flutter library and tool build rules. set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") add_subdirectory(${FLUTTER_MANAGED_DIR}) # Application build; see runner/CMakeLists.txt. add_subdirectory("runner") # Generated plugin build rules, which manage building the plugins and adding # them to the application. include(flutter/generated_plugins.cmake) # === Installation === # Support files are copied into place next to the executable, so that it can # run in place. This is done instead of making a separate bundle (as on Linux) # so that building and running from within Visual Studio will work. set(BUILD_BUNDLE_DIR "$") # Make the "install" step default, as it's required to run. set(CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD 1) if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) endif() set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}") install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" COMPONENT Runtime) install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" COMPONENT Runtime) if(PLUGIN_BUNDLED_LIBRARIES) install(FILES "${PLUGIN_BUNDLED_LIBRARIES}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" COMPONENT Runtime) endif() # Fully re-copy the assets directory on each build to avoid having stale files # from a previous install. set(FLUTTER_ASSET_DIR_NAME "flutter_assets") install(CODE " file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") " COMPONENT Runtime) install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) # Install the AOT library on non-Debug builds only. install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" CONFIGURATIONS Profile;Release COMPONENT Runtime) ================================================ FILE: example/windows/flutter/CMakeLists.txt ================================================ # This file controls Flutter-level build steps. It should not be edited. cmake_minimum_required(VERSION 3.14) set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") # Configuration provided via flutter tool. include(${EPHEMERAL_DIR}/generated_config.cmake) # TODO: Move the rest of this into files in ephemeral. See # https://github.com/flutter/flutter/issues/57146. set(WRAPPER_ROOT "${EPHEMERAL_DIR}/cpp_client_wrapper") # === Flutter Library === set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/flutter_windows.dll") # Published to parent scope for install step. set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) set(AOT_LIBRARY "${PROJECT_DIR}/build/windows/app.so" PARENT_SCOPE) list(APPEND FLUTTER_LIBRARY_HEADERS "flutter_export.h" "flutter_windows.h" "flutter_messenger.h" "flutter_plugin_registrar.h" "flutter_texture_registrar.h" ) list(TRANSFORM FLUTTER_LIBRARY_HEADERS PREPEND "${EPHEMERAL_DIR}/") add_library(flutter INTERFACE) target_include_directories(flutter INTERFACE "${EPHEMERAL_DIR}" ) target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}.lib") add_dependencies(flutter flutter_assemble) # === Wrapper === list(APPEND CPP_WRAPPER_SOURCES_CORE "core_implementations.cc" "standard_codec.cc" ) list(TRANSFORM CPP_WRAPPER_SOURCES_CORE PREPEND "${WRAPPER_ROOT}/") list(APPEND CPP_WRAPPER_SOURCES_PLUGIN "plugin_registrar.cc" ) list(TRANSFORM CPP_WRAPPER_SOURCES_PLUGIN PREPEND "${WRAPPER_ROOT}/") list(APPEND CPP_WRAPPER_SOURCES_APP "flutter_engine.cc" "flutter_view_controller.cc" ) list(TRANSFORM CPP_WRAPPER_SOURCES_APP PREPEND "${WRAPPER_ROOT}/") # Wrapper sources needed for a plugin. add_library(flutter_wrapper_plugin STATIC ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_PLUGIN} ) apply_standard_settings(flutter_wrapper_plugin) set_target_properties(flutter_wrapper_plugin PROPERTIES POSITION_INDEPENDENT_CODE ON) set_target_properties(flutter_wrapper_plugin PROPERTIES CXX_VISIBILITY_PRESET hidden) target_link_libraries(flutter_wrapper_plugin PUBLIC flutter) target_include_directories(flutter_wrapper_plugin PUBLIC "${WRAPPER_ROOT}/include" ) add_dependencies(flutter_wrapper_plugin flutter_assemble) # Wrapper sources needed for the runner. add_library(flutter_wrapper_app STATIC ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_APP} ) apply_standard_settings(flutter_wrapper_app) target_link_libraries(flutter_wrapper_app PUBLIC flutter) target_include_directories(flutter_wrapper_app PUBLIC "${WRAPPER_ROOT}/include" ) add_dependencies(flutter_wrapper_app flutter_assemble) # === Flutter tool backend === # _phony_ is a non-existent file to force this command to run every time, # since currently there's no way to get a full input/output list from the # flutter tool. set(PHONY_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/_phony_") set_source_files_properties("${PHONY_OUTPUT}" PROPERTIES SYMBOLIC TRUE) add_custom_command( OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_PLUGIN} ${CPP_WRAPPER_SOURCES_APP} ${PHONY_OUTPUT} COMMAND ${CMAKE_COMMAND} -E env ${FLUTTER_TOOL_ENVIRONMENT} "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.bat" windows-x64 $ VERBATIM ) add_custom_target(flutter_assemble DEPENDS "${FLUTTER_LIBRARY}" ${FLUTTER_LIBRARY_HEADERS} ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_PLUGIN} ${CPP_WRAPPER_SOURCES_APP} ) ================================================ FILE: example/windows/flutter/generated_plugin_registrant.cc ================================================ // // Generated file. Do not edit. // // clang-format off #include "generated_plugin_registrant.h" #include #include #include void RegisterPlugins(flutter::PluginRegistry* registry) { FlutterOpenglPluginCApiRegisterWithRegistrar( registry->GetRegistrarForPlugin("FlutterOpenglPluginCApi")); PermissionHandlerWindowsPluginRegisterWithRegistrar( registry->GetRegistrarForPlugin("PermissionHandlerWindowsPlugin")); UrlLauncherWindowsRegisterWithRegistrar( registry->GetRegistrarForPlugin("UrlLauncherWindows")); } ================================================ FILE: example/windows/flutter/generated_plugin_registrant.h ================================================ // // Generated file. Do not edit. // // clang-format off #ifndef GENERATED_PLUGIN_REGISTRANT_ #define GENERATED_PLUGIN_REGISTRANT_ #include // Registers Flutter plugins. void RegisterPlugins(flutter::PluginRegistry* registry); #endif // GENERATED_PLUGIN_REGISTRANT_ ================================================ FILE: example/windows/flutter/generated_plugins.cmake ================================================ # # Generated file, do not edit. # list(APPEND FLUTTER_PLUGIN_LIST flutter_opengl permission_handler_windows url_launcher_windows ) list(APPEND FLUTTER_FFI_PLUGIN_LIST ) set(PLUGIN_BUNDLED_LIBRARIES) foreach(plugin ${FLUTTER_PLUGIN_LIST}) add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/windows plugins/${plugin}) target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) list(APPEND PLUGIN_BUNDLED_LIBRARIES $) list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) endforeach(plugin) foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/windows plugins/${ffi_plugin}) list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) endforeach(ffi_plugin) ================================================ FILE: example/windows/runner/CMakeLists.txt ================================================ cmake_minimum_required(VERSION 3.14) project(runner LANGUAGES CXX) # Define the application target. To change its name, change BINARY_NAME in the # top-level CMakeLists.txt, not the value here, or `flutter run` will no longer # work. # # Any new source files that you add to the application should be added here. add_executable(${BINARY_NAME} WIN32 "flutter_window.cpp" "main.cpp" "utils.cpp" "win32_window.cpp" "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" "Runner.rc" "runner.exe.manifest" ) # Apply the standard set of build settings. This can be removed for applications # that need different build settings. apply_standard_settings(${BINARY_NAME}) # Add preprocessor definitions for the build version. target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION=\"${FLUTTER_VERSION}\"") target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MAJOR=${FLUTTER_VERSION_MAJOR}") target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MINOR=${FLUTTER_VERSION_MINOR}") target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_PATCH=${FLUTTER_VERSION_PATCH}") target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_BUILD=${FLUTTER_VERSION_BUILD}") # Disable Windows macros that collide with C++ standard library functions. target_compile_definitions(${BINARY_NAME} PRIVATE "NOMINMAX") # Add dependency libraries and include directories. Add any application-specific # dependencies here. target_link_libraries(${BINARY_NAME} PRIVATE flutter flutter_wrapper_app) target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}") # Run the Flutter tool portions of the build. This must not be removed. add_dependencies(${BINARY_NAME} flutter_assemble) ================================================ FILE: example/windows/runner/Runner.rc ================================================ // Microsoft Visual C++ generated resource script. // #pragma code_page(65001) #include "resource.h" #define APSTUDIO_READONLY_SYMBOLS ///////////////////////////////////////////////////////////////////////////// // // Generated from the TEXTINCLUDE 2 resource. // #include "winres.h" ///////////////////////////////////////////////////////////////////////////// #undef APSTUDIO_READONLY_SYMBOLS ///////////////////////////////////////////////////////////////////////////// // English (United States) resources #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US #ifdef APSTUDIO_INVOKED ///////////////////////////////////////////////////////////////////////////// // // TEXTINCLUDE // 1 TEXTINCLUDE BEGIN "resource.h\0" END 2 TEXTINCLUDE BEGIN "#include ""winres.h""\r\n" "\0" END 3 TEXTINCLUDE BEGIN "\r\n" "\0" END #endif // APSTUDIO_INVOKED ///////////////////////////////////////////////////////////////////////////// // // Icon // // Icon with lowest ID value placed first to ensure application icon // remains consistent on all systems. IDI_APP_ICON ICON "resources\\app_icon.ico" ///////////////////////////////////////////////////////////////////////////// // // Version // #if defined(FLUTTER_VERSION_MAJOR) && defined(FLUTTER_VERSION_MINOR) && defined(FLUTTER_VERSION_PATCH) && defined(FLUTTER_VERSION_BUILD) #define VERSION_AS_NUMBER FLUTTER_VERSION_MAJOR,FLUTTER_VERSION_MINOR,FLUTTER_VERSION_PATCH,FLUTTER_VERSION_BUILD #else #define VERSION_AS_NUMBER 1,0,0,0 #endif #if defined(FLUTTER_VERSION) #define VERSION_AS_STRING FLUTTER_VERSION #else #define VERSION_AS_STRING "1.0.0" #endif VS_VERSION_INFO VERSIONINFO FILEVERSION VERSION_AS_NUMBER PRODUCTVERSION VERSION_AS_NUMBER FILEFLAGSMASK VS_FFI_FILEFLAGSMASK #ifdef _DEBUG FILEFLAGS VS_FF_DEBUG #else FILEFLAGS 0x0L #endif FILEOS VOS__WINDOWS32 FILETYPE VFT_APP FILESUBTYPE 0x0L BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "040904e4" BEGIN VALUE "CompanyName", "com.example" "\0" VALUE "FileDescription", "flutter_opengl_example" "\0" VALUE "FileVersion", VERSION_AS_STRING "\0" VALUE "InternalName", "flutter_opengl_example" "\0" VALUE "LegalCopyright", "Copyright (C) 2022 com.example. All rights reserved." "\0" VALUE "OriginalFilename", "flutter_opengl_example.exe" "\0" VALUE "ProductName", "flutter_opengl_example" "\0" VALUE "ProductVersion", VERSION_AS_STRING "\0" END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x409, 1252 END END #endif // English (United States) resources ///////////////////////////////////////////////////////////////////////////// #ifndef APSTUDIO_INVOKED ///////////////////////////////////////////////////////////////////////////// // // Generated from the TEXTINCLUDE 3 resource. // ///////////////////////////////////////////////////////////////////////////// #endif // not APSTUDIO_INVOKED ================================================ FILE: example/windows/runner/flutter_window.cpp ================================================ #include "flutter_window.h" #include #include "flutter/generated_plugin_registrant.h" FlutterWindow::FlutterWindow(const flutter::DartProject& project) : project_(project) {} FlutterWindow::~FlutterWindow() {} bool FlutterWindow::OnCreate() { if (!Win32Window::OnCreate()) { return false; } RECT frame = GetClientArea(); // The size here must match the window dimensions to avoid unnecessary surface // creation / destruction in the startup path. flutter_controller_ = std::make_unique( frame.right - frame.left, frame.bottom - frame.top, project_); // Ensure that basic setup of the controller was successful. if (!flutter_controller_->engine() || !flutter_controller_->view()) { return false; } RegisterPlugins(flutter_controller_->engine()); SetChildContent(flutter_controller_->view()->GetNativeWindow()); return true; } void FlutterWindow::OnDestroy() { if (flutter_controller_) { flutter_controller_ = nullptr; } Win32Window::OnDestroy(); } LRESULT FlutterWindow::MessageHandler(HWND hwnd, UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept { // Give Flutter, including plugins, an opportunity to handle window messages. if (flutter_controller_) { std::optional result = flutter_controller_->HandleTopLevelWindowProc(hwnd, message, wparam, lparam); if (result) { return *result; } } switch (message) { case WM_FONTCHANGE: flutter_controller_->engine()->ReloadSystemFonts(); break; } return Win32Window::MessageHandler(hwnd, message, wparam, lparam); } ================================================ FILE: example/windows/runner/flutter_window.h ================================================ #ifndef RUNNER_FLUTTER_WINDOW_H_ #define RUNNER_FLUTTER_WINDOW_H_ #include #include #include #include "win32_window.h" // A window that does nothing but host a Flutter view. class FlutterWindow : public Win32Window { public: // Creates a new FlutterWindow hosting a Flutter view running |project|. explicit FlutterWindow(const flutter::DartProject& project); virtual ~FlutterWindow(); protected: // Win32Window: bool OnCreate() override; void OnDestroy() override; LRESULT MessageHandler(HWND window, UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept override; private: // The project to run. flutter::DartProject project_; // The Flutter instance hosted by this window. std::unique_ptr flutter_controller_; }; #endif // RUNNER_FLUTTER_WINDOW_H_ ================================================ FILE: example/windows/runner/main.cpp ================================================ #include #include #include #include "flutter_window.h" #include "utils.h" int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev, _In_ wchar_t *command_line, _In_ int show_command) { // Attach to console when present (e.g., 'flutter run') or create a // new console when running with a debugger. if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::IsDebuggerPresent()) { CreateAndAttachConsole(); } // Initialize COM, so that it is available for use in the library and/or // plugins. ::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED); flutter::DartProject project(L"data"); std::vector command_line_arguments = GetCommandLineArguments(); project.set_dart_entrypoint_arguments(std::move(command_line_arguments)); FlutterWindow window(project); Win32Window::Point origin(10, 10); Win32Window::Size size(500, 800); if (!window.CreateAndShow(L"flutter_opengl_example", origin, size)) { return EXIT_FAILURE; } window.SetQuitOnClose(true); ::MSG msg; while (::GetMessage(&msg, nullptr, 0, 0)) { ::TranslateMessage(&msg); ::DispatchMessage(&msg); } ::CoUninitialize(); return EXIT_SUCCESS; } ================================================ FILE: example/windows/runner/resource.h ================================================ //{{NO_DEPENDENCIES}} // Microsoft Visual C++ generated include file. // Used by Runner.rc // #define IDI_APP_ICON 101 // Next default values for new objects // #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS #define _APS_NEXT_RESOURCE_VALUE 102 #define _APS_NEXT_COMMAND_VALUE 40001 #define _APS_NEXT_CONTROL_VALUE 1001 #define _APS_NEXT_SYMED_VALUE 101 #endif #endif ================================================ FILE: example/windows/runner/runner.exe.manifest ================================================ PerMonitorV2 ================================================ FILE: example/windows/runner/utils.cpp ================================================ #include "utils.h" #include #include #include #include #include void CreateAndAttachConsole() { if (::AllocConsole()) { FILE *unused; if (freopen_s(&unused, "CONOUT$", "w", stdout)) { _dup2(_fileno(stdout), 1); } if (freopen_s(&unused, "CONOUT$", "w", stderr)) { _dup2(_fileno(stdout), 2); } std::ios::sync_with_stdio(); FlutterDesktopResyncOutputStreams(); } } std::vector GetCommandLineArguments() { // Convert the UTF-16 command line arguments to UTF-8 for the Engine to use. int argc; wchar_t** argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc); if (argv == nullptr) { return std::vector(); } std::vector command_line_arguments; // Skip the first argument as it's the binary name. for (int i = 1; i < argc; i++) { command_line_arguments.push_back(Utf8FromUtf16(argv[i])); } ::LocalFree(argv); return command_line_arguments; } std::string Utf8FromUtf16(const wchar_t* utf16_string) { if (utf16_string == nullptr) { return std::string(); } int target_length = ::WideCharToMultiByte( CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, -1, nullptr, 0, nullptr, nullptr); std::string utf8_string; if (target_length == 0 || target_length > utf8_string.max_size()) { return utf8_string; } utf8_string.resize(target_length); int converted_length = ::WideCharToMultiByte( CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, -1, utf8_string.data(), target_length, nullptr, nullptr); if (converted_length == 0) { return std::string(); } return utf8_string; } ================================================ FILE: example/windows/runner/utils.h ================================================ #ifndef RUNNER_UTILS_H_ #define RUNNER_UTILS_H_ #include #include // Creates a console for the process, and redirects stdout and stderr to // it for both the runner and the Flutter library. void CreateAndAttachConsole(); // Takes a null-terminated wchar_t* encoded in UTF-16 and returns a std::string // encoded in UTF-8. Returns an empty std::string on failure. std::string Utf8FromUtf16(const wchar_t* utf16_string); // Gets the command line arguments passed in as a std::vector, // encoded in UTF-8. Returns an empty std::vector on failure. std::vector GetCommandLineArguments(); #endif // RUNNER_UTILS_H_ ================================================ FILE: example/windows/runner/win32_window.cpp ================================================ #include "win32_window.h" #include #include "resource.h" namespace { constexpr const wchar_t kWindowClassName[] = L"FLUTTER_RUNNER_WIN32_WINDOW"; // The number of Win32Window objects that currently exist. static int g_active_window_count = 0; using EnableNonClientDpiScaling = BOOL __stdcall(HWND hwnd); // Scale helper to convert logical scaler values to physical using passed in // scale factor int Scale(int source, double scale_factor) { return static_cast(source * scale_factor); } // Dynamically loads the |EnableNonClientDpiScaling| from the User32 module. // This API is only needed for PerMonitor V1 awareness mode. void EnableFullDpiSupportIfAvailable(HWND hwnd) { HMODULE user32_module = LoadLibraryA("User32.dll"); if (!user32_module) { return; } auto enable_non_client_dpi_scaling = reinterpret_cast( GetProcAddress(user32_module, "EnableNonClientDpiScaling")); if (enable_non_client_dpi_scaling != nullptr) { enable_non_client_dpi_scaling(hwnd); FreeLibrary(user32_module); } } } // namespace // Manages the Win32Window's window class registration. class WindowClassRegistrar { public: ~WindowClassRegistrar() = default; // Returns the singleton registar instance. static WindowClassRegistrar* GetInstance() { if (!instance_) { instance_ = new WindowClassRegistrar(); } return instance_; } // Returns the name of the window class, registering the class if it hasn't // previously been registered. const wchar_t* GetWindowClass(); // Unregisters the window class. Should only be called if there are no // instances of the window. void UnregisterWindowClass(); private: WindowClassRegistrar() = default; static WindowClassRegistrar* instance_; bool class_registered_ = false; }; WindowClassRegistrar* WindowClassRegistrar::instance_ = nullptr; const wchar_t* WindowClassRegistrar::GetWindowClass() { if (!class_registered_) { WNDCLASS window_class{}; window_class.hCursor = LoadCursor(nullptr, IDC_ARROW); window_class.lpszClassName = kWindowClassName; window_class.style = CS_HREDRAW | CS_VREDRAW; window_class.cbClsExtra = 0; window_class.cbWndExtra = 0; window_class.hInstance = GetModuleHandle(nullptr); window_class.hIcon = LoadIcon(window_class.hInstance, MAKEINTRESOURCE(IDI_APP_ICON)); window_class.hbrBackground = 0; window_class.lpszMenuName = nullptr; window_class.lpfnWndProc = Win32Window::WndProc; RegisterClass(&window_class); class_registered_ = true; } return kWindowClassName; } void WindowClassRegistrar::UnregisterWindowClass() { UnregisterClass(kWindowClassName, nullptr); class_registered_ = false; } Win32Window::Win32Window() { ++g_active_window_count; } Win32Window::~Win32Window() { --g_active_window_count; Destroy(); } bool Win32Window::CreateAndShow(const std::wstring& title, const Point& origin, const Size& size) { Destroy(); const wchar_t* window_class = WindowClassRegistrar::GetInstance()->GetWindowClass(); const POINT target_point = {static_cast(origin.x), static_cast(origin.y)}; HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTONEAREST); UINT dpi = FlutterDesktopGetDpiForMonitor(monitor); double scale_factor = dpi / 96.0; HWND window = CreateWindow( window_class, title.c_str(), WS_OVERLAPPEDWINDOW | WS_VISIBLE, Scale(origin.x, scale_factor), Scale(origin.y, scale_factor), Scale(size.width, scale_factor), Scale(size.height, scale_factor), nullptr, nullptr, GetModuleHandle(nullptr), this); if (!window) { return false; } return OnCreate(); } // static LRESULT CALLBACK Win32Window::WndProc(HWND const window, UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept { if (message == WM_NCCREATE) { auto window_struct = reinterpret_cast(lparam); SetWindowLongPtr(window, GWLP_USERDATA, reinterpret_cast(window_struct->lpCreateParams)); auto that = static_cast(window_struct->lpCreateParams); EnableFullDpiSupportIfAvailable(window); that->window_handle_ = window; } else if (Win32Window* that = GetThisFromHandle(window)) { return that->MessageHandler(window, message, wparam, lparam); } return DefWindowProc(window, message, wparam, lparam); } LRESULT Win32Window::MessageHandler(HWND hwnd, UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept { switch (message) { case WM_DESTROY: window_handle_ = nullptr; Destroy(); if (quit_on_close_) { PostQuitMessage(0); } return 0; case WM_DPICHANGED: { auto newRectSize = reinterpret_cast(lparam); LONG newWidth = newRectSize->right - newRectSize->left; LONG newHeight = newRectSize->bottom - newRectSize->top; SetWindowPos(hwnd, nullptr, newRectSize->left, newRectSize->top, newWidth, newHeight, SWP_NOZORDER | SWP_NOACTIVATE); return 0; } case WM_SIZE: { RECT rect = GetClientArea(); if (child_content_ != nullptr) { // Size and position the child window. MoveWindow(child_content_, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, TRUE); } return 0; } case WM_ACTIVATE: if (child_content_ != nullptr) { SetFocus(child_content_); } return 0; } return DefWindowProc(window_handle_, message, wparam, lparam); } void Win32Window::Destroy() { OnDestroy(); if (window_handle_) { DestroyWindow(window_handle_); window_handle_ = nullptr; } if (g_active_window_count == 0) { WindowClassRegistrar::GetInstance()->UnregisterWindowClass(); } } Win32Window* Win32Window::GetThisFromHandle(HWND const window) noexcept { return reinterpret_cast( GetWindowLongPtr(window, GWLP_USERDATA)); } void Win32Window::SetChildContent(HWND content) { child_content_ = content; SetParent(content, window_handle_); RECT frame = GetClientArea(); MoveWindow(content, frame.left, frame.top, frame.right - frame.left, frame.bottom - frame.top, true); SetFocus(child_content_); } RECT Win32Window::GetClientArea() { RECT frame; GetClientRect(window_handle_, &frame); return frame; } HWND Win32Window::GetHandle() { return window_handle_; } void Win32Window::SetQuitOnClose(bool quit_on_close) { quit_on_close_ = quit_on_close; } bool Win32Window::OnCreate() { // No-op; provided for subclasses. return true; } void Win32Window::OnDestroy() { // No-op; provided for subclasses. } ================================================ FILE: example/windows/runner/win32_window.h ================================================ #ifndef RUNNER_WIN32_WINDOW_H_ #define RUNNER_WIN32_WINDOW_H_ #include #include #include #include // A class abstraction for a high DPI-aware Win32 Window. Intended to be // inherited from by classes that wish to specialize with custom // rendering and input handling class Win32Window { public: struct Point { unsigned int x; unsigned int y; Point(unsigned int x, unsigned int y) : x(x), y(y) {} }; struct Size { unsigned int width; unsigned int height; Size(unsigned int width, unsigned int height) : width(width), height(height) {} }; Win32Window(); virtual ~Win32Window(); // Creates and shows a win32 window with |title| and position and size using // |origin| and |size|. New windows are created on the default monitor. Window // sizes are specified to the OS in physical pixels, hence to ensure a // consistent size to will treat the width height passed in to this function // as logical pixels and scale to appropriate for the default monitor. Returns // true if the window was created successfully. bool CreateAndShow(const std::wstring& title, const Point& origin, const Size& size); // Release OS resources associated with window. void Destroy(); // Inserts |content| into the window tree. void SetChildContent(HWND content); // Returns the backing Window handle to enable clients to set icon and other // window properties. Returns nullptr if the window has been destroyed. HWND GetHandle(); // If true, closing this window will quit the application. void SetQuitOnClose(bool quit_on_close); // Return a RECT representing the bounds of the current client area. RECT GetClientArea(); protected: // Processes and route salient window messages for mouse handling, // size change and DPI. Delegates handling of these to member overloads that // inheriting classes can handle. virtual LRESULT MessageHandler(HWND window, UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept; // Called when CreateAndShow is called, allowing subclass window-related // setup. Subclasses should return false if setup fails. virtual bool OnCreate(); // Called when Destroy is called. virtual void OnDestroy(); private: friend class WindowClassRegistrar; // OS callback called by message pump. Handles the WM_NCCREATE message which // is passed when the non-client area is being created and enables automatic // non-client DPI scaling so that the non-client area automatically // responsponds to changes in DPI. All other messages are handled by // MessageHandler. static LRESULT CALLBACK WndProc(HWND const window, UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept; // Retrieves a class instance pointer for |window| static Win32Window* GetThisFromHandle(HWND const window) noexcept; bool quit_on_close_ = false; // window handle for top level window. HWND window_handle_ = nullptr; // window handle for hosted content. HWND child_content_ = nullptr; }; #endif // RUNNER_WIN32_WINDOW_H_ ================================================ FILE: lib/flutter_opengl.dart ================================================ library star_menu; export 'src/flutter_opengl.dart'; export 'src/flutter_opengl_ffi.dart'; export 'src/flutter_opengl_method_channel.dart'; export 'src/flutter_opengl_platform_interface.dart'; export 'src/ogl_utils.dart'; export 'src/opengl_controller.dart'; export 'src/opengl_texture.dart'; ================================================ FILE: lib/src/flutter_opengl.dart ================================================ import 'flutter_opengl_platform_interface.dart'; class FlutterOpengl { /// This function needs to call native to prepare the texture /// All the other methods use FFI Future createSurface(int width, int height) { return FlutterOpenglPlatform.instance.createSurface(width, height); } } ================================================ FILE: lib/src/flutter_opengl_ffi.dart ================================================ import 'dart:ffi' as ffi; import 'dart:typed_data'; import 'package:ffi/ffi.dart'; import 'package:flutter/material.dart'; enum PointerEventType { onPointerDown, onPointerMove, onPointerUp, } enum UniformType { uniformBool, uniformInt, uniformFloat, uniformVec2, uniformVec3, uniformVec4, uniformMat2, uniformMat3, uniformMat4, uniformSampler2D, } /// FFI bindings to Flutter_OpenGL class FlutterOpenGLFfi { /// Holds the symbol lookup function. final ffi.Pointer Function(String symbolName) _lookup; /// The symbols are looked up in [dynamicLibrary]. FlutterOpenGLFfi(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup; /// The symbols are looked up with [lookup]. FlutterOpenGLFfi.fromLookup( ffi.Pointer Function(String symbolName) lookup) : _lookup = lookup; /// *********************************************** /// **** GET RENDERER STATUS /// Returns true if the texture has been created successfully bool rendererStatus() { return _rendererStatus() == 0 ? false : true; } late final _rendererStatusPtr = _lookup>('rendererStatus'); late final _rendererStatus = _rendererStatusPtr.asFunction(); /// *********************************************** /// **** GET TEXTURE SIZE /// Get the size of the current texture. /// If not set it returns Size(-1, -1) Size getTextureSize() { ffi.Pointer w = calloc(ffi.sizeOf()); ffi.Pointer h = calloc(ffi.sizeOf()); _textureSize(w, h); Size size = Size(w.value.toDouble(), h.value.toDouble()); calloc.free(w); calloc.free(h); return size; } late final _textureSizePtr = _lookup< ffi.NativeFunction< ffi.Int Function(ffi.Pointer, ffi.Pointer)>>('getTextureSize'); late final _textureSize = _textureSizePtr.asFunction< int Function(ffi.Pointer, ffi.Pointer)>(); /// *********************************************** /// **** START THREAD /// Starts the drawing thread loop. It does nothing it's already running void startThread() { return _startThread(); } late final _startThreadPtr = _lookup>('startThread'); late final _startThread = _startThreadPtr.asFunction(); /// *********************************************** /// **** STOP THREAD /// Delete shader, delete texture and stops the drawing thread loop void stopThread() { return _stopThread(); } late final _stopThreadPtr = _lookup>('stopThread'); late final _stopThread = _stopThreadPtr.asFunction(); /// *********************************************** /// **** SET SHADER /// Set the shader to be used in the current texture. /// /// [isContinuous] not used yet /// [vertexShader] String of the vertex shader source /// [fragmentShader] String of the fragment shader source /// /// returns the compiling shader error string or an empty string if no errors. String setShader( bool isContinuous, String vertexShader, String fragmentShader, ) { ffi.Pointer err = _setShader( isContinuous ? 1 : 0, vertexShader.toNativeUtf8().cast(), fragmentShader.toNativeUtf8().cast(), ); String ret = err.cast().toDartString(); return ret; } late final _setShaderPtr = _lookup< ffi.NativeFunction< ffi.Pointer Function(ffi.Int, ffi.Pointer, ffi.Pointer)>>('setShader'); late final _setShader = _setShaderPtr.asFunction< ffi.Pointer Function( int, ffi.Pointer, ffi.Pointer)>(); /// *********************************************** /// **** SET SHADERTOY SHADER /// Set the shader to be used in the current texture. /// These are only fragment shaders taken from ShaderToy.com /// Many of the shaders can be copy/pasted, but they must have /// only the "image" layer (ie no buffer). /// Also many of them could be heavy for mobile devices (few FPS). /// The uniforms actually available and automatically registered are: /// float iTime /// vec4 iMouse /// vec3 iResolution /// Sampler2D iChannel[0-3] String setShaderToy(String fragmentShader) { return _setShaderToy( fragmentShader.toNativeUtf8().cast(), ).cast().toDartString(); } late final _setShaderToyPtr = _lookup< ffi.NativeFunction< ffi.Pointer Function( ffi.Pointer)>>('setShaderToy'); late final _setShaderToy = _setShaderToyPtr .asFunction Function(ffi.Pointer)>(); /// *********************************************** /// **** GET VERTEX SHADER /// Get current vertex shader text String getVertexShader() { ffi.Pointer vs = _getVertexShader(); return vs.cast().toDartString(); } late final _getVertexShaderPtr = _lookup Function()>>( 'getVertexShader'); late final _getVertexShader = _getVertexShaderPtr.asFunction Function()>(); /// *********************************************** /// **** GET FRAGMENT SHADER /// Get current fragment shader text String getFragmentShader() { ffi.Pointer fs = _getFragmentShader(); return fs.cast().toDartString(); } late final _getFragmentShaderPtr = _lookup Function()>>( 'getFragmentShader'); late final _getFragmentShader = _getFragmentShaderPtr.asFunction Function()>(); /// *********************************************** /// **** ADD SHADERTORY UNIFORMS /// this will add /// vec4 iMouse /// vec3 iResolution /// float iTime /// Sampler2D iChannel[0-3] /// These are automatically set when using [setShaderToy] void addShaderToyUniforms() { return _addShaderToyUniforms(); } late final _addShaderToyUniformsPtr = _lookup>('addShaderToyUniforms'); late final _addShaderToyUniforms = _addShaderToyUniformsPtr.asFunction(); /// *********************************************** /// **** SET MOUSE POS /// Set the iMouse uniform /// Shows how to use the mouse input (only left button supported): /// /// mouse.xy = mouse position during last button down /// abs(mouse.zw) = mouse position during last button click /// sign(mouze.z) = button is down /// sign(mouze.w) = button is clicked /// /// This is automatically processed by [OpenGLTexture] widget /// /// For reference: /// https://www.shadertoy.com/view/llySRh /// https://www.shadertoy.com/view/Mss3zH void setMousePosition( Offset startingPos, Offset pos, PointerEventType eventType, Size twSize, ) { return _setMousePosition( pos.dx, pos.dy, eventType == PointerEventType.onPointerDown || eventType == PointerEventType.onPointerMove ? startingPos.dx : -startingPos.dx, -startingPos.dy, twSize.width, twSize.height, ); } late final _setMousePositionPtr = _lookup< ffi.NativeFunction< ffi.Void Function(ffi.Double, ffi.Double, ffi.Double, ffi.Double, ffi.Double, ffi.Double)>>('setMousePosition'); late final _setMousePosition = _setMousePositionPtr.asFunction< void Function(double, double, double, double, double, double)>(); /// *********************************************** /// **** GET FPS /// Get current FPS (the algorithm seems correct, but what we see, is not! /// See Renderer::loop() ) double getFps() { return _getFps(); } late final _getFpsPtr = _lookup>('getFPS'); late final _getFps = _getFpsPtr.asFunction(); /// *********************************************** /// **** SET CLEAR COLOR (not used yet) void setClearColor( int clearR, int clearG, int clearB, int clearA, ) { return _nativeSurfaceSetClearColor( clearR, clearG, clearB, clearA, ); } late final _nativeSurfaceSetClearColorPtr = _lookup< ffi.NativeFunction< ffi.Void Function(ffi.Int32, ffi.Int32, ffi.Int32, ffi.Int32)>>('nativeSurfaceSetClearColor'); late final _nativeSurfaceSetClearColor = _nativeSurfaceSetClearColorPtr .asFunction(); /// *********************************************** /// *********************************************** /// *********************************************** /// *********************************************** /// **** ADD UNIFORMs /// * add BOOL bool addBoolUniform(String name, bool val) { ffi.Pointer valT = calloc(ffi.sizeOf()); valT.value = val; int ret = _addUniform( name.toNativeUtf8().cast(), UniformType.uniformBool.index, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * add INT bool addIntUniform(String name, int val) { ffi.Pointer valT = calloc(ffi.sizeOf()); valT.value = val; int ret = _addUniform( name.toNativeUtf8().cast(), UniformType.uniformInt.index, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * add FLOAT bool addFloatUniform(String name, double val) { ffi.Pointer valT = calloc(ffi.sizeOf()); valT.value = val; int ret = _addUniform( name.toNativeUtf8().cast(), UniformType.uniformFloat.index, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * add VEC2 bool addVec2Uniform(String name, List val) { assert( val.length == 2, "Assert error: vec2 has 2 doubles." "You have passed a list with ${val.length}"); ffi.Pointer valT = calloc(ffi.sizeOf() * 2); for (int i = 0; i < val.length; ++i) { valT[i] = val[i]; } int ret = _addUniform( name.toNativeUtf8().cast(), UniformType.uniformVec2.index, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * add VEC3 bool addVec3Uniform(String name, List val) { assert( val.length == 3, "Assert error: vec3 has 3 doubles." "You have passed a list with ${val.length}"); ffi.Pointer valT = calloc(ffi.sizeOf() * 3); for (int i = 0; i < val.length; ++i) { valT[i] = val[i]; } int ret = _addUniform( name.toNativeUtf8().cast(), UniformType.uniformVec3.index, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * add VEC4 bool addVec4Uniform(String name, List val) { assert( val.length == 4, "Assert error: vec4 has 4 doubles." "You have passed a list with ${val.length}"); ffi.Pointer valT = calloc(ffi.sizeOf() * 4); for (int i = 0; i < val.length; ++i) { valT[i] = val[i]; } int ret = _addUniform( name.toNativeUtf8().cast(), UniformType.uniformVec4.index, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * add MAT2 bool addMat2Uniform(String name, List val) { assert( val.length == 4, "Assert error: mat2 has 4 doubles." "You have passed a list with ${val.length}"); ffi.Pointer valT = calloc(ffi.sizeOf() * 4); for (int i = 0; i < val.length; ++i) { valT[i] = val[i]; } int ret = _addUniform( name.toNativeUtf8().cast(), UniformType.uniformMat2.index, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * add MAT3 bool addMat3Uniform(String name, List val) { assert( val.length == 9, "Assert error: mat3 has 9 doubles." "You have passed a list with ${val.length}"); ffi.Pointer valT = calloc(ffi.sizeOf() * 9); for (int i = 0; i < val.length; ++i) { valT[i] = val[i]; } int ret = _addUniform( name.toNativeUtf8().cast(), UniformType.uniformMat3.index, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * add MAT4 bool addMat4Uniform(String name, List val) { assert( val.length == 16, "Assert error: mat4 has 16 doubles." "You have passed a list with ${val.length}"); ffi.Pointer valT = calloc(ffi.sizeOf() * 16); for (int i = 0; i < val.length; ++i) { valT[i] = val[i]; } int ret = _addUniform( name.toNativeUtf8().cast(), UniformType.uniformMat3.index, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } late final _addUniformPtr = _lookup< ffi.NativeFunction< ffi.Int Function(ffi.Pointer, ffi.Int32, ffi.Pointer)>>('addUniform'); late final _addUniform = _addUniformPtr.asFunction< int Function(ffi.Pointer, int, ffi.Pointer)>(); /// *********************************************** /// **** REMOVE UNIFORM bool removeUniform(String name) { int ret = _removeUniform( name.toNativeUtf8().cast(), ); return ret == 0 ? false : true; } late final _removeUniformPtr = _lookup)>>( 'removeUniform'); late final _removeUniform = _removeUniformPtr.asFunction)>(); /// *********************************************** /// **** ADD SAMPLER2D UNIFORM /// /// * Add a Sampler2D uniform. The raw image stored in *val* must be in RGBA32 format. bool addSampler2DUniform( String name, int width, int height, Uint8List val, ) { assert( val.length == width * height * 4, "\nAssert error: RGBA32 raw image length mismatch." "\nYou have passed a Uint8list with ${val.length}" "\nIt should be $width x $height * 4 = ${width * height * 4}"); ffi.Pointer valT = calloc(ffi.sizeOf() * val.length); for (int i = 0; i < val.length; ++i) { valT[i] = val[i]; } int ret = _addSampler2DUniform( name.toNativeUtf8().cast(), width, height, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } late final _addSampler2DUniformPtr = _lookup< ffi.NativeFunction< ffi.Int Function(ffi.Pointer, ffi.Int32, ffi.Int32, ffi.Pointer)>>('addSampler2DUniform'); late final _addSampler2DUniform = _addSampler2DUniformPtr.asFunction< int Function(ffi.Pointer, int, int, ffi.Pointer)>(); /// *********************************************** /// **** REPLACE SAMPLER2D UNIFORM /// /// * replace Sampler2D uniform texture with another one with different size bool replaceSampler2DUniform( String name, int width, int height, Uint8List val, ) { assert( val.length == width * height * 4, "\nAssert error: RGBA32 raw image length mismatch." "\nYou have passed a Uint8list with ${val.length}" "\nIt should be $width x $height * 4 = ${width * height * 4}"); ffi.Pointer valT = calloc(ffi.sizeOf() * val.length); for (int i = 0; i < val.length; ++i) { valT[i] = val[i]; } int ret = _replaceSampler2DUniform( name.toNativeUtf8().cast(), width, height, valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } late final _replaceSampler2DUniformPtr = _lookup< ffi.NativeFunction< ffi.Int Function(ffi.Pointer, ffi.Int32, ffi.Int32, ffi.Pointer)>>('replaceSampler2DUniform'); late final _replaceSampler2DUniform = _replaceSampler2DUniformPtr.asFunction< int Function(ffi.Pointer, int, int, ffi.Pointer)>(); /// *********************************************** /// **** SET UNIFORMs /// * set BOOL bool setBoolUniform(String name, bool val) { ffi.Pointer valT = calloc(ffi.sizeOf()); valT.value = val; int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * set INT bool setIntUniform(String name, int val) { ffi.Pointer valT = calloc(ffi.sizeOf()); valT.value = val; int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * set FLOAT bool setFloatUniform(String name, double val) { ffi.Pointer valT = calloc(ffi.sizeOf()); valT.value = val; int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * set VEC2 bool setVec2Uniform(String name, List val) { ffi.Pointer valT = calloc(ffi.sizeOf() * 2); valT[0] = val[0]; valT[1] = val[1]; int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * set VEC3 bool setVec3Uniform(String name, List val) { ffi.Pointer valT = calloc(ffi.sizeOf() * 3); valT[0] = val[0]; valT[1] = val[1]; valT[2] = val[2]; int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * set VEC4 bool setVec4Uniform(String name, List val) { ffi.Pointer valT = calloc(ffi.sizeOf() * 4); valT[0] = val[0]; valT[1] = val[1]; valT[2] = val[2]; valT[3] = val[3]; int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * set MAT2 bool setMat2Uniform(String name, List val) { ffi.Pointer valT = calloc(ffi.sizeOf() * 4); valT[0] = val[0]; valT[1] = val[1]; valT[2] = val[2]; valT[3] = val[3]; int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * set MAT3 bool setMat3Uniform(String name, List val) { ffi.Pointer valT = calloc(ffi.sizeOf() * 9); valT[0] = val[0]; valT[1] = val[1]; valT[2] = val[2]; valT[3] = val[3]; valT[4] = val[4]; valT[5] = val[5]; valT[6] = val[6]; valT[7] = val[7]; valT[8] = val[8]; int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * set MAT4 bool setMat4Uniform(String name, List val) { ffi.Pointer valT = calloc(ffi.sizeOf() * 12); valT[0] = val[0]; valT[1] = val[1]; valT[2] = val[2]; valT[3] = val[3]; valT[4] = val[4]; valT[5] = val[5]; valT[6] = val[6]; valT[7] = val[7]; valT[8] = val[8]; valT[9] = val[9]; valT[10] = val[10]; valT[11] = val[11]; int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } /// * set SAMPLER2D /// /// Replace a texture with another image with the same size. /// Be sure the [val] length is the same as the previously /// stored image with the uniform named [name]. bool setSampler2DUniform(String name, Uint8List val) { ffi.Pointer valT = calloc(ffi.sizeOf() * val.length); for (int i = 0; i < val.length; ++i) { valT[i] = val[i]; } int ret = _setUniform( name.toNativeUtf8().cast(), valT.cast(), ); calloc.free(valT); return ret == 0 ? false : true; } late final _setUniformPtr = _lookup< ffi.NativeFunction< ffi.Int Function( ffi.Pointer, ffi.Pointer)>>('setUniform'); late final _setUniform = _setUniformPtr .asFunction, ffi.Pointer)>(); /// * Start capturing /// /// Set Sampler2D uniform [name] with frames captured by OpenCV VideoCapture /// /// [completeFilePath] can be: /// 'cam0' for webCam0 /// 'cam1' for webCam1 /// a complete local video file path bool startCaptureOnSampler2D(String name, String completeFilePath) { int ret = _startCapture( name.toNativeUtf8().cast(), completeFilePath.toNativeUtf8().cast(), ); return ret == 0 ? false : true; } late final _startCapturePtr = _lookup< ffi.NativeFunction< ffi.Int Function( ffi.Pointer, ffi.Pointer)>>('startCaptureOnSampler2D'); late final _startCapture = _startCapturePtr .asFunction, ffi.Pointer)>(); /// * Stop capturing /// bool stopCapture() { int ret = _stopCapture(); return ret == 0 ? false : true; } late final _stopCapturePtr = _lookup< ffi.NativeFunction< ffi.Int Function()>>('stopCapture'); late final _stopCapture = _stopCapturePtr .asFunction(); } ================================================ FILE: lib/src/flutter_opengl_method_channel.dart ================================================ import 'package:flutter/foundation.dart'; import 'package:flutter/services.dart'; import 'flutter_opengl_platform_interface.dart'; /// An implementation of [FlutterOpenglPlatform] that uses method channels. class MethodChannelFlutterOpengl extends FlutterOpenglPlatform { /// The method channel used to interact with the native platform. @visibleForTesting final methodChannel = const MethodChannel('flutter_opengl_plugin'); @override Future createSurface(int width, int height) async { int? textureId; try { textureId = await methodChannel.invokeMethod('createSurface', { 'width': width, 'height': height, }); } on PlatformException catch (e) { debugPrint(e.toString()); return -1; } return textureId ?? -1; } } ================================================ FILE: lib/src/flutter_opengl_platform_interface.dart ================================================ import 'package:plugin_platform_interface/plugin_platform_interface.dart'; import 'flutter_opengl_method_channel.dart'; abstract class FlutterOpenglPlatform extends PlatformInterface { /// Constructs a FlutterOpenglPlatform. FlutterOpenglPlatform() : super(token: _token); static final Object _token = Object(); static FlutterOpenglPlatform _instance = MethodChannelFlutterOpengl(); int textureId = -1; /// The default instance of [FlutterOpenglPlatform] to use. /// /// Defaults to [MethodChannelFlutterOpengl]. static FlutterOpenglPlatform get instance => _instance; /// Platform-specific implementations should set this with their own /// platform-specific class that extends [FlutterOpenglPlatform] when /// they register themselves. static set instance(FlutterOpenglPlatform instance) { PlatformInterface.verifyToken(instance, _token); _instance = instance; } Future createSurface(int width, int height) async { throw UnimplementedError('createSurface() has not been implemented.'); } } ================================================ FILE: lib/src/ogl_utils.dart ================================================ import 'dart:async'; import 'dart:ui' as ui; import 'package:flutter/material.dart'; import 'package:flutter/rendering.dart'; import 'package:flutter/services.dart'; import 'package:image/image.dart' as img; import 'package:image/image.dart'; import 'opengl_controller.dart'; /// class to store captured widget class CapturedWidget { ByteData byteData; // uncompressed 32bit RGBA image data Size size; CapturedWidget(this.byteData, this.size); } enum AddMethod { /// Add Sampler2D uniform if not already exists add, /// Replace Sampler2D uniform with another with different size replace, /// Set a new Sampler2D uniform with the same size set, } class OGLUtils { /// Capture raw RGBA32 data image static Future captureWidget(GlobalKey widgetKey) async { final RenderRepaintBoundary boundary = widgetKey.currentContext!.findRenderObject()! as RenderRepaintBoundary; final ui.Image image = await boundary.toImage(pixelRatio: 1.0); final ByteData? byteData = await image.toByteData(format: ui.ImageByteFormat.rawRgba); if (byteData == null) { return CapturedWidget(ByteData(0), Size.zero); } return CapturedWidget( byteData, Size(image.width.toDouble(), image.height.toDouble()), ); } /// Load an asset image, flip vertically and /// add it to the shader uniform with the name [uniformName] /// [toReplace] if true replace the texture with another /// one with different size. static Future setAssetTexture(String uniformName, String assetName, {AddMethod method = AddMethod.replace}) async { final Uint8List inputImg = (await rootBundle.load(assetName)).buffer.asUint8List(); final decoder = img.PngDecoder(); img.Image? decodedImg = decoder.decode(inputImg); img.Image rgba = decodedImg!.convert( format: Format.uint8, numChannels: 4, withPalette: false, ); // texture in OpenGL have the origin at top left, so flip it vertically rgba = img.flipVertical(rgba); final decodedBytes = rgba.getBytes(order: img.ChannelOrder.rgba); bool ret = false; switch (method) { case AddMethod.add: ret = OpenGLController().openglFFI.addSampler2DUniform( uniformName, rgba.width, rgba.height, decodedBytes); break; case AddMethod.replace: ret = OpenGLController().openglFFI.replaceSampler2DUniform( uniformName, rgba.width, rgba.height, decodedBytes); break; case AddMethod.set: ret = OpenGLController() .openglFFI .setSampler2DUniform(uniformName, decodedBytes); break; } return ret; } } ================================================ FILE: lib/src/opengl_controller.dart ================================================ import 'dart:ffi' as ffi; import 'dart:io'; import 'flutter_opengl.dart'; import 'flutter_opengl_ffi.dart'; /// Controller that expose method channel and FFI class OpenGLController { static OpenGLController? _instance; factory OpenGLController() => _instance ??= OpenGLController._(); OpenGLController._(); late ffi.DynamicLibrary nativeLib; late final FlutterOpengl openglPlugin; late final FlutterOpenGLFfi openglFFI; initializeGL() { nativeLib = Platform.isAndroid ? ffi.DynamicLibrary.open("libflutter_opengl_plugin.so") : (Platform.isWindows ? ffi.DynamicLibrary.open("flutter_opengl_plugin.dll") : ffi.DynamicLibrary.process()); openglFFI = FlutterOpenGLFfi.fromLookup(nativeLib.lookup); openglPlugin = FlutterOpengl(); } } ================================================ FILE: lib/src/opengl_texture.dart ================================================ import 'package:flutter/material.dart'; import 'package:flutter_opengl/src/opengl_controller.dart'; import 'flutter_opengl_ffi.dart'; /// A widget that contains the Texture widget. /// /// The size of this widget is not related to the texture size. /// It grabs also the mouse events to pass to the shader. /// /// First get the id calling [OpenGLController().flutterOpenglPlugin.createSurface] /// then feed this widget with id got: /// /// '''dart /// SizedBox( /// width: 400, /// height: 300, /// child: FutureBuilder( /// /// The surface size identifies the real texture size and /// /// it is not related to the above SizedBox size /// future: OpenGLController().openglPlugin.createSurface(300, 200), /// builder: (_, snapshot) { /// if (snapshot.hasError || !snapshot.hasData) { /// return const SizedBox.shrink(); /// } /// /// When the texture id is retrieved, it will be possible /// /// to start the renderer, set a shader and display it. /// /// /// Start renderer thread /// OpenGLController().openglFFI.startThread(); /// /// /// Set the fragment shader /// OpenGLController().openglFFI.setShaderToy(fShader); /// /// /// build the texture widget /// return OpenGLTexture(id: snapshot.data!); /// }, /// ), /// ) /// ''' class OpenGLTexture extends StatelessWidget { /// the texture id got by /// [OpenGLController().flutterOpenglPlugin.createSurface] final int id; const OpenGLTexture({ Key? key, required this.id, }) : super(key: key); @override Widget build(BuildContext context) { Size twSize = Size.zero; Offset startingPos = Offset.zero; var key = GlobalKey(); return Listener( onPointerDown: (event) { startingPos = event.localPosition; OpenGLController().openglFFI.setMousePosition( startingPos, event.localPosition, PointerEventType.onPointerDown, twSize, ); }, onPointerMove: (event) { OpenGLController().openglFFI.setMousePosition( startingPos, event.localPosition, PointerEventType.onPointerMove, twSize, ); }, onPointerUp: (event) { OpenGLController().openglFFI.setMousePosition( startingPos, event.localPosition, PointerEventType.onPointerUp, twSize, ); }, child: LayoutBuilder(builder: (_, __) { WidgetsBinding.instance.addPostFrameCallback((timeStamp) { final box = context.findRenderObject() as RenderBox; twSize = box.size; }); return ColoredBox( key: key, color: Colors.black, child: Texture(textureId: id), ); }), ); } } ================================================ FILE: linux/CMakeLists.txt ================================================ # The Flutter tooling requires that developers have CMake 3.10 or later # installed. You should not increase this version, as doing so will cause # the plugin to fail to compile for some customers of the plugin. cmake_minimum_required(VERSION 3.10) # Project-level configuration. set(PROJECT_NAME "flutter_opengl") project(${PROJECT_NAME} LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) # This value is used when generating builds using this plugin, so it must # not be changed. set(PLUGIN_NAME "flutter_opengl_plugin") # Define the plugin library target. Its name must not be changed (see comment # on PLUGIN_NAME above). # # Any new source files that you add to the plugin should be added here. add_library( ${PLUGIN_NAME} SHARED flutter_opengl_plugin.cc fl_my_texture_gl.cc # test.cpp ../src/common.h ../src/ffi.cpp ../src/Renderer.cpp ../src/Shader.cpp ../src/uniformQueue.cpp ../src/Sampler2D.cpp ../src/opencv_capture.cpp ) # Apply a standard set of build settings that are configured in the # application-level CMakeLists.txt. This can be removed for plugins that want # full control over build settings. # apply_standard_settings(${PLUGIN_NAME}) # Symbols are hidden by default to reduce the chance of accidental conflicts # between plugins. This should not be removed; any symbols that should be # exported should be explicitly exported with the FLUTTER_PLUGIN_EXPORT macro. set_target_properties(${PLUGIN_NAME} PROPERTIES CXX_VISIBILITY_PRESET hidden) target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL) # don't treat warnings as compile errors in this plugin. It will be removed target_compile_options(${PLUGIN_NAME} PRIVATE -Wall -Wno-error -v -v) # Source include directories and library dependencies. Add any plugin-specific # dependencies here. target_include_directories(${PLUGIN_NAME} INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/../src" "${CMAKE_CURRENT_SOURCE_DIR}/../src/shaders" ) target_link_libraries(${PLUGIN_NAME} PRIVATE flutter) target_link_libraries(${PLUGIN_NAME} PRIVATE PkgConfig::GTK) find_package(OpenGL REQUIRED COMPONENTS OpenGL EGL) find_package(OpenCV REQUIRED COMPONENTS core highgui # imgproc # imgcodecs ) include_directories( ${OpenCV_INCLUDE_DIRS} ) target_link_libraries(${PLUGIN_NAME} PRIVATE # OpenGL::OpenGL GLEW opencv_core opencv_highgui # opencv_imgproc # opencv_imgcodecs lapack cblas ) # List of absolute paths to libraries that should be bundled with the plugin. # This list could contain prebuilt libraries, or libraries created by an # external build triggered from this build file. set(flutter_opengl_bundled_libraries "" # PARENT_SCOPE ) message(STATUS "************* OpenCV_DIR = ${OpenCV_DIR}") message(STATUS "************* OpenCV_INCLUDE_DIRS = ${OpenCV_INCLUDE_DIRS}") message(STATUS "************* OpenCV_LIBS = ${OpenCV_LIBS}") # target_compile_definitions(${PLUGIN_NAME} PRIVATE -DWITH_OPENCV=TRUE ) # set(CMAKE_EXE_LINKER_FLAGS "-Xlinker -v -v") # target_compile_options(${PLUGIN_NAME} PRIVATE -v) #Available s are gles2, gles3, gles31, gles32, and gl. The default is gles32 # add_compile_options(-DDEQP_TARGET=default -DGLCTS_GTF_TARGET=gles2) # set(DEQP_GLES2_LIBRARIES ) # set(DEQP_GLES3_LIBRARIES ) # set(DEQP_GLES31_LIBRARIES ) # set(DEQP_GLES32_LIBRARIES ) # set(DEQP_EGL_LIBRARIES ) # set(DEQP_OPENGL_LIBRARIES ) ================================================ FILE: linux/fl_my_texture_gl.cc ================================================ #include "include/fl_my_texture_gl.h" // https://github.com/lattice0/external_texture_flutter_linux/tree/master/external_texture/linux #include G_DEFINE_TYPE(FlMyTextureGL, fl_my_texture_gl, fl_texture_gl_get_type()) static gboolean fl_my_texture_gl_populate(FlTextureGL *texture, uint32_t *target, uint32_t *name, uint32_t *width, uint32_t *height, GError **error) { // std::cout << "attention: populate called" << std::endl; FlMyTextureGL* f = (FlMyTextureGL*) texture; *target = f->target; *name = f->name; *width = f->width; *height = f->height; return true; } FlMyTextureGL *fl_my_texture_gl_new(uint32_t target, uint32_t name, uint32_t width, uint32_t height) { auto r = FL_MY_TEXTURE_GL(g_object_new(fl_my_texture_gl_get_type(), nullptr)); r->target = target; r->name = name; r->width = width; r->height = height; return r; } static void fl_my_texture_gl_class_init( FlMyTextureGLClass *klass) { FL_TEXTURE_GL_CLASS(klass)->populate = fl_my_texture_gl_populate; } static void fl_my_texture_gl_init(FlMyTextureGL *self) { } ================================================ FILE: linux/flutter_opengl_plugin.cc ================================================ #include "include/flutter_opengl/flutter_opengl_plugin.h" #include #include #include #include #include #include #include #include #include #include #include #include #include "include/fl_my_texture_gl.h" #include "../src/ffi.h" #include "../src/common.h" #include "include/test.h" G_DEFINE_TYPE(FlutterOpenglPlugin, flutter_opengl_plugin, g_object_get_type()) #define EGL_EGLEXT_PROTOTYPES // Called when a method call is received from Flutter. static void flutter_opengl_plugin_handle_method_call( FlutterOpenglPlugin *self, FlMethodCall *method_call) { g_autoptr(FlMethodResponse) response = nullptr; const gchar *method = fl_method_call_get_name(method_call); // Get Dart arguments FlValue *args = fl_method_call_get_args(method_call); /********************************************/ /*** CREATE SURFACE *************************/ /********************************************/ if (strcmp(method, "createSurface") == 0) { int width = 0; int height = 0; FlValue *w = fl_value_lookup_string(args, "width"); FlValue *h = fl_value_lookup_string(args, "height"); if (w != nullptr) width = fl_value_get_int(w); if (h != nullptr) height = fl_value_get_int(h); if (width == 0 || height == 0) { response = FL_METHOD_RESPONSE(fl_method_error_response_new( "100", "MethodCall createSurface() called without passing width and height parameters!", nullptr)); } else { if (self->context != nullptr && self->myTexture->width == width && self->myTexture->height == height) { // g_autoptr(FlValue) result = fl_value_new_int(-1); // response = FL_METHOD_RESPONSE(fl_method_success_response_new(result)); fl_texture_registrar_unregister_texture(self->texture_registrar, self->texture); if (getRenderer() != nullptr) stopThread(); } GdkWindow *window = nullptr; window = gtk_widget_get_parent_window(GTK_WIDGET(self->fl_view)); GError *error = NULL; self->context = gdk_window_create_gl_context(window, &error); gdk_gl_context_make_current(self->context); glGenTextures(1, &self->texture_name); glBindTexture(GL_TEXTURE_2D, self->texture_name); self->myTexture = fl_my_texture_gl_new(GL_TEXTURE_2D, self->texture_name, width, height); self->texture = FL_TEXTURE(self->myTexture); fl_texture_registrar_register_texture(self->texture_registrar, self->texture); fl_texture_registrar_mark_texture_frame_available(self->texture_registrar, self->texture); gdk_gl_context_clear_current(); ctx_f.context = self->context; ctx_f.texture_name = self->texture_name; ctx_f.texture_registrar = self->texture_registrar; ctx_f.myTexture = self->myTexture; ctx_f.texture = self->texture; ctx_f.width = width; ctx_f.height = height; createRenderer(&ctx_f); g_autoptr(FlValue) result = fl_value_new_int(reinterpret_cast(self->texture)); response = FL_METHOD_RESPONSE(fl_method_success_response_new(result)); } } // end createSurface else { response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new()); } fl_method_call_respond(method_call, response, nullptr); } static void flutter_opengl_plugin_dispose(GObject *object) { G_OBJECT_CLASS(flutter_opengl_plugin_parent_class)->dispose(object); } static void flutter_opengl_plugin_class_init(FlutterOpenglPluginClass *klass) { G_OBJECT_CLASS(klass)->dispose = flutter_opengl_plugin_dispose; } static void flutter_opengl_plugin_init(FlutterOpenglPlugin *self) {} static void method_call_cb(FlMethodChannel *channel, FlMethodCall *method_call, gpointer user_data) { FlutterOpenglPlugin *plugin = FLUTTER_OPENGL_PLUGIN(user_data); flutter_opengl_plugin_handle_method_call(plugin, method_call); } void flutter_opengl_plugin_register_with_registrar(FlPluginRegistrar *registrar) { FlutterOpenglPlugin *plugin = FLUTTER_OPENGL_PLUGIN( g_object_new(flutter_opengl_plugin_get_type(), nullptr)); FlView *fl_view = fl_plugin_registrar_get_view(registrar); plugin->fl_view = fl_view; plugin->texture_registrar = fl_plugin_registrar_get_texture_registrar(registrar); g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new(); g_autoptr(FlMethodChannel) channel = fl_method_channel_new(fl_plugin_registrar_get_messenger(registrar), "flutter_opengl_plugin", FL_METHOD_CODEC(codec)); fl_method_channel_set_method_call_handler( channel, method_call_cb, g_object_ref(plugin), g_object_unref); // Initialize GL glewExperimental = GL_TRUE; GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ std::cout << "Error: " << glewGetErrorString(err) << std::endl; return; } g_object_unref(plugin); } ================================================ FILE: linux/include/fl_my_texture_gl.h ================================================ #ifndef FLUTTER_MY_TEXTURE_H #define FLUTTER_MY_TEXTURE_H #include #include #include "flutter_opengl/flutter_opengl_plugin.h" #include G_DECLARE_FINAL_TYPE(FlMyTextureGL, fl_my_texture_gl, FL, MY_TEXTURE_GL, FlTextureGL) struct _FlMyTextureGL { FlTextureGL parent_instance; uint32_t target; uint32_t name; uint32_t width; uint32_t height; }; #define FLUTTER_OPENGL_PLUGIN(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj), flutter_opengl_plugin_get_type(), \ FlutterOpenglPlugin)) struct _FlutterOpenglPlugin { GObject parent_instance; GdkGLContext *context = nullptr; FlTextureRegistrar *texture_registrar = nullptr; FlMyTextureGL *myTexture = nullptr; unsigned int texture_name = 0; g_autoptr(FlTexture) texture; FlView *fl_view = nullptr; }; FlMyTextureGL *fl_my_texture_gl_new(uint32_t target, uint32_t name, uint32_t width, uint32_t height); #endif // FLUTTER_MY_TEXTURE_H ================================================ FILE: linux/include/flutter_opengl/flutter_opengl_plugin.h ================================================ #ifndef FLUTTER_PLUGIN_FLUTTER_OPENGL_PLUGIN_H_ #define FLUTTER_PLUGIN_FLUTTER_OPENGL_PLUGIN_H_ #include G_BEGIN_DECLS #ifdef FLUTTER_PLUGIN_IMPL #define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default"))) #else #define FLUTTER_PLUGIN_EXPORT #endif typedef struct _FlutterOpenglPlugin FlutterOpenglPlugin; typedef struct { GObjectClass parent_class; } FlutterOpenglPluginClass; FLUTTER_PLUGIN_EXPORT GType flutter_opengl_plugin_get_type(); FLUTTER_PLUGIN_EXPORT void flutter_opengl_plugin_register_with_registrar( FlPluginRegistrar* registrar); G_END_DECLS #endif // FLUTTER_PLUGIN_FLUTTER_OPENGL_PLUGIN_H_ ================================================ FILE: linux/include/test.h ================================================ #include "flutter_opengl/flutter_opengl_plugin.h" #include "fl_my_texture_gl.h" #include #include #include #include #include #include // #include // #include #include // #include // #include // // #define GLFW_INCLUDE_ES2 // // #include // // #include // #include // #include void drawFrame(FlutterOpenglPlugin *self); void main2(FlutterOpenglPlugin *self, int width, int height); // void main3(FlutterOpenglPlugin *self, int width, int height); void mainFBO(FlutterOpenglPlugin *self, int width, int height); void mainFBO2(FlutterOpenglPlugin *self, int width, int height); void mainFBO3(FlutterOpenglPlugin *self, int width, int height); void mainFBO4(FlutterOpenglPlugin *self, int width, int height); void mainFBO5(FlutterOpenglPlugin *self, int width, int height); void eglTest(EGLDisplay egl_display = 0); GLint common_get_shader_program(const char *vertex_shader_source, const char *fragment_shader_source); ================================================ FILE: linux/test.cpp ================================================ #include "include/test.h" #include "include/flutter_opengl/flutter_opengl_plugin.h" // #include // #include #include #include #include #include #include #include "include/fl_my_texture_gl.h" #include "../src/Shader.h" const char* nullSafe(const char* str) { return str ? str : "null"; } void eglTest(EGLDisplay egl_display) { std::cout << "*********************************START" << std::endl; std::cout << "OPENGL GL_VENDOR: " << glGetString(GL_VENDOR) << std::endl; std::cout << "OPENGL GL_RENDERER: " << glGetString(GL_RENDERER) << std::endl; std::cout << "OPENGL GL_VERSION: " << glGetString(GL_VERSION) << std::endl; std::cout << "EGL Vendor : " << nullSafe(eglQueryString(egl_display, EGL_VENDOR)) << std::endl; std::cout << "EGL Version : " << nullSafe(eglQueryString(egl_display, EGL_VERSION)) << std::endl; std::cout << "EGL ClientAPIs: " << nullSafe(eglQueryString(egl_display, EGL_CLIENT_APIS)) << std::endl; std::cout << "EGL Extensions: " << nullSafe(eglQueryString(egl_display, EGL_EXTENSIONS)) << std::endl; std::cout << "*********************************FINE" << std::endl; } static EGLDisplay egl_display; static EGLSurface egl_surface; static EGLContext egl_context; static const GLfloat vertices[] = { 0.0f, 0.5f, 0.0f, 0.5f, -0.5f, 0.0f, -0.5f, -0.5f, 0.0f, }; static GLfloat shaderVertices[] = { -1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 0.0f }; std::vector shaderVertices2 { -0.5f, 0.5f, 0.0f, -0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f, 0.5f, 0.5f, 0.0f }; const GLchar* vertex_shader000 = "#version 330 core\n" "layout (location = 0) in vec3 position;\n" "layout (location = 1) in vec3 color;\n" "out vec3 ourColor;\n" "void main()\n" "{\n" "gl_Position = vec4(position, 1.0);\n" "ourColor = color;\n" "}\0"; const GLchar* fragment_shader000 = "#version 330 core\n" "out vec4 color;\n" "uniform vec4 ourColor;\n" "void main()\n" "{\n" "color = ourColor;\n" "}\n\0"; static const GLchar* vertex_shader00 = "#version 330 core\n" "layout (location = 0) in vec3 aPos;\n" "void main(){\n" " gl_Position = vec4(aPos, 1.0);\n" "}\0"; static const GLchar* fragment_shader00 = "#version 330 core\n" "uniform float time;\n" "out vec4 color;\n" "void main() {\n" // " color=vec4(gl_Position.x, gl_Position.y, time/10.);\n" " color=vec4((1.0, 0.0, 1.0, 1.0);\n" "}\0"; static const GLchar* vertex_shader0 = "#version 330 core\n" "out vec2 tc;\n" "void main(){\n" " tc=vec2( (gl_VertexID & 1)<<1, (gl_VertexID & 2));\n" " gl_Position=vec4(tc*2.0-1.0,0,1);\n" "}\0"; static const GLchar* fragment_shader0 = "#version 330 core\n" "uniform sampler2D tex;\n" "uniform int useTex;\n" "uniform float time;\n" "in vec2 tc;\n" "out vec4 color;\n" "void main() {\n" " if (useTex>0) color=texture(tex,vec2(tc.x,tc.y+0.01*sin(gl_FragCoord.x*0.1)));\n" " else color=vec4(tc,0.0f,1.0f / time);\n" "}\0"; static const GLchar* vertex_shader1 = "#version 150\n" "attribute vec3 position;\n" "void main() {\n" "}\n\0"; static const GLchar* fragment_shader1 = "#version 150\n" "void main() {\n" " gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" "}\n\0"; static const GLchar* vertex_shader2 = "#version 330 core\n" "layout (location = 0) in vec2 aPos;\n" "layout (location = 1) in vec2 aTexCoords;\n" "out vec2 TexCoords;\n" "void main()\n" "{\n" " gl_Position = vec4(aPos.x, aPos.y, 0.0, 1.0);\n" " TexCoords = aTexCoords;\n" "}\n\0"; static const GLchar* fragment_shader2 = "#version 330 core\n" "out vec4 FragColor;\n" "in vec2 TexCoords;\n" "uniform sampler2D screenTexture;\n" "void main()\n" "{\n" " FragColor = texture(screenTexture, TexCoords);\n" "}\n\0"; static const GLchar* vertex_shader3 = "#version 150\n" "void main() \n" "{ \n" "} \n\0"; static const GLchar* fragment_shader3 = "#version 150\n" "precision mediump float; \n" "void main() \n" "{ \n" " gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); \n" "} \n\0"; // Supported versions are: 1.10, 1.20, 1.30, 1.40, 1.50, 3.30, 4.00, // 4.10, 4.20, 4.30, 4.40, 4.50, 4.60, 1.00 ES, 3.00 ES, 3.10 ES, and 3.20 ES static const GLchar* vertex_shader4 = "#version 330 core\n" "precision mediump float;\n" "precision mediump int;\n" "attribute vec4 a_Position; \n" // Per-vertex position information we will pass in. "uniform vec3 u_resolution; \n" "uniform float u_time; \n" "varying vec3 v_resolution; \n" // viewport resolution (in pixels) "varying float v_time; \n" "void main() \n" // The entry point for our vertex shader. "{ \n" " gl_Position = a_Position; \n" " v_resolution = u_resolution; \n" " v_time = u_time; \n" "} \n\0"; static const GLchar* fragment_shader4 = "#version 330 core\n" "precision mediump float;\n" "precision mediump int;\n" "mat2 rot(in float a){float c = cos(a), s = sin(a);return mat2(c,s,-s,c);}\n" "const mat3 m3 = mat3(0.33338, 0.56034, -0.71817, -0.87887, 0.32651, -0.15323, 0.15162, 0.69596, 0.61339)*1.93;\n" "float mag2(vec2 p){return dot(p,p);}\n" "float linstep(in float mn, in float mx, in float x){ return clamp((x - mn)/(mx - mn), 0., 1.); }\n" "float prm1 = 0.;\n" "vec2 bsMo = vec2(0);\n" "" "varying vec3 v_resolution; \n" // viewport resolution (in pixels) "varying float v_time; \n" // shader playback time (in seconds) "" "vec2 disp(float t){ return vec2(sin(t*0.22)*1., cos(t*0.175)*1.)*2.; }\n" "" "vec2 map(vec3 p)\n" "{\n" " vec3 p2 = p;\n" " p2.xy -= disp(p.z).xy;\n" " p.xy *= rot(sin(p.z+v_time)*(0.1 + prm1*0.05) + v_time*0.09);\n" " float cl = mag2(p2.xy);\n" " float d = 0.;\n" " p *= .61;\n" " float z = 1.;\n" " float trk = 1.;\n" " float dspAmp = 0.1 + prm1*0.2;\n" " for(int i = 0; i < 5; i++)\n" " {\n" " p += sin(p.zxy*0.75*trk + v_time*trk*.8)*dspAmp;\n" " d -= abs(dot(cos(p), sin(p.yzx))*z);\n" " z *= 0.57;\n" " trk *= 1.4;\n" " p = p*m3;\n" " }\n" " d = abs(d + prm1*3.)+ prm1*.3 - 2.5 + bsMo.y;\n" " return vec2(d + cl*.2 + 0.25, cl);\n" "}\n" "" "vec4 render( in vec3 ro, in vec3 rd, float time )\n" "{\n" " vec4 rez = vec4(0);\n" " const float ldst = 8.;\n" " vec3 lpos = vec3(disp(time + ldst)*0.5, time + ldst);\n" " float t = 1.5;\n" " float fogT = 0.;\n" " for(int i=0; i<130; i++)\n" " {\n" " if(rez.a > 0.99)break;\n" "" " vec3 pos = ro + t*rd;\n" " vec2 mpv = map(pos);\n" " float den = clamp(mpv.x-0.3,0.,1.)*1.12;\n" " float dn = clamp((mpv.x + 2.),0.,3.);\n" "" " vec4 col = vec4(0);\n" " if (mpv.x > 0.6)\n" " {\n" "" " col = vec4(sin(vec3(5.,0.4,0.2) + mpv.y*0.1 +sin(pos.z*0.4)*0.5 + 1.8)*0.5 + 0.5,0.08);\n" " col *= den*den*den;\n" " col.rgb *= linstep(4.,-2.5, mpv.x)*2.3;\n" " float dif = clamp((den - map(pos+.8).x)/9., 0.001, 1. );\n" " dif += clamp((den - map(pos+.35).x)/2.5, 0.001, 1. );\n" " col.xyz *= den*(vec3(0.005,.045,.075) + 1.5*vec3(0.033,0.07,0.03)*dif);\n" " }\n" "" " float fogC = exp(t*0.2 - 2.2);\n" " col.rgba += vec4(0.06,0.11,0.11, 0.1)*clamp(fogC-fogT, 0., 1.);\n" " fogT = fogC;\n" " rez = rez + col*(1. - rez.a);\n" " t += clamp(0.5 - dn*dn*.05, 0.09, 0.3);\n" " }\n" " return clamp(rez, 0.0, 1.0);\n" "}\n" "" "float getsat(vec3 c)\n" "{\n" " float mi = min(min(c.x, c.y), c.z);\n" " float ma = max(max(c.x, c.y), c.z);\n" " return (ma - mi)/(ma+ 1e-7);\n" "}\n" "\n" "vec3 iLerp(in vec3 a, in vec3 b, in float x)\n" "{\n" " vec3 ic = mix(a, b, x) + vec3(1e-6,0.,0.);\n" " float sd = abs(getsat(ic) - mix(getsat(a), getsat(b), x));\n" " vec3 dir = normalize(vec3(2.*ic.x - ic.y - ic.z, 2.*ic.y - ic.x - ic.z, 2.*ic.z - ic.y - ic.x));\n" " float lgt = dot(vec3(1.0), ic);\n" " float ff = dot(dir, normalize(ic));\n" " ic += 1.5*dir*sd*ff*lgt;\n" " return clamp(ic,0.,1.);\n" "}\n" "\n" "void main()\n" "{\n" " vec2 q = gl_FragCoord.xy/v_resolution.xy;\n" " vec2 p = (gl_FragCoord.xy - 0.5*v_resolution.xy)/v_resolution.y;\n" " bsMo = (0.5*v_resolution.xy)/v_resolution.y;\n" "" " float time = v_time*3.;\n" " vec3 ro = vec3(0,0,time);\n" "" " ro += vec3(sin(v_time)*0.5,sin(v_time*1.)*0.,0);\n" "" " float dspAmp = .85;\n" " ro.xy += disp(ro.z)*dspAmp;\n" " float tgtDst = 3.5;\n" "" " vec3 target = normalize(ro - vec3(disp(time + tgtDst)*dspAmp, time + tgtDst));\n" " ro.x -= bsMo.x*2.;\n" " vec3 rightdir = normalize(cross(target, vec3(0,1,0)));\n" " vec3 updir = normalize(cross(rightdir, target));\n" " rightdir = normalize(cross(updir, target));\n" " vec3 rd=normalize((p.x*rightdir + p.y*updir)*1. - target);\n" " rd.xy *= rot(-disp(time + 3.5).x*0.2 + bsMo.x);\n" " prm1 = smoothstep(-0.4, 0.4,sin(v_time*0.3));\n" " vec4 scn = render(ro, rd, time);\n" "" " vec3 col = scn.rgb;\n" " col = iLerp(col.bgr, col.rgb, clamp(1.-prm1,0.05,1.));\n" " \n" " col = pow(col, vec3(.55,0.65,0.6))*vec3(1.,.97,.9);\n" "" " col *= pow( 16.0*q.x*q.y*(1.0-q.x)*(1.0-q.y), 0.12)*0.7+0.3;\n" "" " gl_FragColor = vec4( col, 1.0 );\n" "}\0"; void drawFrame(FlutterOpenglPlugin *self) { // Load the vertex data glVertexAttribPointer ( 0, 3, GL_FLOAT, GL_FALSE, 0, shaderVertices ); glEnableVertexAttribArray ( 0 ); // glBindTexture(GL_TEXTURE_2D, self->texture_name); glDrawArrays(GL_TRIANGLES, 0, 6); } // http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture/ // https://cgit.freedesktop.org/mesa/demos/tree/src/egl/opengles2/es2tri.c // https://discourse.gnome.org/t/gtk-opengl-widget-drawing-result-broken-when-maximize-restore-window/4165 void main2(FlutterOpenglPlugin *self, int width, int height) { GtkWidget *widget = GTK_WIDGET(self->fl_view); // GdkDisplay *display = gtk_widget_get_display(widget); // int www = gtk_widget_get_allocated_width(widget); // int hhh = gtk_widget_get_allocated_height(widget); // Window xidApp = gdk_x11_window_get_xid(gtk_widget_get_window(widget)); // GtkAllocation allocation; // gtk_widget_get_allocation(widget, &allocation); // GdkWindowAttr window_attributes; // window_attributes.window_type = GDK_WINDOW_CHILD; // window_attributes.x = 100; //allocation.x; // window_attributes.y = 100; //allocation.y; // window_attributes.width = 200; //allocation.width; // window_attributes.height = 400; //allocation.height; // window_attributes.wclass = GDK_INPUT_OUTPUT; // window_attributes.event_mask = // gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK | // GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | // GDK_BUTTON_RELEASE_MASK | GDK_SCROLL_MASK | GDK_SMOOTH_SCROLL_MASK | // GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK; // gint window_attributes_mask = GDK_WA_X | GDK_WA_Y; // GdkWindow *viewWindow = // gdk_window_new(gtk_widget_get_window(widget), &window_attributes, // window_attributes_mask); // gtk_widget_register_window(widget, viewWindow); // gtk_widget_set_window(widget, viewWindow); // gdk_window_show(viewWindow); EGLNativeWindowType _window = gdk_x11_window_get_xid(gtk_widget_get_window(widget)); EGLint majorVersion, minorVersion; EGLConfig egl_config; EGLint n_config; EGLint attributes[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_BUFFER_SIZE, 16, EGL_DEPTH_SIZE, 16, EGL_STENCIL_SIZE, 0, EGL_BLUE_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_RED_SIZE, 8, EGL_NONE }; egl_display = eglGetDisplay((EGLNativeDisplayType)gdk_x11_display_get_xdisplay( gtk_widget_get_display(widget))); egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY); eglPrintError("eglGetDisplay()"); eglInitialize(egl_display, &majorVersion, &minorVersion); eglPrintError("eglInitialize()"); eglChooseConfig(egl_display, attributes, &egl_config, 1, &n_config); eglPrintError("eglChooseConfig()"); eglBindAPI(EGL_OPENGL_ES_API); eglPrintError("eglBindAPI()"); // egl_surface = eglCreateWindowSurface( // egl_display, egl_config, gdk_x11_window_get_xid(viewWindow), NULL); egl_surface = eglCreateWindowSurface( egl_display, egl_config, _window, NULL); eglPrintError("eglCreateWindowSurface()"); egl_context = eglCreateContext(egl_display, egl_config, EGL_NO_CONTEXT, 0); // egl_context = self->context; // eglPrintError("eglCreateContext()"); eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context); eglPrintError("eglMakeCurrent()"); int w = 0; int h = 0; eglQuerySurface(egl_display, egl_surface, EGL_WIDTH, &w); eglQuerySurface(egl_display, egl_surface, EGL_HEIGHT, &h); eglTest(egl_display); printf("********** QUERY: %d %d\n", w,h); // std::string vShader = // "#version 150\n" // "uniform mat4 modelviewProjection;" // "attribute vec4 pos;\n" // "attribute vec4 color;\n" // "varying vec4 v_color;\n" // "void main() {\n" // " gl_Position = modelviewProjection * pos;\n" // " v_color = color;\n" // "};\n"; // std::string fShader = // "#version 150\n" // "precision mediump float\n;" // "varying vec4 v_color;\n" // "void main() {\n" // " gl_FragColor = v_color;\n" // "};\n"; // Shader *shader = new Shader(width, height); // shader->setShadersText(vShader, fShader); // shader->initShader(); // drawFrame(self); // if (!eglSwapBuffers(egl_display, egl_surface)) { // eglPrintError("eglSwapBuffers()"); // } // fl_texture_registrar_mark_texture_frame_available(self->texture_registrar, // self->texture); // free(shader); GLuint shader_program, vbo; GLint pos; shader_program = common_get_shader_program(vertex_shader1, fragment_shader1); pos = glGetAttribLocation(shader_program, "position"); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glViewport(0, 0, w, h); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glVertexAttribPointer(pos, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0); glEnableVertexAttribArray(pos); glBindBuffer(GL_ARRAY_BUFFER, 0); glClear(GL_COLOR_BUFFER_BIT); glUseProgram(shader_program); glDrawArrays(GL_TRIANGLES, 0, 3); eglSwapBuffers(egl_display, egl_surface); eglPrintError("eglSwapBuffers()"); } /**************************************************/ /**************************************************/ /**************************************************/ /**************************************************/ /**************************************************/ /**************************************************/ static const GLuint WIDTH = 800; static const GLuint HEIGHT = 600; GLint common_get_shader_program(const char *vertex_shader_source, const char *fragment_shader_source) { enum Consts {INFOLOG_LEN = 512}; GLchar infoLog[INFOLOG_LEN]; GLint fragment_shader; GLint shader_program; GLint success; GLint vertex_shader; /* Vertex shader */ vertex_shader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL); glCompileShader(vertex_shader); glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(vertex_shader, INFOLOG_LEN, NULL, infoLog); printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog); } /* Fragment shader */ fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL); glCompileShader(fragment_shader); glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(fragment_shader, INFOLOG_LEN, NULL, infoLog); printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog); } /* Link shaders */ shader_program = glCreateProgram(); glAttachShader(shader_program, vertex_shader); glAttachShader(shader_program, fragment_shader); glLinkProgram(shader_program); glGetProgramiv(shader_program, GL_LINK_STATUS, &success); if (!success) { glGetProgramInfoLog(shader_program, INFOLOG_LEN, NULL, infoLog); printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog); } glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); return shader_program; } // GLFW // void main3(FlutterOpenglPlugin *self, int width, int height) { // GLuint shader_program, vbo; // GLint pos; // GLFWwindow* window; // glfwInit(); // glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API); // glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2); // window = glfwCreateWindow(WIDTH, HEIGHT, __FILE__, NULL, NULL); // // https://www.glfw.org/docs/3.3/group__native.html // // glfwGetX11Window() // glfwMakeContextCurrent(window); // printf("GL_VERSION : %s\n", glGetString(GL_VERSION) ); // printf("GL_RENDERER : %s\n", glGetString(GL_RENDERER) ); // shader_program = common_get_shader_program(vertex_shader2, fragment_shader2); // pos = glGetAttribLocation(shader_program, "position"); // glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // glViewport(0, 0, WIDTH, HEIGHT); // glGenBuffers(1, &vbo); // glBindBuffer(GL_ARRAY_BUFFER, vbo); // glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); // glVertexAttribPointer(pos, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0); // glEnableVertexAttribArray(pos); // glBindBuffer(GL_ARRAY_BUFFER, 0); // while (!glfwWindowShouldClose(window)) { // glfwPollEvents(); // glClear(GL_COLOR_BUFFER_BIT); // glUseProgram(shader_program); // glDrawArrays(GL_TRIANGLES, 0, 3); // glfwSwapBuffers(window); // } // glDeleteBuffers(1, &vbo); // glfwTerminate(); // } /**************************************************/ /**************************************************/ /**************************************************/ /**************************************************/ /**************************************************/ /**************************************************/ GLuint createRenderTarget(uint16_t const width, uint16_t const height) { GLuint frameBuffer = 0; glGenFramebuffers(1, &frameBuffer); glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); // Color buffer GLuint colorBuffer = 0; glGenRenderbuffers(1, &colorBuffer); glBindRenderbuffer(GL_RENDERBUFFER, colorBuffer); glRenderbufferStorage(GL_RENDERBUFFER, GL_RGB, width, height); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorBuffer); // Depth buffer GLuint depthrenderbuffer; glGenRenderbuffers(1, &depthrenderbuffer); glBindRenderbuffer(GL_RENDERBUFFER, depthrenderbuffer); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthrenderbuffer); GLuint test = glCheckFramebufferStatus(GL_FRAMEBUFFER); if ( test != GL_FRAMEBUFFER_COMPLETE ) { std::cout << "OpenGL Failed to create multi-sampled render target" << std::endl; return 0; } return frameBuffer; } GLuint createRenderTargetTexture(FlutterOpenglPlugin *self, uint16_t const width, uint16_t const height) { GLuint frameBuffer = 0; glGenFramebuffers(1, &frameBuffer); glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); // The texture we're going to render to // GLuint renderedTexture; // glGenTextures(1, &renderedTexture); // "Bind" the newly created texture : all future texture functions will modify this texture glBindTexture(GL_TEXTURE_2D, self->texture_name/*renderedTexture*/); // Give an empty image to OpenGL ( the last "0" ) glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); // Poor filtering. Needed ! glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // The depth buffer GLuint depthrenderbuffer; glGenRenderbuffers(1, &depthrenderbuffer); glBindRenderbuffer(GL_RENDERBUFFER, depthrenderbuffer); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthrenderbuffer); // Set "renderedTexture" as our colour attachement #0 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->texture_name/*renderedTexture*/, 0); // Set the list of draw buffers. GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0}; glDrawBuffers(1, DrawBuffers); // "1" is the size of DrawBuffers GLuint test = glCheckFramebufferStatus(GL_FRAMEBUFFER); if ( test != GL_FRAMEBUFFER_COMPLETE ) { std::cout << "OpenGL Failed to create render target" << std::endl; return 0; } return frameBuffer; } static void cs(GLuint p, GLenum type, const char *src) { GLuint sh=glCreateShader(type); glShaderSource(sh, 1, (const GLchar**)&src, NULL); glCompileShader(sh); glAttachShader(p, sh); } // https://github.com/derhass/miscstuff/blob/2b06b6b39ba77b82488a8c803784d60cedc8dc49/OpenGL/code/HelloFBO_minimal.c void mainFBO3(FlutterOpenglPlugin *self, int width, int height) { gdk_gl_context_make_current(self->context); GLuint vs, p, vao, tex, fbo, lUseTex; p=glCreateProgram(); cs(p,GL_VERTEX_SHADER,vertex_shader0); cs(p,GL_FRAGMENT_SHADER,fragment_shader0); glLinkProgram(p); glUseProgram(p); lUseTex=glGetUniformLocation(p,"useTex"); glGenVertexArrays(1,&vao); glBindVertexArray(vao); // glGenTextures(1,&self->texture_name); glBindTexture(GL_TEXTURE_2D, self->texture_name); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glGenFramebuffers(1,&fbo); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, self->texture_name, 0); // while (!glfwWindowShouldClose(win)) { // int w,h; glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); glViewport(0,0,width, height); glClear(GL_COLOR_BUFFER_BIT); glUniform1i(lUseTex,0); glDrawArrays(GL_TRIANGLES, 0, 3); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); // glfwGetFramebufferSize(win,&w,&h); glViewport(0,0,width, height); glUniform1i(lUseTex,1); glDrawArrays(GL_TRIANGLES, 0, 3); // glfwSwapBuffers(win); // glfwPollEvents(); // } fl_texture_registrar_mark_texture_frame_available(self->texture_registrar, self->texture); gdk_gl_context_clear_current(); } void mainFBO4(FlutterOpenglPlugin *self, int width, int height) { Shader *shader = new Shader(width, height); shader->setShadersText(vertex_shader4, fragment_shader4); shader->initShader(self); std::thread gl_thread([](FlutterOpenglPlugin *self, Shader *shader, int width, int height) { GLfloat startTime = (GLfloat) clock() / (GLfloat) CLOCKS_PER_SEC; while(1) { gdk_gl_context_make_current(self->context); // If you want to use a clockwise definition, you can simply call // glFrontFace(GL_CW); GLuint VBO, VAO; glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s). glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(shaderVertices), shaderVertices, GL_STATIC_DRAW); // Position attribute // glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0); // glEnableVertexAttribArray(0); glVertexAttribPointer ( 0, 3, GL_FLOAT, GL_FALSE, 0, shaderVertices ); glEnableVertexAttribArray ( 0 ); glBindVertexArray(0); // Unbind VAO GLuint fbo; glBindTexture(GL_TEXTURE_2D, self->texture_name); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glGenFramebuffers(1,&fbo); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, self->texture_name, 0); GLfloat time = (GLfloat) clock() / (GLfloat) CLOCKS_PER_SEC - startTime; // printf("%f\n", time); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); glViewport(0,0,width, height); glClearColor(.2f,.3f,.3f,1.f); glClear(GL_COLOR_BUFFER_BIT); shader->use(); glUniform1f(glGetUniformLocation(shader->getProgramObject(), "u_time"), time); glUniform3f(glGetUniformLocation(shader->getProgramObject(), "u_resolution"), (GLfloat)width, (GLfloat)height, 0.0f); glBindVertexArray(VAO); glDrawArrays(GL_TRIANGLES, 0, 6); glBindVertexArray(0); fl_texture_registrar_mark_texture_frame_available(self->texture_registrar, self->texture); gdk_gl_context_clear_current(); } }, self, shader, width, height ); gl_thread.detach(); } void mainFBO5(FlutterOpenglPlugin *self, int width, int height) { std::thread gl_thread([](FlutterOpenglPlugin *self, int width, int height) { gdk_gl_context_make_current(self->context); Shader *shader = new Shader(width, height); shader->setShadersText(vertex_shader4, fragment_shader4); shader->initShader(self); gdk_gl_context_clear_current(); while (1) { shader->drawFrame(self); } }, self, width, height ); gl_thread.detach(); } // https://metashapes.com/blog/opengl-frame-buffer-objects-blitting-multi-sampling/ void mainFBO2(FlutterOpenglPlugin *self, int width, int height) { gdk_gl_context_make_current(self->context); GLuint framebuffer = createRenderTarget(width, height); GLuint renderbuffer = createRenderTargetTexture(self, width, height); // GLuint shader_program = common_get_shader_program(vertex_shader2, fragment_shader2); Shader *shader = new Shader(width, height); shader->setShadersText(vertex_shader4, fragment_shader4); shader->initShader(self); glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); shader->use(); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // draw your scene here... drawFrame(self); glBindFramebuffer(GL_FRAMEBUFFER, 0); // unbind your FBO to set the default framebuffer glClearColor(0.0f, 0.7f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shader->use(); // shader program for rendering the quad // glUseProgram(shader_program); eglPrintError("glUseProgram()"); glBindTexture(GL_TEXTURE_2D, self->texture_name); // color attachment texture GLuint vbo; GLint pos; glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glViewport(0, 0, width, height); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(shaderVertices), shaderVertices, GL_STATIC_DRAW); glVertexAttribPointer(pos, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0); glEnableVertexAttribArray(pos); glBindBuffer(GL_ARRAY_BUFFER, 0); // You can also use VAO or attribute pointers instead of only VBO... glDrawArrays(GL_TRIANGLES, 0, 6); glBindBuffer(GL_ARRAY_BUFFER, 0); fl_texture_registrar_mark_texture_frame_available(self->texture_registrar, self->texture); gdk_gl_context_clear_current(); } // https://learnopengl.com/Advanced-OpenGL/Framebuffers @Rendering to a texture void mainFBO(FlutterOpenglPlugin *self, int width, int height) { gdk_gl_context_make_current(self->context); GLuint framebuffer; // Creating a framebuffer glGenFramebuffers(1, &framebuffer); eglPrintError("glGenFramebuffers()"); glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); eglPrintError("glBindFramebuffer()"); if (!glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) { std::cout << "Error creating framebuffer!" << std::endl; return; } // texture is already created in "createSurface" // glGenTextures(1, &self->texture_name); glBindTexture(GL_TEXTURE_2D, self->texture_name); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glBindTexture(GL_TEXTURE_2D, 0); glViewport(0, 0, width, height); // attach texture to the framebuffer glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->texture_name, 0); // Creating a renderbuffer object unsigned int rbo; glGenRenderbuffers(1, &rbo ); eglPrintError("glGenRenderbuffers()"); glBindRenderbuffer(GL_RENDERBUFFER, rbo); eglPrintError("glBindRenderbuffer()"); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height); eglPrintError("glRenderbufferStorage()"); glBindRenderbuffer(GL_RENDERBUFFER, 0); eglPrintError("glBindRenderbuffer()"); // attach the renderbuffer object to the depth and stencil attachment of the framebuffer glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo); eglPrintError("glFramebufferRenderbuffer()"); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE){ eglPrintError("glCheckFramebufferStatus()"); std::cout << "ERROR::FRAMEBUFFER:: Framebuffer is not complete!" << std::endl; // return; } glBindFramebuffer(GL_FRAMEBUFFER, 0); eglPrintError("glBindFramebuffer()"); // load shader GLuint shader_program = common_get_shader_program(vertex_shader1, fragment_shader1); // Shader *shader = new Shader(width, height); // shader->setShadersText(vertex_shader3, fragment_shader3); // shader->initShader(); // first pass glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); eglPrintError("glBindFramebuffer()"); glClearColor(0.9f, 0.95f, 1.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // we're not using the stencil buffer now glEnable(GL_DEPTH_TEST); // DrawScene(); drawFrame(self); // float shaderVertices[] = { // -1.0f, -1.0f, 0.0f, // -1.0f, 1.0f, 0.0f, // 1.0f, -1.0f, 0.0f, // -1.0f, 1.0f, 0.0f, // 1.0f, 1.0f, 0.0f, // 1.0f, -1.0f, 0.0f // }; // // Load the vertex data // glVertexAttribPointer ( 0, 3, GL_FLOAT, GL_FALSE, 0, shaderVertices ); // glEnableVertexAttribArray ( 0 ); // glBindTexture(GL_TEXTURE_2D, self->texture_name); // eglPrintError("glBindTexture()"); // glDrawArrays(GL_TRIANGLES, 0, 6); // second pass glBindFramebuffer(GL_FRAMEBUFFER, 0); eglPrintError("glBindFramebuffer()"); glClearColor(1.0f, 1.0f, 1.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); // glUseProgram(shader->programObject); eglPrintError("glUseProgram()"); glUseProgram(shader_program); eglPrintError("glUseProgram()"); glDisable(GL_DEPTH_TEST); glBindTexture(GL_TEXTURE_2D, self->texture_name); glDrawArrays(GL_TRIANGLES, 0, 6); fl_texture_registrar_mark_texture_frame_available(self->texture_registrar, self->texture); gdk_gl_context_clear_current(); // free(shader); glDeleteFramebuffers(1, &framebuffer); } void testRandomTexture(FlutterOpenglPlugin *self, int width, int height) { std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> distr(0, 255); std::vector buffer; for (int i = 0; i < height * width * 4; ++i) { buffer.push_back( distr(gen) ); } gdk_gl_context_make_current(self->context); glBindTexture(GL_TEXTURE_2D, self->texture_name); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_BGR, GL_UNSIGNED_BYTE, buffer.data()); fl_texture_registrar_mark_texture_frame_available(self->texture_registrar, self->texture); gdk_gl_context_clear_current(); std::cout << "************ FINE" << std::endl; } ================================================ FILE: pubspec.yaml ================================================ name: flutter_opengl description: Flutter plugin to bind a Texture widget to an OpenGL ES context. Many ShaderToy shaders can be used version: 0.9.0 homepage: https://github.com/alnitak/flutter_opengl environment: sdk: '>=2.18.4 <3.0.0' flutter: ">=2.5.0" dependencies: flutter: sdk: flutter plugin_platform_interface: ^2.1.3 #https://pub.dev/packages/ffi ffi: 2.0.1 #https://pub.dev/packages/image image: ^4.0.13 #https://pub.dev/packages/permission_handler permission_handler: ^10.2.0 dev_dependencies: flutter_test: sdk: flutter flutter_lints: ^2.0.1 #https://pub.dev/packages/ffigen ffigen: ^7.2.4 ffigen: output: './lib/flutter_opengl_ffi_TMP.dart' name: 'FlutterOpenGLFfi' description: 'Bindings to Flutter_OpenGL' functions: exclude: - 'getVisualizer' headers: entry-points: - 'ppp.h' include-directives: - '**ppp.h' unnamed-enums: include: - 'CX_.*' exclude: - '.*Flag' rename: 'CXType_(.*)': '$1' # For information on the generic Dart part of this file, see the # following page: https://dart.dev/tools/pub/pubspec # The following section is specific to Flutter packages. flutter: # This section identifies this Flutter project as a plugin project. # The 'pluginClass' specifies the class (in Java, Kotlin, Swift, Objective-C, etc.) # which should be registered in the plugin registry. This is required for # using method channels. # The Android 'package' specifies package in which the registered class is. # This is required for using method channels on Android. # The 'ffiPlugin' specifies that native code should be built and bundled. # This is required for using `dart:ffi`. # All these are used by the tooling to maintain consistency when # adding or updating assets for this project. plugin: platforms: android: package: com.example.flutter_opengl pluginClass: FlutterOpenglPlugin ios: pluginClass: FlutterOpenglPlugin linux: pluginClass: FlutterOpenglPlugin macos: pluginClass: FlutterOpenglPlugin windows: pluginClass: FlutterOpenglPluginCApi ================================================ FILE: src/Renderer.cpp ================================================ #include "Renderer.h" #ifdef _IS_ANDROID_ #include #include #include #include #include #include #include #include #elif _IS_LINUX_ #include "uniformQueue.h" #elif _IS_WIN_ #include #endif #define LOG_TAG_RENDERER "RENDERER" #define DEBUG true Renderer::Renderer(OpenglPluginContext *textureStruct) : self(textureStruct), frameRate(0.0), #ifdef WITH_OPENCV capture(nullptr), #endif shader(new Shader(textureStruct)), isShaderToy(false), loopRunning(false) { msg.push_back(MSG_NONE); } Renderer::~Renderer() { #ifdef WITH_OPENCV if (capture != nullptr) stopCapture(); #endif if (shader.get() != nullptr) { shader.reset(); shader.release(); } #ifdef _IS_WIN_ if (self->hrc) { wglMakeCurrent( NULL, NULL ); wglDeleteContext(self->hrc); } if (self->hdc) ReleaseDC(self->m_hWnd, self->hdc); if (self->myTexture != nullptr) { delete self->myTexture; self->myTexture = nullptr; } #endif } #ifdef _IS_ANDROID_ // TODO: try to use FBO in Android bool Renderer::setNativeAndroidWindow(jobject surface) { self->window = ANativeWindow_fromSurface(self->g_env, surface); self->surface = surface; return true; } bool Renderer::initOpenGL() { const EGLint attribs[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_BLUE_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_RED_SIZE, 8, EGL_NONE }; EGLConfig config; EGLint numConfigs; EGLint format; EGLDisplay display; EGLContext context; EGLSurface surface; GLfloat ratio; EGLint majorVersion, minorVersion; if (DEBUG) LOGD(LOG_TAG_RENDERER, "****************initializeGL()"); if ((display = eglGetDisplay(EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY) { eglPrintError("eglGetDisplay()"); return false; } if (!eglInitialize(display, &majorVersion, &minorVersion)) { eglPrintError("eglInitialize()"); return false; } if (!eglChooseConfig(display, attribs, &config, 1, &numConfigs)) { eglPrintError("eglChooseConfig()"); return false; } if (!eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format)) { eglPrintError("eglGetConfigAttrib()"); return false; } // TODO ANativeWindow_getWidth doesn't get real value // int mBufferWidth = (int)(ANativeWindow_getWidth(_window) * bufferScaleX); // int mBufferHeight = (int)(ANativeWindow_getHeight(_window) * bufferScaleY); int mBufferWidth = (int) (self->width); int mBufferHeight = (int) (self->height); ANativeWindow_setBuffersGeometry(self->window, mBufferWidth, mBufferHeight, format); if (!(surface = eglCreateWindowSurface(display, config, self->window, 0))) { eglPrintError("eglCreateWindowSurface()"); return false; } // can't get ES3 to work! const EGLint attribs2[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_BLUE_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_RED_SIZE, 8, EGL_NONE }; eglChooseConfig(display, attribs2, &config, 1, &numConfigs); const EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; if (!(context = eglCreateContext(display, config, 0, context_attribs))) { eglPrintError("eglCreateContext()"); return false; } if (!eglMakeCurrent(display, surface, surface, context)) { eglPrintError("eglMakeCurrent()"); return false; } if (!eglQuerySurface(display, surface, EGL_WIDTH, &self->width) || !eglQuerySurface(display, surface, EGL_HEIGHT, &self->height)) { eglPrintError("eglQuerySurface()"); return false; } eglSwapInterval(self->display, 1); self->display = display; self->surface = surface; self->context = context; return true; } void Renderer::destroyGL() { if (DEBUG) LOGD(LOG_TAG_RENDERER, "destroy()"); if (self->display != EGL_NO_DISPLAY) eglMakeCurrent(self->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); if (self->display != EGL_NO_DISPLAY && self->context != EGL_NO_CONTEXT) eglDestroyContext(self->display, self->context); if (self->display != EGL_NO_DISPLAY && self->surface != EGL_NO_SURFACE) eglDestroySurface(self->display, self->surface); if (self->display != EGL_NO_DISPLAY) eglTerminate(self->display); self->display = EGL_NO_DISPLAY; self->surface = EGL_NO_SURFACE; self->context = EGL_NO_CONTEXT; if (self->window != nullptr) { // native_window_api_disconnect(_window, NATIVE_WINDOW_API_EGL); ANativeWindow_release(self->window); } self->window = nullptr; if (DEBUG) LOGD(LOG_TAG_RENDERER, "destroyED"); } #endif #ifdef _IS_WIN_ GLint Renderer::setPixelFormat() { static PIXELFORMATDESCRIPTOR pfd= { sizeof(PIXELFORMATDESCRIPTOR), 1, PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, PFD_TYPE_RGBA, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0 }; GLint iPixelFormat; // get the device context's best, available pixel format match if((iPixelFormat = ChoosePixelFormat(self->hdc, &pfd)) == 0) { LOGD(LOG_TAG_RENDERER, "ChoosePixelFormat Failed"); return 0; } // make that match the device context's current pixel format if(SetPixelFormat(self->hdc, iPixelFormat, &pfd) == FALSE) { LOGD(LOG_TAG_RENDERER, "SetPixelFormat Failed"); return 0; } if((self->hrc = wglCreateContext(self->hdc)) == NULL) { LOGD(LOG_TAG_RENDERER, "wglCreateContext Failed"); return 0; } if((wglMakeCurrent(self->hdc, self->hrc)) == NULL) { LOGD(LOG_TAG_RENDERER, "wglMakeCurrent Failed"); return 0; } return 1; } bool Renderer::initOpenGL() { /* Get the handle of the windows device context. */ self->hdc = GetDC(self->m_hWnd); bool b; b = wglMakeCurrent(self->hdc, NULL); b = setPixelFormat(); // Initialize GL glewExperimental = GL_TRUE; GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ LOGD(LOG_TAG_RENDERER, "Error: %s", glewGetErrorString(err)); msg.push_back(MSG_STOP_RENDERER); return false; } glGenTextures(1, &self->texture_name); glBindTexture(GL_TEXTURE_2D, self->texture_name); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, self->width, self->height, 0, GL_BGR, GL_UNSIGNED_BYTE, nullptr); return true; } void Renderer::destroyGL() { } #endif #ifdef WITH_OPENCV OpenCVCapture *Renderer::getOpenCVCapture() { return capture; } bool Renderer::openCapture(std::string uniformName, std::string completeFilePath, int *width, int *height) { stopCapture(); capture = new OpenCVCapture(); bool opened = capture->open(uniformName, completeFilePath, width, height); if (!opened) { delete capture; capture = nullptr; return false; } return true; } std::mutex captureMutex; bool Renderer::stopCapture() { std::lock_guard guard(captureMutex); if (capture == nullptr) return false; delete capture; capture = nullptr; LOGD(LOG_TAG_RENDERER, "CAMERA STOPPED"); return true; } #endif void Renderer::stop() { msg.push_back(MSG_STOP_RENDERER); } // Set the message for the main loop that a new shader should be used std::string Renderer::setShader(bool isContinuous, const char *vertexSource, const char *fragmentSource) { compileError = ""; isShaderToy = false; newShaderFragmentSource = fragmentSource; newShaderVertexSource = vertexSource; newShaderIsContinuous = isContinuous; msg.push_back(MSG_NEW_SHADER); if (loopRunning) while (msg.back() == MSG_NEW_SHADER); return compileError; } // Set the message for the main loop that a new ShaderToy shader should be used std::string Renderer::setShaderToy(const char *fragmentSource) { compileError = ""; isShaderToy = true; newShaderFragmentSource = fragmentSource; newShaderVertexSource = ""; newShaderIsContinuous = true; msg.push_back(MSG_NEW_SHADER); if (loopRunning) while (msg.size() > 0 /* && msg.back() == MSG_NEW_SHADER*/); return compileError; } // The main rendering loop void Renderer::loop() { if (DEBUG) LOGD(LOG_TAG_RENDERER, "ENTERING LOOP"); unsigned int frames = 0; frameRate = 0.0; auto startFps = std::chrono::steady_clock::now(); auto endFps = std::chrono::steady_clock::now(); auto startDraw = std::chrono::steady_clock::now(); auto endDraw = std::chrono::steady_clock::now(); std::chrono::duration elapsedFps = std::chrono::duration(0); std::chrono::duration elapsedDraw = std::chrono::duration(0); double ms = 100.0; // MAX_FPS==0.1 draw 1 frame at max every 10 ms (max 100 FPS) double MAX_FPS = 1.0 / 100.0; loopRunning = true; #if defined _IS_ANDROID_ || defined _IS_WIN_ msg.push_back(MSG_INIT_OPENGL); #endif Sampler2D *sampler; RenderThreadMessage _msg; while (loopRunning) { mutex.lock(); if (msg.size() == 0) _msg = MSG_NONE; else { _msg = msg.back(); msg.pop_back(); } switch (_msg) { case MSG_INIT_OPENGL: #if defined _IS_ANDROID_ || defined _IS_WIN_ // On Android the GL context is created in initOpenGL() // and must be created in the loop thread. // On linux it is created by the Flutter engine // initOpenGL() must be called and if a shader // is already been set, initialize it! if (!initOpenGL()) { LOGD(LOG_TAG_RENDERER, "ERROR: Main Loop error initializing OpenGL!"); msg.push_back(MSG_STOP_RENDERER); } if (shader != nullptr) msg.push_back(MSG_NEW_SHADER); #endif break; case MSG_NEW_SHADER: // Eventually stop the capture #ifdef WITH_OPENCV stopCapture(); #endif if (shader.get() != nullptr) shader.reset(); shader = std::make_unique(self); shader->setShadersText(newShaderVertexSource, newShaderFragmentSource); shader->setShadersSize(self->width, self->height); shader->setIsContinuous(newShaderIsContinuous); if (isShaderToy) compileError = shader->initShaderToy(); else compileError = shader->initShader(); break; case MSG_START_CAPTURE_ON_UNIFORM: #ifdef _IS_LINUX_ gdk_gl_context_make_current(self->context); #elif _IS_WIN_ wglMakeCurrent(self->hdc, self->hrc); #endif #ifdef WITH_OPENCV sampler = shader->getUniforms().getSampler2D(uniformToSetCapture); if (sampler != nullptr && capture != nullptr) capture->start(sampler); #endif #ifdef _IS_LINUX_ gdk_gl_context_clear_current(); #endif break; case MSG_NEW_TEXTURE: #ifdef _IS_LINUX_ gdk_gl_context_make_current(self->context); #elif _IS_WIN_ wglMakeCurrent(self->hdc, self->hrc); #endif shader->getUniforms().setAllSampler2D(); #ifdef _IS_LINUX_ gdk_gl_context_clear_current(); #endif break; case MSG_SET_TEXTURE: #ifdef _IS_LINUX_ gdk_gl_context_make_current(self->context); #elif _IS_WIN_ wglMakeCurrent(self->hdc, self->hrc); #endif // // shader->getUniforms().setSampler2D("iChannel0", shader->getUniforms().programObject, sampler2DToSet); // shader->getUniforms().setAllSampler2D(); glActiveTexture(GL_TEXTURE0 + sampler2DToSet.nTexture); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, sampler2DToSet.texture_index); glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, sampler2DToSet.width, sampler2DToSet.height, GL_RGBA, GL_UNSIGNED_BYTE, sampler2DToSet.data.data() ); sampler2DToSet.data.clear(); #ifdef _IS_LINUX_ gdk_gl_context_clear_current(); #endif break; case MSG_DELETE_TEXTURE: #ifdef _IS_LINUX_ gdk_gl_context_make_current(self->context); #elif _IS_WIN_ wglMakeCurrent(self->hdc, self->hrc); #endif glDeleteTextures(1, &textureIdToDelete); #ifdef _IS_LINUX_ gdk_gl_context_clear_current(); #endif break; case MSG_STOP_RENDERER: loopRunning = false; #if defined _IS_ANDROID_ || defined _IS_WIN_ destroyGL(); #endif break; default: if (shader == nullptr || !shader->isContinuous()) break; // TODO check this frameRate because visually it seems not correct! // TODO Maybe there is some asynchronous function that doesn't let counting right? elapsedFps = endFps - startFps; elapsedDraw = endDraw - startDraw; if (elapsedDraw.count() >= MAX_FPS) { frames++; // printf("%d\n", frames); fflush(stdout); shader->drawFrame(); startDraw = std::chrono::steady_clock::now(); // this doesn't seem to correct FPS (OpenGL has some asynchronous operations) glFlush(); glFinish(); } endDraw = std::chrono::steady_clock::now(); // update frameRate every second if (elapsedFps.count() >= 1.0) { frameRate = (double) frames * 0.5 + frameRate * 0.5; // more stable frames = 0; startFps = std::chrono::steady_clock::now(); } endFps = std::chrono::steady_clock::now(); break; } mutex.unlock(); } loopRunning = false; } ================================================ FILE: src/Renderer.h ================================================ #ifndef RENDERER_H #define RENDERER_H #include "common.h" #include "Shader.h" #ifdef _IS_ANDROID_ #include #include #include #include #ifdef WITH_OPENCV #include "opencv_capture.h" #endif #elif _IS_LINUX_ #include "../linux/include/fl_my_texture_gl.h" #ifdef WITH_OPENCV #include "opencv_capture.h" #endif #elif _IS_WIN_ #include "../windows/flutter_opengl_plugin.h" #ifdef WITH_OPENCV #include "opencv_capture.h" #endif #endif #include #include class Renderer { public: Renderer( OpenglPluginContext *textureStruct); ~Renderer(); #ifdef _IS_ANDROID_ bool setNativeAndroidWindow(jobject surface); bool initOpenGL(); void destroyGL(); #endif #ifdef _IS_WIN_ GLint setPixelFormat(); bool initOpenGL(); void destroyGL(); #endif void stop(); void loop(); std::string setShader(bool isContinuous, const char *vertexSource, const char *fragmentSource); std::string setShaderToy(const char *fragmentSource); inline std::string getCompileError() { return compileError; }; inline Shader *getShader() { return shader.get(); }; inline bool isLooping() { return loopRunning; }; inline double getFrameRate() { return frameRate; }; inline void setNewTextureMsg() { msg.push_back(MSG_NEW_TEXTURE); }; // set new data for a texture of the same size inline void setTextureMsg(const Sampler2D &sampler) { sampler2DToSet = sampler; msg.push_back(MSG_SET_TEXTURE); }; inline void deleteTextureMsg(unsigned int textureId) { textureIdToDelete = textureId; msg.push_back(MSG_DELETE_TEXTURE); }; #ifdef WITH_OPENCV OpenCVCapture *getOpenCVCapture(); inline void setStartCameraOnUniformMsg(const std::string &name) { uniformToSetCapture = name; msg.push_back(MSG_START_CAPTURE_ON_UNIFORM); }; bool openCapture(std::string uniformName, std::string completeFilePath, int *width, int *height); bool stopCapture(); #endif private: OpenglPluginContext *self; std::mutex mutex; double frameRate; #ifdef WITH_OPENCV OpenCVCapture *capture; std::string uniformToSetCapture; #endif std::string compileError; std::unique_ptr shader; bool newShaderIsContinuous; std::string newShaderFragmentSource; std::string newShaderVertexSource; bool isShaderToy; bool loopRunning; Sampler2D sampler2DToSet; unsigned int textureIdToDelete; enum RenderThreadMessage : int { MSG_NONE = 0, MSG_DATA_RECEIVED, // when new data is ready, the draw function is called which must then free its memory MSG_INIT_OPENGL, // only in Android, this must be called in the loop thread(?) MSG_STOP_RENDERER, MSG_NEW_SHADER, MSG_NEW_TEXTURE, MSG_DELETE_TEXTURE, MSG_SET_TEXTURE, // set new data for a texture of the same size MSG_START_CAPTURE_ON_UNIFORM }; std::vector msg; }; #endif //RENDERER_H ================================================ FILE: src/Sampler2D.cpp ================================================ #include "Sampler2D.h" #include "Shader.h" #ifdef _IS_ANDROID_ #include #include #elif _IS_LINUX_ #include #elif _IS_WIN_ #include #endif #include Sampler2D::Sampler2D() : nTexture(-1) { } void Sampler2D::replaceTexture(int w, int h, unsigned char *rawData) { if (nTexture == -1) return; data.clear(); add_RGBA32(w, h, rawData); } void Sampler2D::add_RGBA32(int w, int h, unsigned char *rawData) { width = w; height = h; int size = width * height * sizeof(unsigned char) * 4; data.resize(size); memcpy(&data[0], rawData, size); } // Generate a texture or resample an existing one // [ñ] should be a unique number from 0 to 31. It's a number // that other Sampler2D doesn't use void Sampler2D::genTexture(int n) { // if the data is empty, the texture has already been generated if (data.empty()) return; // if nTexture != -1 the texture has already been created // and we are here only to update it if (nTexture == -1) { nTexture = n; glGenTextures(1, &texture_index); } glActiveTexture(GL_TEXTURE0 + nTexture); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture_index); // filtering and wrap modes glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (void*)data.data()); // glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, (void*)data.data()); // glGenerateMipmap(GL_TEXTURE_2D); // glBindTexture(GL_TEXTURE_2D, texture_index); data.clear(); } ================================================ FILE: src/Sampler2D.h ================================================ #ifndef SAMPLER2D_H #define SAMPLER2D_H #include "common.h" #include class Sampler2D { public: Sampler2D(); ~Sampler2D() = default; void replaceTexture(int w, int h, unsigned char *rawData); void add_RGBA32(int w, int h, unsigned char *rawData); void genTexture(int n); std::vector data; int width, height; unsigned int texture_index; // define the Nth texture. // The 1st texture defined will be used as GL_TEXTURE0 // The 2nd GL_TEXTURE1 and so on int nTexture; }; #endif // SAMPLER2D_H ================================================ FILE: src/Shader.cpp ================================================ #include "Shader.h" #include "common.h" #include #include #include #define LOG_TAG_SHADER "NATIVE SHADER" // Query eglGetError and eventully print it with the [note] void eglPrintError(const std::string ¬e) { EGLint error = eglGetError(); std::string ret; switch (error) { case EGL_SUCCESS: ret = "No error"; break; case EGL_NOT_INITIALIZED: ret = "EGL not initialized or failed to initialize"; break; case EGL_BAD_ACCESS: ret = "Resource inaccessible"; break; case EGL_BAD_ALLOC: ret = "Cannot allocate resources"; break; case EGL_BAD_ATTRIBUTE: ret = "Unrecognized attribute or attribute value"; break; case EGL_BAD_CONTEXT: ret = "Invalid EGL context"; break; case EGL_BAD_CONFIG: ret = "Invalid EGL frame buffer configuration"; break; case EGL_BAD_CURRENT_SURFACE: ret = "Current surface is no longer valid"; break; case EGL_BAD_DISPLAY: ret = "Invalid EGL display"; break; case EGL_BAD_SURFACE: ret = "Invalid surface"; break; case EGL_BAD_MATCH: ret = "Inconsistent arguments"; break; case EGL_BAD_PARAMETER: ret = "Invalid argument"; break; case EGL_BAD_NATIVE_PIXMAP: ret = "Invalid native pixmap"; break; case EGL_BAD_NATIVE_WINDOW: ret = "Invalid native window"; break; case EGL_CONTEXT_LOST: ret = "Context lost"; break; default: ret = "Unknown error"; } if (error == EGL_SUCCESS) { LOGD(LOG_TAG_SHADER, "%s %s", note.c_str(), ret.c_str()); } else { LOGD(LOG_TAG_SHADER, "%s error: %d 0x%X %s", note.c_str(), error, error, ret.c_str()); } } void replaceAll(std::string& src, const std::string& search, const std::string& replace) { size_t pos = 0; while ((pos = src.find(search, pos)) != std::string::npos) { src.replace(pos, search.length(), replace); pos += replace.length(); } } Shader::Shader(OpenglPluginContext *textureStruct) : self(textureStruct), width(0), height(0), programObject(0), _isContinuous(true), uniformsList(UniformQueue()) { } Shader::~Shader() { if (programObject != 0) glDeleteProgram(programObject); } // Not yet used. It will be used to draw the scene only when new data to draw it will be sent void Shader::setIsContinuous(bool isContinuous) { _isContinuous = isContinuous; } // Adds the basic uniforms used in ShaderToy shaders // #include "Sampler2D.h" // Sampler2D sampler = Sampler2D(); void Shader::addShaderToyUniforms() { glm::vec4 iMouse = glm::vec4(0.0f, 0.0f, 0.0f, 0.0f); glm::vec3 iResolution = glm::vec3((GLfloat) width, (GLfloat) height, 0.0f); float time = 0.0f; uniformsList.addUniform("iMouse", UNIFORM_VEC4, (void *) (&iMouse)); uniformsList.addUniform("iResolution", UNIFORM_VEC3, (void *) (&iResolution)); uniformsList.addUniform("iTime", UNIFORM_FLOAT, (void *) (&time)); // Add black 4x4 texture for each iChannel std::vector rawData(4 * 4 * 4, 0); Sampler2D sampler; sampler.add_RGBA32(4, 4, rawData.data()); uniformsList.addUniform("iChannel0", UNIFORM_SAMPLER2D, (void *) (&sampler)); uniformsList.addUniform("iChannel1", UNIFORM_SAMPLER2D, (void *) (&sampler)); uniformsList.addUniform("iChannel2", UNIFORM_SAMPLER2D, (void *) (&sampler)); uniformsList.addUniform("iChannel3", UNIFORM_SAMPLER2D, (void *) (&sampler)); } void Shader::setShadersSize(int w, int h) { width = w; height = h; } // Set the source of the shaders void Shader::setShadersText(std::string vertexSource, std::string fragmentSource) { this->vertexSource = vertexSource; this->fragmentSource = fragmentSource; LOGD(LOG_TAG_SHADER, "Shader sources set"); } std::string Shader::initShader() { compileError = ""; if (programObject != 0) glDeleteProgram(programObject); #ifdef _IS_LINUX_ gdk_gl_context_make_current(self->context); #elif _IS_WIN_ wglMakeCurrent(self->hdc, self->hrc); #endif programObject = createProgram(vertexSource.c_str(), fragmentSource.c_str()); if (programObject == 0) { LOGD(LOG_TAG_SHADER, "Error loading shader"); return compileError; } uniformsList.setProgram(programObject); startTime = (GLfloat) clock() / (GLfloat) CLOCKS_PER_SEC; #ifdef _IS_ANDROID_ // Load the vertex data glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, shaderVertices); glEnableVertexAttribArray(0); #endif #if defined _IS_LINUX_ || defined _IS_WIN_ // use FrameBuffer on Linux glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); glViewport(0, 0, width, height); glClearColor(.0f, .0f, .0f, 1.f); // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s). glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(shaderVertices), shaderVertices, GL_STATIC_DRAW); // Position attribute glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid *)0); glEnableVertexAttribArray(0); // Text coords attribute // glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(4 * sizeof(GLfloat))); // glEnableVertexAttribArray(1); glBindVertexArray(0); // Unbind VAO glBindTexture(GL_TEXTURE_2D, self->texture_name); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glGenFramebuffers(1, (GLuint *)&FBO); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, FBO); glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, self->texture_name, 0); #endif uniformsList.setAllSampler2D(); #ifdef _IS_LINUX_ gdk_gl_context_clear_current(); #elif _IS_WIN_ // pixelBuffer = make_unique(width * height * 4); // if (buffer == nullptr) { // LOGD(LOG_TAG_SHADER, "Can't allocate buffer memory!"); // if (programObject != 0) // glDeleteProgram(programObject); // compileError = "Can't allocate buffer memory!"; // } #endif LOGD(LOG_TAG_SHADER, "Shader programmed: %d", programObject); return compileError; } // Prepare the common vertex shader and uniforms to be used with // the ShaderToy fragment shader std::string Shader::initShaderToy() { // Shows how to use the mouse input (only left button supported): // // mouse.xy = mouse position during last button down // abs(mouse.zw) = mouse position during last button click // sign(mouze.z) = button is down // sign(mouze.w) = button is clicked // https://www.shadertoy.com/view/llySRh // https://www.shadertoy.com/view/Mss3zH // IMPORT FROM SHADERTOY on Android: // Since for now only ES 2 is supported and the below ES 3 functions // are not supported, replace them // texture ==> texture2D // round == floor #ifdef _IS_ANDROID_ replaceAll(fragmentSource, "texture(", "texture2D("); replaceAll(fragmentSource, "round(", "floor("); #endif vertexSource = #ifdef _IS_ANDROID_ // "#version 300 es\n" #elif defined _IS_LINUX_ || defined _IS_WIN_ "#version 330 core\n" #endif "precision highp float;\n" "precision mediump int;\n" "attribute vec4 a_Position; \n" // Per-vertex position information we will pass in. "void main() \n" // The entry point for our vertex shader. "{ \n" " gl_Position = a_Position; \n" "} \n"; std::string common = "precision highp float; \n" // "layout(binding=0) uniform sampler2D iChannel0; \n" // "layout(binding=1) uniform sampler2D iChannel1; \n" // "layout(binding=2) uniform sampler2D iChannel2; \n" // "layout(binding=3) uniform sampler2D iChannel3; \n" "uniform sampler2D iChannel0; \n" "uniform sampler2D iChannel1; \n" "uniform sampler2D iChannel2; \n" "uniform sampler2D iChannel3; \n" "uniform vec4 iMouse; \n" // mouse position (in pixels) "uniform vec3 iResolution; \n" // viewport resolution (in pixels) "uniform float iTime; \n"; // shader playback time (in seconds) std::string main = "\nvoid main() {\n" #ifdef _IS_ANDROID_ " mainImage(gl_FragColor, gl_FragCoord.xy);\n" #endif #if defined _IS_LINUX_ || defined _IS_WIN_ // The FBO is vertical flipped. It has top-left origin, but OpenGL has bottom-left // So do a flip in vertical axis when using framebuffer " mainImage(gl_FragColor, vec2(gl_FragCoord.x, iResolution.y-gl_FragCoord.y));\n" #endif "}\n"; fragmentSource = #if defined _IS_LINUX_ || defined _IS_WIN_ "#version 330 core\n" #endif //"#version 300 es\n" "#extension GL_OES_standard_derivatives : enable \n" + // needed by fwidth common + fragmentSource + main; addShaderToyUniforms(); return initShader(); } GLuint Shader::loadShader(GLenum shaderType, const char *shaderSource) { GLuint shader = glCreateShader(shaderType); if (shader) { glShaderSource(shader, 1, &shaderSource, NULL); glCompileShader(shader); GLint compiled = 0; glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); if (!compiled) { GLint infoLen = 0; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen) { char *buf = (char *) malloc(infoLen); if (buf) { glGetShaderInfoLog(shader, infoLen, NULL, buf); std::string type = shaderType == GL_VERTEX_SHADER ? "VERTEX" : "FRAGMENT"; LOGD(LOG_TAG_SHADER, "Could not Compile %s Shader:\n%s\n", type.c_str(), buf); compileError = type + " shader compile error:\n" + std::string(buf); free(buf); } glDeleteShader(shader); shader = 0; } } } else { LOGD(LOG_TAG_SHADER, "loadShader(), glCreateShader() error: Could not create shader object!!"); } return shader; } GLuint Shader::createProgram(const char *vertexSource, const char *fragmentSource) { GLuint vertexShader = loadShader(GL_VERTEX_SHADER, vertexSource); if (!vertexShader) return 0; GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, fragmentSource); if (!fragmentShader) return 0; GLuint program = glCreateProgram(); if (program) { glAttachShader(program, vertexShader); glAttachShader(program, fragmentShader); glLinkProgram(program); GLint linkStatus = GL_FALSE; glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); if (linkStatus != GL_TRUE) { GLint bufLength = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength); if (bufLength) { char *buf = (char *) malloc(sizeof(GLint) * bufLength); if (buf) { glGetProgramInfoLog(program, bufLength, NULL, buf); LOGD(LOG_TAG_SHADER, "Could not link program:\n%s\n", buf); free(buf); } } glDeleteProgram(program); program = 0; } } return program; } void Shader::use() const { glUseProgram(programObject); } // called from the main rendering loop. // The flow: // 1 - Make the context current (linux & win) // 2 - set all uniforms // 3 - draw into frame buffer object (linux & win). On android draw to texture and swap buffer // 4 - tell to Flutter texture registrat that a new frame is available void Shader::drawFrame() { if (programObject == 0) return; std::lock_guard lock_guard(mutex_); #ifdef _IS_LINUX_ gdk_gl_context_make_current(self->context); #elif _IS_WIN_ wglMakeCurrent(self->hdc, self->hrc); #endif glClear(GL_COLOR_BUFFER_BIT); GLfloat time = (GLfloat) clock() / (GLfloat) CLOCKS_PER_SEC - startTime; use(); uniformsList.setUniformValue("iTime", (void *) (&time)); uniformsList.sendAllUniforms(); #ifdef _IS_ANDROID_ glDrawArrays(GL_TRIANGLES, 0, 6); if (!eglSwapBuffers(self->display, self->surface)) { eglPrintError("eglSwapBuffers()"); } #elif _IS_LINUX_ glBindVertexArray(VAO); glDrawArrays(GL_TRIANGLES, 0, 6); glBindVertexArray(0); // glBindTexture(GL_TEXTURE_2D, NULL); // glFlush(); // glFinish(); fl_texture_registrar_mark_texture_frame_available(self->texture_registrar, self->texture); gdk_gl_context_clear_current(); #elif _IS_WIN_ glBindVertexArray(VAO); glDrawArrays(GL_TRIANGLES, 0, 6); glBindVertexArray(0); glBindTexture(GL_TEXTURE_2D, NULL); glBindFramebuffer(GLenum(GL_FRAMEBUFFER), FBO); /// uff... takes me ages to understand that Widnwos doesn't like glGetTexImage??*@##[]][!! // glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, (void*)(self->myTexture->buffer.data())); glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, (void*)(self->myTexture->buffer.data())); self->myTexture->Update(); #endif } ================================================ FILE: src/Shader.h ================================================ #ifndef SHADER_H #define SHADER_H #include "common.h" #include "uniformQueue.h" #include #include #include #include #ifdef _IS_ANDROID_ #define EGL_EGLEXT_PROTOTYPES #include "EGL/eglext.h" #include "GLES3/gl3.h" #define GL_GLEXT_PROTOTYPES #include "GLES3/gl3ext.h" #include #include "glm.hpp" #endif #ifdef _IS_LINUX_ #include "../linux/include/fl_my_texture_gl.h" #include #include #include #endif #ifdef _IS_WIN_ #include "../windows/flutter_opengl_plugin.h" #include #include #include #endif extern "C" void eglPrintError(const std::string ¬e); extern "C" void replaceAll(std::string& src, const std::string& search, const std::string& replace); class Shader { public: Shader(OpenglPluginContext *textureStruct); virtual ~Shader(); void addShaderToyUniforms(); void setShadersSize(int w, int h); void setShadersText(std::string vertexSource, std::string fragmentSource); void setIsContinuous(bool isContinuous); bool isContinuous() { return _isContinuous; }; bool isValid() { return programObject != 0; } bool getProgramObject() { return programObject; } int getWidth() { return width; } int getHeight() { return height; } std::string initShaderToy(); std::string initShader(); void drawFrame(); UniformQueue &getUniforms() { return uniformsList; }; void use() const; std::string compileError; std::string vertexSource; std::string fragmentSource; private: // good glVertexAttribPointer explaination // https://stackoverflow.com/questions/16380005/opengl-3-4-glvertexattribpointer-stride-and-offset-miscalculation?r=Saves_UserSavesList const GLfloat shaderVertices[18] = { -1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 0.0f }; mutable std::mutex mutex_; OpenglPluginContext *self; bool _isContinuous = true; EGLint width; EGLint height; GLuint programObject; GLuint VAO, VBO; GLuint FBO; GLfloat startTime; UniformQueue uniformsList; GLuint loadShader(GLenum shaderType, const char *shaderSource); GLuint createProgram(const char *vertexSource, const char *fragmentSource); }; #endif //SHADER_H ================================================ FILE: src/common.h ================================================ #ifndef COMMON_H #define COMMON_H // On Android, also __linux__ is defined. So make my own #ifdef __ANDROID__ #define _IS_ANDROID_ 1 #define WITH_OPENCV #elif __linux__ #define _IS_LINUX_ 1 #define WITH_OPENCV #elif _WIN32 | _WIN64 #define _IS_WIN_ 1 #define WITH_OPENCV #endif #ifdef _IS_ANDROID_ #include #include #include #define LOGD(TAG, ...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__) #define FFI_PLUGIN_EXPORT __attribute__((visibility("default"))) __attribute__((used)) typedef struct flutter_opengl_plugin_context { JavaVM *javaVM; JNIEnv *g_env; jclass cls; ANativeWindow *window; EGLDisplay display; EGLContext context; EGLSurface surface; unsigned int texture_name; int width; int height; } OpenglPluginContext; static OpenglPluginContext g_ctx_f = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 0, 0, 0}; #elif _IS_LINUX_ #include #include "../linux/include/fl_my_texture_gl.h" #include #include #include #include // #define LOGD(TAG, ...) std::cout< #include "../windows/fl_my_texture_gl.h" #include #define LOGD(TAG,...) printf(TAG),printf(" "),printf(__VA_ARGS__),printf("\n");fflush(stdout); #define FFI_PLUGIN_EXPORT __declspec(dllexport) typedef struct flutter_opengl_plugin_context { HWND m_hWnd; HDC hdc; HGLRC hrc; // rendering context variable flutter::TextureRegistrar *texture_registrar; flutter::PluginRegistrarWindows *registrar; FlMyTextureGL *myTexture; unsigned int texture_name; int64_t texture_id; int width; int height; } OpenglPluginContext; static OpenglPluginContext ctx_f = {0, 0, 0, 0, 0, 0, 0, 0, 0}; #endif #endif // COMMON_H ================================================ FILE: src/ffi.cpp ================================================ #include "common.h" #include "ffi.h" #include "Renderer.h" #include "uniformQueue.h" #include "Sampler2D.h" Renderer *renderer = nullptr; #define LOG_TAG_FFI "NATIVE FFI" #define DEBUG_TAG_FFI true //////////////////////////////// /// renderer //////////////////////////////// void deleteRenderer() { if (renderer != nullptr) { if (renderer->isLooping()) { // eventually stop the capture #ifdef WITH_OPENCV if (renderer->getOpenCVCapture() != nullptr) renderer->stopCapture(); #endif while (bool b = renderer->isLooping()) renderer->stop(); } delete renderer; renderer = nullptr; } } void createRenderer(OpenglPluginContext *textureStruct) { deleteRenderer(); renderer = new Renderer(textureStruct); } Renderer *getRenderer() { return renderer; } extern "C" FFI_PLUGIN_EXPORT bool rendererStatus() { if (renderer == nullptr) return false; return true; } extern "C" FFI_PLUGIN_EXPORT void getTextureSize(int32_t *width, int32_t *height) { if (renderer == nullptr || renderer->getShader() == nullptr) { *width = -1; *height = -1; return; } *width = renderer->getShader()->getWidth(); *height = renderer->getShader()->getHeight(); } /////////////////////////////////// // Start OpenGL thread extern "C" FFI_PLUGIN_EXPORT void startThread() { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "startThread: Texture not yet created!"); return; } std::thread loopThread = std::thread([&]() { renderer->loop(); }); loopThread.detach(); } /////////////////////////////////// // Stop OpenGL thread extern "C" FFI_PLUGIN_EXPORT void stopThread() { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "stopThread: Renderer not yet created!"); return; } renderer->stop(); while (renderer->isLooping()); delete renderer; renderer = nullptr; } /////////////////////////////////// // Set new shader std::string compileError; extern "C" FFI_PLUGIN_EXPORT const char * setShader(bool isContinuous, const char *vertexShader, const char *fragmentShader) { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "setShader: Renderer not yet created!"); return ""; } compileError = renderer->setShader( isContinuous, vertexShader, fragmentShader); const char *ret = compileError.c_str(); return ret; } /////////////////////////////////// // Set new ShaderToy shader extern "C" FFI_PLUGIN_EXPORT const char * setShaderToy(const char *fragmentShader) { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "setShaderToy: Renderer not yet created!"); return ""; } compileError = renderer->setShaderToy(fragmentShader); const char *ret = compileError.c_str(); return ret; } /////////////////////////////////// // Get shader sources extern "C" FFI_PLUGIN_EXPORT const char * getVertexShader() { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "getVertexShader: Renderer not yet created!"); return ""; } if (renderer->getShader() == nullptr) { LOGD(LOG_TAG_FFI, "getVertexShader: Shader not set yet!"); return ""; } return renderer->getShader()->vertexSource.c_str(); } extern "C" FFI_PLUGIN_EXPORT const char * getFragmentShader() { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "getFragmentShader: Renderer not yet created!"); return ""; } if (renderer->getShader() == nullptr) { LOGD(LOG_TAG_FFI, "getFragmentShader: Shader not set yet!"); return ""; } return renderer->getShader()->fragmentSource.c_str(); } /////////////////////////////////// // Set mouse position extern "C" FFI_PLUGIN_EXPORT void addShaderToyUniforms() { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "addShaderToyUniforms: Renderer not yet created!"); return; } if (renderer->getShader() == nullptr) { LOGD(LOG_TAG_FFI, "addShaderToyUniforms: Shader not set yet!"); return; } renderer->getShader()->addShaderToyUniforms(); } /////////////////////////////////// // Set mouse position // Shows how to use the mouse input (only left button supported): // // mouse.xy = mouse position during last button down // abs(mouse.zw) = mouse position during last button click // sign(mouze.z) = button is down // sign(mouze.w) = button is clicked // https://www.shadertoy.com/view/llySRh // https://www.shadertoy.com/view/Mss3zH extern "C" FFI_PLUGIN_EXPORT void setMousePosition( double posX, double posY, double posZ, double posW, double textureWidgetWidth, double textureWidgetHeight) { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "setMousePosition: Renderer not yet created!"); return; } if (renderer->getShader() == nullptr) { LOGD(LOG_TAG_FFI, "setMousePosition: Shader not yet binded!"); return; } // Normalize values from the Texture() widget to the texture size double textureWidth = renderer->getShader()->getWidth(); double textureHeigth = renderer->getShader()->getHeight(); double arH = textureWidth / textureWidgetWidth; double arV = textureHeigth / textureWidgetHeight; posX *= arH; posY *= arV; posZ *= arH; posW *= arV; // flip vertically Y coord posY = textureHeigth - posY; posW = -textureHeigth - posW; // LOGD(LOG_TAG_FFI, "setMousePosition: %f %f %f %f", posX, posY, posZ, posW); auto mouse = glm::vec4( posX, posY, posZ, posW); renderer->getShader()->getUniforms().setUniformValue( std::string("iMouse"), (void *) (&mouse)); } /////////////////////////////////// // Get FPS extern "C" FFI_PLUGIN_EXPORT double getFPS() { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "getFPS: Renderer not yet created!"); return -1.0; } if (!renderer->isLooping()) { LOGD(LOG_TAG_FFI, "getFPS: Renderer not running!"); return -1.0; } return renderer->getFrameRate(); } /////////////////////////////////// // Add uniform extern "C" FFI_PLUGIN_EXPORT bool addUniform( const char *name, UniformType type, void *val) { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "addUniform: Renderer not yet created!"); return false; } if (renderer->getShader() == nullptr) { LOGD(LOG_TAG_FFI, "addUniform: shader not yet binded!"); return false; } renderer->getShader()->getUniforms().addUniform(name, type, val); return true; } /////////////////////////////////// // Remove uniform extern "C" FFI_PLUGIN_EXPORT bool removeUniform(const char *name) { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "addUniform: Renderer not yet created!"); return false; } if (renderer->getShader() == nullptr) { LOGD(LOG_TAG_FFI, "addUniform: shader not yet binded!"); return false; } return renderer->getShader()->getUniforms().removeUniform(name); } /////////////////////////////////// // Set uniform extern "C" FFI_PLUGIN_EXPORT bool setUniform( const char *name, void *val) { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "addUniform: Renderer not yet created!"); return false; } if (renderer->getShader() == nullptr) { LOGD(LOG_TAG_FFI, "addUniform: shader not yet binded!"); return false; } return renderer->getShader()->getUniforms().setUniformValue(name, val); } /////////////////////////////////// // Add Sampler2D uniform //* val should be a list of RGBA32 values //* Use setUniform() to set a new value with a texture with the same size extern "C" FFI_PLUGIN_EXPORT bool addSampler2DUniform(const char *name, int width, int height, void *val) { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "addUniform: Renderer not yet created!"); return false; } if (renderer->getShader() == nullptr) { LOGD(LOG_TAG_FFI, "addUniform: shader not yet binded!"); return false; } bool ret = false; Sampler2D sampler = Sampler2D(); sampler.add_RGBA32(width, height, (unsigned char*)val); ret = renderer->getShader()->getUniforms() .addUniform(name, UNIFORM_SAMPLER2D, (void*)&sampler); if (ret && renderer->isLooping()) renderer->setNewTextureMsg(); return ret; } /////////////////////////////////// // Replace Sampler2D uniform //* val should be a list of RGBA32 values //* Used when replacing textures of different sizes extern "C" FFI_PLUGIN_EXPORT bool replaceSampler2DUniform(const char *name, int width, int height, void *val) { if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "replaceSampler2DUniform: Renderer not yet created!"); return false; } if (renderer->getShader() == nullptr) { LOGD(LOG_TAG_FFI, "replaceSampler2DUniform: shader not yet binded!"); return false; } bool replaced = renderer->getShader()->getUniforms() .replaceSampler2D(name, width, height, (unsigned char *)val); if (replaced && renderer->isLooping()) renderer->setNewTextureMsg(); return replaced; } /////////////////////////////////// // Start capture extern "C" FFI_PLUGIN_EXPORT bool startCaptureOnSampler2D(const char *name, const char *completeFilePath) { #ifndef WITH_OPENCV LOGD(LOG_TAG_FFI, "Error startCaptureOnSampler2D(): OPENCV is not yet supported on this platform!"); return false; #else if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "startCaptureOnSampler2D: Renderer not yet created!"); return false; } int width; int height; if (renderer->openCapture(name, completeFilePath, &width, &height)) { renderer->setStartCameraOnUniformMsg(name); // Force a resample of sampler2D texture // char dummy[width * height * 4]; auto * dummy = (unsigned char *) malloc(width * height * 4); replaceSampler2DUniform(name, width, height, (void *) dummy); free(dummy); return true; } return false; #endif } /////////////////////////////////// // Start capture extern "C" FFI_PLUGIN_EXPORT bool stopCapture() { #ifndef WITH_OPENCV LOGD(LOG_TAG_FFI, "Error stopCapture(): OPENCV is not yet supported on this platform!"); return false; #else if (renderer == nullptr) { LOGD(LOG_TAG_FFI, "stopCapture: Renderer not yet created!"); return false; } return renderer->stopCapture(); #endif } ================================================ FILE: src/ffi.h ================================================ #ifndef FFI_H #define FFI_H #include "common.h" #include "uniformQueue.h" #include "Renderer.h" void deleteRenderer(); void createRenderer(OpenglPluginContext *textureStruct); Renderer *getRenderer(); extern "C" FFI_PLUGIN_EXPORT bool rendererStatus(); extern "C" FFI_PLUGIN_EXPORT void getTextureSize(int32_t *width, int32_t *height); extern "C" FFI_PLUGIN_EXPORT void startThread(); extern "C" FFI_PLUGIN_EXPORT void stopThread(); extern "C" FFI_PLUGIN_EXPORT const char *setShader( bool isContinuous, const char *vertexShader, const char *fragmentShader); extern "C" FFI_PLUGIN_EXPORT const char *setShaderToy( const char *fragmentShader); extern "C" FFI_PLUGIN_EXPORT const char *getVertexShader(); extern "C" FFI_PLUGIN_EXPORT const char *getFragmentShader(); extern "C" FFI_PLUGIN_EXPORT void addShaderToyUniforms(); extern "C" FFI_PLUGIN_EXPORT void setMousePosition( double posX, double posY, double posZ, double posW, double textureWidgetWidth, double textureWidgetHeight); extern "C" FFI_PLUGIN_EXPORT double getFPS(); extern "C" FFI_PLUGIN_EXPORT bool addUniform( const char *name, UniformType type, void *val); extern "C" FFI_PLUGIN_EXPORT bool removeUniform(const char *name); extern "C" FFI_PLUGIN_EXPORT bool setUniform( const char *name, void *val); extern "C" FFI_PLUGIN_EXPORT bool addSampler2DUniform( const char *name, int width, int height, void *val); extern "C" FFI_PLUGIN_EXPORT bool replaceSampler2DUniform( const char *name, int width, int height, void *val); extern "C" FFI_PLUGIN_EXPORT bool startCameraOnSampler2D( const char *name, const char *completeFilePath); extern "C" FFI_PLUGIN_EXPORT bool stopCapture(); #endif // FFI_H ================================================ FILE: src/ndk/ndk.cpp ================================================ #include #include "common.h" //#include "native.h" #include "ffi.h" #include "Renderer.h" #define JAVA(X) JNIEXPORT Java_com_example_flutter_1opengl_FlutterOpenglPlugin_##X void setVM(JavaVM *vm) { g_ctx_f.javaVM = vm; } bool setFlutterEnvironment() { if (g_ctx_f.javaVM->GetEnv((void **) &g_ctx_f.g_env, JNI_VERSION_1_6) != JNI_OK) return false; return true; } extern "C" jint JNI_OnLoad(JavaVM *vm, void *reserved) { setVM(vm); setFlutterEnvironment(); LOGD("ndk.cpp", "JNI INIT"); return JNI_VERSION_1_6; } //extern "C" void JAVA(nativeSetSurface)(JNIEnv *jenv, // jclass obj, // jobject surface) { // if (getVisualizer() != nullptr) { // stopThread(); // } else { // createVisualizer(); // } // // getVisualizer()->setNativeWindow(g_ctx_f.g_env, static_cast(surface)); //} extern "C" void JAVA(nativeSetSurface)(JNIEnv *jenv, jclass obj, jobject surface, jint width, jint height) { if (getRenderer() != nullptr) { LOGD("ndk.cpp", "Renderer already created! Stopping."); stopThread(); } else { g_ctx_f.width = width; g_ctx_f.height = height; createRenderer(&g_ctx_f); getRenderer()->setNativeAndroidWindow(static_cast(surface)); } } ================================================ FILE: src/opencv_capture.cpp ================================================ // 0 QSize(640, 480) 30 - 30 Format_YUYV // 1 QSize(160, 120) 30 - 30 Format_YUYV // 2 QSize(176, 144) 30 - 30 Format_YUYV // 3 QSize(320, 176) 30 - 30 Format_YUYV // 4 QSize(320, 240) 30 - 30 Format_YUYV // 5 QSize(432, 240) 30 - 30 Format_YUYV // 6 QSize(352, 288) 30 - 30 Format_YUYV // 7 QSize(544, 288) 30 - 30 Format_YUYV // 8 QSize(640, 360) 30 - 30 Format_YUYV // 9 QSize(752, 416) 24 - 24 Format_YUYV // 10 QSize(800, 448) 24 - 24 Format_YUYV // 11 QSize(864, 480) 20 - 20 Format_YUYV // 12 QSize(960, 544) 20 - 20 Format_YUYV // 13 QSize(1024, 576) 10 - 10 Format_YUYV // 14 QSize(800, 600) 20 - 20 Format_YUYV // 15 QSize(1184, 656) 10 - 10 Format_YUYV // 16 QSize(960, 720) 15 - 15 Format_YUYV // 17 QSize(1280, 720) 10 - 10 Format_YUYV // 18 QSize(1392, 768) 7.5 - 7.5 Format_YUYV // 19 QSize(1504, 832) 5 - 5 Format_YUYV // 20 QSize(1600, 896) 5 - 5 Format_YUYV // 21 QSize(1280, 960) 5 - 5 Format_YUYV // 22 QSize(1712, 960) 5 - 5 Format_YUYV // 23 QSize(1792, 1008) 5 - 5 Format_YUYV // 24 QSize(1920, 1080) 2 - 2 Format_YUYV // 25 QSize(1600, 1200) 2 - 2 Format_YUYV // 26 QSize(2048, 1536) 2 - 2 Format_YUYV // 27 QSize(2592, 1944) 2 - 2 Format_YUYV // 28 QSize(640, 480) 60 - 60 Format_Jpeg // 29 QSize(160, 120) 30 - 30 Format_Jpeg // 30 QSize(176, 144) 30 - 30 Format_Jpeg // 31 QSize(320, 176) 30 - 30 Format_Jpeg // 32 QSize(320, 240) 60 - 60 Format_Jpeg // 33 QSize(432, 240) 30 - 30 Format_Jpeg // 34 QSize(352, 288) 30 - 30 Format_Jpeg // 35 QSize(544, 288) 30 - 30 Format_Jpeg // 36 QSize(640, 360) 60 - 60 Format_Jpeg // 37 QSize(752, 416) 30 - 30 Format_Jpeg // 38 QSize(800, 448) 30 - 30 Format_Jpeg // 39 QSize(864, 480) 30 - 30 Format_Jpeg // 40 QSize(960, 544) 30 - 30 Format_Jpeg // 41 QSize(1024, 576) 30 - 30 Format_Jpeg // 42 QSize(800, 600) 30 - 30 Format_Jpeg // 43 QSize(1184, 656) 30 - 30 Format_Jpeg // 44 QSize(960, 720) 30 - 30 Format_Jpeg // 45 QSize(1280, 720) 30 - 30 Format_Jpeg // 46 QSize(1392, 768) 15 - 15 Format_Jpeg // 47 QSize(1504, 832) 15 - 15 Format_Jpeg // 48 QSize(1600, 896) 15 - 15 Format_Jpeg // 49 QSize(1280, 960) 15 - 15 Format_Jpeg // 50 QSize(1712, 960) 15 - 15 Format_Jpeg // 51 QSize(1792, 1008) 15 - 15 Format_Jpeg // 52 QSize(1920, 1080) 30 - 30 Format_Jpeg // 53 QSize(1600, 1200) 15 - 15 Format_Jpeg // 54 QSize(2048, 1536) 15 - 15 Format_Jpeg // 55 QSize(2592, 1944) 10 - 10 Format_Jpeg #include "opencv_capture.h" #include "common.h" #include "ffi.h" #include "Renderer.h" #include #include #include #ifdef _IS_ANDROID_ #include "EGL/eglext.h" #include "GLES3/gl3.h" #include // for usleep #endif #ifdef _IS_LINUX_ #include #endif #ifdef _IS_WIN_ #include #endif // for testing open file in android #include #include #include OpenCVCapture::OpenCVCapture() : message(MSG_CAMERA_NONE), cameraThreadRunning(false) { } OpenCVCapture::~OpenCVCapture() { if (cameraThreadRunning) stop(); } bool OpenCVCapture::open(const std::string& uniformName, const std::string& completeFilePath, int *width, int *height) { // webCam on Android seems not to work. Probably ffmpeg is needed by OpenCV also // to speed up video files // https://docs.opencv.org/3.4/d4/d15/group__videoio__flags__base.html int apiCamPreference = 0; int apiFilePreference = 0; #ifdef _IS_ANDROID_ apiCamPreference = cv::CAP_ANDROID; #endif #ifdef _IS_LINUX_ apiCamPreference = cv::CAP_V4L2; #endif #ifdef _IS_WIN_ apiCamPreference = cv::CAP_DSHOW; #endif #ifdef _IS_ANDROID_ apiFilePreference = cv::CAP_ANDROID; #endif #ifdef _IS_LINUX_ apiFilePreference = cv::CAP_ANY; #endif #ifdef _IS_WIN_ apiFilePreference = cv::CAP_MSMF; #endif if (completeFilePath == "cam0") cap.open(0, apiCamPreference); else if (completeFilePath == "cam1") cap.open(1, apiCamPreference); else cap.open(completeFilePath, apiFilePreference); // cap.set(cv::CAP_PROP_FRAME_WIDTH, 640); // cap.set(cv::CAP_PROP_FRAME_HEIGHT, 480); if (!cap.isOpened()) { LOGD("OCV CAPTURE", "ERROR! Unable to open VideoCapture"); return false; } // silence log! cv::utils::logging::setLogLevel(cv::utils::logging::LogLevel::LOG_LEVEL_ERROR); *width = this->width = (int)cap.get(cv::CAP_PROP_FRAME_WIDTH); *height = this->height = (int)cap.get(cv::CAP_PROP_FRAME_HEIGHT); this->uniformName = std::move(uniformName); fps = (int)cap.get(cv::CAP_PROP_FPS); if (fps == 0) fps = 30; frameDuration = 1000000.0 / fps; // Set the capture mode to BGR // https://docs.opencv.org/3.4/d4/d15/group__videoio__flags__base.html#gad0f42b32af0d89d2cee80dae0ea62b3d cap.set(cv::CAP_PROP_MODE, 1); return true; } cv::Mat OpenCVCapture::getNewFrame() { cap.read(frame); cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB); return frame; } void OpenCVCapture::stop() { if (!cameraThreadRunning) { LOGD("OCV CAPTURE", "ERROR! Capture thread already stopped!"); if (cap.isOpened()) cap.release(); return; } message = MSG_CAMERA_STOP; while (isCameraThreadRunning()); } void OpenCVCapture::start(Sampler2D *sampler) { if (cameraThreadRunning) { LOGD("OCV CAPTURE", "ERROR! Capture thread already running!"); return; } LOGD("OCV CAPTURE", "Starting capture thread!"); std::thread camera_thread([](OpenCVCapture *me, Sampler2D *sampler) { Renderer *renderer = getRenderer(); me->cameraThreadRunning = true; auto start = std::chrono::steady_clock::now(); auto end = std::chrono::steady_clock::now(); int64_t elapsed; for (;;) { if (me->message == MSG_CAMERA_STOP) { me->cap.release(); me->cameraThreadRunning = false; me->message = MSG_CAMERA_NONE; LOGD("OCV CAPTURE", "Stopping capture thread!"); return; } me->cap.read(me->frame); if (me->frame.empty()) continue; #ifdef _IS_ANDROID_ cv::cvtColor(me->frame, me->frame, cv::COLOR_RGB2RGBA); #endif #if defined _IS_LINUX_ || defined _IS_WIN_ cv::cvtColor(me->frame, me->frame, cv::COLOR_BGR2RGBA); #endif cv::flip(me->frame, me->frame,0); end = std::chrono::steady_clock::now(); elapsed = std::chrono::duration_cast(end - start).count(); if (me->frameDuration > elapsed) std::this_thread::sleep_for(std::chrono::microseconds((int)(me->frameDuration - elapsed))); // usleep(me->frameDuration - elapsed); renderer = getRenderer(); if (renderer != nullptr) { if (!me->frame.empty() && elapsed >= me->frameDuration) { sampler->replaceTexture(me->width, me->height, me->frame.clone().data ); getRenderer()->setTextureMsg(*sampler); start = std::chrono::steady_clock::now(); } } else me->message = MSG_CAMERA_NONE; } }, this, sampler); camera_thread.detach(); } cv::Mat OpenCVCapture::getCurrentMatFrame() { if (!cameraThreadRunning || message != MSG_CAMERA_NONE) return cv::Mat(); return frame; } ================================================ FILE: src/opencv_capture.h ================================================ #ifndef OPENCV_CAPTURE_H #define OPENCV_CAPTURE_H #include "Sampler2D.h" #include #include #include #include #include #include enum CameraMsg { MSG_CAMERA_NONE, MSG_CAMERA_STOP, MSG_CAMERA_GET_MAT_FRAME }; class OpenCVCapture { public: OpenCVCapture(); ~OpenCVCapture(); bool open(const std::string& uniformName, const std::string& completeFilePath, int *width, int *height); cv::Mat getNewFrame(); void start(Sampler2D *sampler); void stop(); cv::Mat getCurrentMatFrame(); inline bool isCameraThreadRunning() { return cameraThreadRunning; } inline std::string getUniformName() { return uniformName; } std::atomic message; private: cv::Mat frame; bool cameraThreadRunning; cv::VideoCapture cap; int width; int height; std::string uniformName; double fps; double frameDuration; }; #endif //OPENCV_CAPTURE_H ================================================ FILE: src/uniformQueue.cpp ================================================ #include "uniformQueue.h" #include "Shader.h" #include "ffi.h" #include #include // for setw #include #include // #ifdef _IS_WIN_ // #define std::any_cast(reinterpret_cast(X) // #else // // if doesn't compile, update visual studio // // https://developercommunity.visualstudio.com/t/stdany-doesnt-link-when-exceptions-are-disabled/376072 // #define CAST( any_cast(X) // #endif GLuint UniformQueue::programObject = 0; UniformQueue::UniformQueue() { } UniformQueue::~UniformQueue() { // delete all Sampler2D textures for (auto &[name, uniform]: uniforms) { const std::type_info &t = uniforms[name].type(); if (t == typeid(UNIFORM_SAMPLER2D_t)) { Sampler2D &sampler = std::any_cast(uniform).val; glDeleteTextures(1, &sampler.texture_index); } } } void UniformQueue::debug(const std::string &name) { auto uniform = uniforms[name]; const std::type_info &t = uniforms[name].type(); if (t == typeid(UNIFORM_BOOL_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "bool: " << std::left << std::setw(10) << std::any_cast(uniform).val << std::endl; } else if (t == typeid(UNIFORM_INT_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "int: " << std::left << std::setw(10) << std::any_cast(uniform).val << std::endl; } else if (t == typeid(UNIFORM_FLOAT_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "float: " << std::left << std::setw(10) << std::any_cast(uniform).val << std::endl; } else if (t == typeid(UNIFORM_VEC2_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "vec2: " << std::left << std::setw(10) << std::any_cast(uniform).val.x << " " << std::left << std::setw(10) << std::any_cast(uniform).val.y << std::endl; } else if (t == typeid(UNIFORM_VEC3_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "vec3: " << std::left << std::setw(10) << std::any_cast(uniform).val.x << " " << std::left << std::setw(10) << std::any_cast(uniform).val.y << " " << std::left << std::setw(10) << std::any_cast(uniform).val.z << std::endl; } else if (t == typeid(UNIFORM_VEC4_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "vec4: " << std::left << std::setw(10) << std::any_cast(uniform).val.x << " " << std::left << std::setw(10) << std::any_cast(uniform).val.y << " " << std::left << std::setw(10) << std::any_cast(uniform).val.z << " " << std::left << std::setw(10) << std::any_cast(uniform).val.w << std::endl; } else if (t == typeid(UNIFORM_MAT2_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "mat2: " << std::left << std::setw(10) << std::any_cast(uniform).val[0][0] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[0][1] << " " << std::endl << std::left << std::setw(10) << std::any_cast(uniform).val[1][0] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[1][1] << std::endl; } else if (t == typeid(UNIFORM_MAT3_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "mat3: " << std::left << std::setw(10) << std::any_cast(uniform).val[0][0] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[0][1] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[0][2] << " " << std::endl << std::left << std::setw(10) << std::any_cast(uniform).val[1][0] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[1][1] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[1][2] << " " << std::endl << std::left << std::setw(10) << std::any_cast(uniform).val[2][0] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[2][1] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[2][2] << std::endl; } else if (t == typeid(UNIFORM_MAT4_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "mat4: " << std::left << std::setw(10) << std::any_cast(uniform).val[0][0] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[0][1] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[0][2] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[0][3] << " " << std::endl << std::left << std::setw(10) << std::any_cast(uniform).val[1][0] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[1][1] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[1][2] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[1][3] << " " << std::endl << std::left << std::setw(10) << std::any_cast(uniform).val[2][0] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[2][1] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[2][2] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[2][3] << " " << std::endl << std::left << std::setw(10) << std::any_cast(uniform).val[3][0] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[3][1] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[3][2] << " " << std::left << std::setw(10) << std::any_cast(uniform).val[3][3] << std::endl; } else if (t == typeid(UNIFORM_SAMPLER2D_t)) { std::cout << std::left << std::setw(15) << name << std::left << std::setw(7) << "Sampler2D: " << std::left << std::setw(4) << std::any_cast(uniform).val.width << " x " << std::any_cast(uniform).val.height << " texture index: " << std::left << std::setw(6) << std::any_cast(uniform).val.texture_index << " N texture: " << std::any_cast(uniform).val.nTexture << std::endl; } } // Add a uniform to the shader bool UniformQueue::addUniform(std::string name, UniformType type, void *val) { // check if the uniform already exists if (/*type != UNIFORM_SAMPLER2D && */uniforms.find(name) != uniforms.end()) { std::cout << "Uniform \"" << name << "\" already exists!" << std::endl; return false; } std::cout << "ADD " << name << std::endl; switch (type) { case UNIFORM_BOOL: { bool f = *(bool *) val; uniforms.emplace(name, UNIFORM_BOOL_t(UNIFORM_BOOL, f)); setUniformValue(name, val); break; } case UNIFORM_INT: { int f = *(int *) val; uniforms.emplace(name, UNIFORM_INT_t(UNIFORM_INT, f)); setUniformValue(name, val); break; } case UNIFORM_FLOAT: { float f = *(float *) val; uniforms.emplace(name, UNIFORM_FLOAT_t(UNIFORM_FLOAT, f)); setUniformValue(name, val); break; } case UNIFORM_VEC2: { glm::vec2 f = *(glm::vec2 *) val; uniforms.emplace(name, UNIFORM_VEC2_t(UNIFORM_VEC2, f)); setUniformValue(name, val); break; } case UNIFORM_VEC3: { glm::vec3 f = *(glm::vec3 *) val; uniforms.emplace(name, UNIFORM_VEC3_t(UNIFORM_VEC3, f)); setUniformValue(name, val); break; } case UNIFORM_VEC4: { glm::vec4 f = *(glm::vec4 *) val; uniforms.emplace(name, UNIFORM_VEC4_t(UNIFORM_VEC4, f)); setUniformValue(name, val); break; } case UNIFORM_MAT2: { glm::mat2 f = *(glm::mat2 *) val; uniforms.emplace(name, UNIFORM_MAT2_t(UNIFORM_MAT2, f)); setUniformValue(name, val); break; } case UNIFORM_MAT3: { glm::mat3 f = *(glm::mat3 *) val; uniforms.emplace(name, UNIFORM_MAT3_t(UNIFORM_MAT3, f)); setUniformValue(name, val); break; } case UNIFORM_MAT4: { glm::mat4 f = *(glm::mat4 *) val; uniforms.emplace(name, UNIFORM_MAT4_t(UNIFORM_MAT4, f)); setUniformValue(name, val); break; } case UNIFORM_SAMPLER2D: { const Sampler2D f = *(Sampler2D*)(val); uniforms.emplace(name, UNIFORM_SAMPLER2D_t(UNIFORM_SAMPLER2D, f)); break; } } return true; } // Remove the uniform with name [name] bool UniformQueue::removeUniform(const std::string &name) { // check if the uniform already exists if (uniforms.find(name) == uniforms.end()) { std::cout << "Uniform \"" << name << "\" doesn't exists!" << std::endl; return false; } if (uniforms[name].type() == typeid(UNIFORM_SAMPLER2D_t)) { Sampler2D &f = std::any_cast(uniforms[name]).val; if (getRenderer() != nullptr && getRenderer()->isLooping()) getRenderer()->deleteTextureMsg(f.texture_index); else glDeleteTextures(1, &f.texture_index); } uniforms.erase(uniforms.find(name)); return true; } // Set new value to an existing uniform bool UniformQueue::setUniformValue(const std::string &name, void *val) { bool found = false; const std::type_info &t = uniforms[name].type(); if (t == typeid(UNIFORM_BOOL_t)) { float f = *(float *) val; std::any_cast(uniforms[name]).val = f; found = true; } else if (t == typeid(UNIFORM_INT_t)) { float f = *(float *) val; std::any_cast(uniforms[name]).val = f; found = true; } else if (t == typeid(UNIFORM_FLOAT_t)) { float f = *(float *) val; std::any_cast(uniforms[name]).val = f; found = true; } else if (t == typeid(UNIFORM_VEC2_t)) { glm::vec2 f = *(glm::vec2 *) val; std::any_cast(uniforms[name]).val = f; found = true; } else if (t == typeid(UNIFORM_VEC3_t)) { glm::vec3 f = *(glm::vec3 *) val; std::any_cast(uniforms[name]).val = f; found = true; } else if (t == typeid(UNIFORM_VEC4_t)) { glm::vec4 f = *(glm::vec4 *) val; std::any_cast(uniforms[name]).val = f; found = true; } else if (t == typeid(UNIFORM_MAT2_t)) { glm::mat2 f = *(glm::mat2 *) val; std::any_cast(uniforms[name]).val = f; found = true; } else if (t == typeid(UNIFORM_MAT3_t)) { glm::mat3 f = *(glm::mat3 *) val; std::any_cast(uniforms[name]).val = f; found = true; } else if (t == typeid(UNIFORM_MAT4_t)) { glm::mat4 f = *(glm::mat4 *) val; std::any_cast(uniforms[name]).val = f; found = true; } else if (t == typeid(UNIFORM_SAMPLER2D_t)) { std::cout << "UPDATE Sampler2D " << name << std::endl; Sampler2D &f = std::any_cast(uniforms[name]).val; f.add_RGBA32(f.width, f.height, (unsigned char *) val); if (getRenderer() != nullptr && getRenderer()->isLooping()) getRenderer()->setNewTextureMsg(); found = true; } else { std::cout << "Uniform \"" << name << "\" not found!" << std::endl; } return found; } void UniformQueue::sendAllUniforms() { for (auto &[name, uniform]: uniforms) { const std::type_info &t = uniforms[name].type(); if (t == typeid(UNIFORM_BOOL_t)) { setBool(name, programObject, std::any_cast(uniform).val); } else if (t == typeid(UNIFORM_INT_t)) { setInt(name, programObject, std::any_cast(uniform).val); } else if (t == typeid(UNIFORM_FLOAT_t)) { setFloat(name, programObject, std::any_cast(uniform).val); } else if (t == typeid(UNIFORM_VEC2_t)) { setVec2(name, programObject, std::any_cast(uniform).val); } else if (t == typeid(UNIFORM_VEC3_t)) { setVec3(name, programObject, std::any_cast(uniform).val); } else if (t == typeid(UNIFORM_VEC4_t)) { setVec4(name, programObject, std::any_cast(uniform).val); } else if (t == typeid(UNIFORM_MAT2_t)) { setMat2(name, programObject, std::any_cast(uniform).val); } else if (t == typeid(UNIFORM_MAT3_t)) { setMat3(name, programObject, std::any_cast(uniform).val); } else if (t == typeid(UNIFORM_MAT4_t)) { setMat4(name, programObject, std::any_cast(uniform).val); } else if (t == typeid(UNIFORM_SAMPLER2D_t)) { Sampler2D &sampler = std::any_cast(uniform).val; if (sampler.nTexture != -1) setSampler2D(name, programObject, sampler); // debug(name); } } } // Called once when a new texture is set. Could be from Shader::initShader() // or from Renderer loop with MSG_NEW_TEXTURE message void UniformQueue::setAllSampler2D() { // make a vector to store all th nTexture number already used std::vector nTextures; for (auto &[name, uniform]: uniforms) { const std::type_info &t = uniforms[name].type(); if (t == typeid(UNIFORM_SAMPLER2D_t)) { Sampler2D sampler = std::any_cast(uniform).val; nTextures.push_back(sampler.nTexture); } } int n = 0; for (auto &[name, uniform]: uniforms) { const std::type_info &t = uniforms[name].type(); if (t == typeid(UNIFORM_SAMPLER2D_t)) { Sampler2D &sampler = std::any_cast(uniform).val; if (!sampler.data.empty()) { // Find a new [nTexture] if not already set // If it is already set the new sampler.data is given to replace the existing if (sampler.nTexture == -1) { while ( n < 32 && std::find(nTextures.begin(), nTextures.end(), n) != nTextures.end() ) n++; } else n = sampler.nTexture; if (n < 32) { // std::cout << "setAllSampler2D " << name << " nTexture: " << n << " size: " << sampler.width << "x" << sampler.height << std::endl; sampler.genTexture(n); setSampler2D(name, programObject, sampler); nTextures.push_back(n); // debug(name); } } } } } bool UniformQueue::replaceSampler2D(const std::string &name, int w, int h, unsigned char *rawData) { // check if the uniform already exists if (uniforms.find(name) == uniforms.end()) { LOGD("UNIFORMQUEUE", "Uniform ", name.c_str(), " doesn't exists!"); return false; } const std::type_info &t = uniforms[name].type(); if (t == typeid(UNIFORM_SAMPLER2D_t)) { Sampler2D &sampler = std::any_cast(uniforms[name]).val; LOGD("UNIFORMQUEUE", "replaceSampler2D ", name.c_str()); sampler.replaceTexture(w, h, rawData); return true; } return false; } Sampler2D *UniformQueue::getSampler2D(const std::string &name) { if (uniforms.find(name) == uniforms.end()) { std::cout << "Uniform \"" << name << "\" doesn't exists!" << std::endl; return nullptr; } const std::type_info &t = uniforms[name].type(); if (t == typeid(UNIFORM_SAMPLER2D_t)) { return &std::any_cast(uniforms[name]).val; } std::cout << "Uniform \"" << name << "\" is not a Sampler2D!" << std::endl; return nullptr; } // ------------------------------------------------------------------------ void UniformQueue::setBool(const std::string &name, GLuint po, bool value) { glUniform1i(glGetUniformLocation(po, name.c_str()), (int) value); } // ------------------------------------------------------------------------ void UniformQueue::setInt(const std::string &name, GLuint po, int value) { glUniform1i(glGetUniformLocation(po, name.c_str()), value); } // ------------------------------------------------------------------------ void UniformQueue::setFloat(const std::string &name, GLuint po, float value) { glUniform1f(glGetUniformLocation(po, name.c_str()), value); } // ------------------------------------------------------------------------ void UniformQueue::setVec2(const std::string &name, GLuint po, const glm::vec2 &value) { glUniform2fv(glGetUniformLocation(po, name.c_str()), 1, &value[0]); } void UniformQueue::setVec2(const std::string &name, GLuint po, float x, float y) { glUniform2f(glGetUniformLocation(po, name.c_str()), x, y); } // ------------------------------------------------------------------------ void UniformQueue::setVec3(const std::string &name, GLuint po, const glm::vec3 &value) { glUniform3fv(glGetUniformLocation(po, name.c_str()), 1, &value[0]); } void UniformQueue::setVec3(const std::string &name, GLuint po, float x, float y, float z) { glUniform3f(glGetUniformLocation(po, name.c_str()), x, y, z); } // ------------------------------------------------------------------------ void UniformQueue::setVec4(const std::string &name, GLuint po, const glm::vec4 &value) { glUniform4fv(glGetUniformLocation(po, name.c_str()), 1, &value[0]); } void UniformQueue::setVec4(const std::string &name, GLuint po, float x, float y, float z, float w) { glUniform4f(glGetUniformLocation(po, name.c_str()), x, y, z, w); } // ------------------------------------------------------------------------ void UniformQueue::setMat2(const std::string &name, GLuint po, const glm::mat2 &mat) { glUniformMatrix2fv(glGetUniformLocation(po, name.c_str()), 1, GL_FALSE, &mat[0][0]); } // ------------------------------------------------------------------------ void UniformQueue::setMat3(const std::string &name, GLuint po, const glm::mat3 &mat) { glUniformMatrix3fv(glGetUniformLocation(po, name.c_str()), 1, GL_FALSE, &mat[0][0]); } // ------------------------------------------------------------------------ void UniformQueue::setMat4(const std::string &name, GLuint po, const glm::mat4 &mat) { glUniformMatrix4fv(glGetUniformLocation(po, name.c_str()), 1, GL_FALSE, &mat[0][0]); } // ------------------------------------------------------------------------ void UniformQueue::setSampler2D(const std::string &name, GLuint po, Sampler2D &data) { glActiveTexture(GL_TEXTURE0 + data.nTexture); glBindTexture(GL_TEXTURE_2D, data.texture_index); glUniform1i( glGetUniformLocation(po, name.c_str()), data.nTexture ); } ================================================ FILE: src/uniformQueue.h ================================================ #ifndef UNIFORM_QUEUE_H #define UNIFORM_QUEUE_H #include "common.h" #include "Sampler2D.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef _IS_ANDROID_ #include #include "GLES3/gl3.h" #include "glm.hpp" #endif #ifdef _IS_LINUX_ #include #include #include #endif #ifdef _IS_WIN_ #include #include #include #include #endif typedef enum { UNIFORM_BOOL, UNIFORM_INT, UNIFORM_FLOAT, UNIFORM_VEC2, UNIFORM_VEC3, UNIFORM_VEC4, UNIFORM_MAT2, UNIFORM_MAT3, UNIFORM_MAT4, UNIFORM_SAMPLER2D } UniformType; class UniformQueue { public: UniformQueue(); ~UniformQueue(); void debug(const std::string &name); void setProgram(GLuint po) { this->programObject = po; } bool addUniform(std::string name, UniformType type, void *val); bool removeUniform(const std::string &name); bool setUniformValue(const std::string &, void *val); void sendAllUniforms(); void setAllSampler2D(); bool replaceSampler2D(const std::string &name, int w, int h, unsigned char *rawData); void setBool(const std::string &name, GLuint po, bool value); void setInt(const std::string &name, GLuint po, int value); void setFloat(const std::string &name, GLuint po, float value); void setVec2(const std::string &name, GLuint po, const glm::vec2 &value); void setVec2(const std::string &name, GLuint po, float x, float y); void setVec3(const std::string &name, GLuint po, const glm::vec3 &value); void setVec3(const std::string &name, GLuint po, float x, float y, float z); void setVec4(const std::string &name, GLuint po, const glm::vec4 &value); void setVec4(const std::string &name, GLuint po, float x, float y, float z, float w); void setMat2(const std::string &name, GLuint po, const glm::mat2 &mat); void setMat3(const std::string &name, GLuint po, const glm::mat3 &mat); void setMat4(const std::string &name, GLuint po, const glm::mat4 &mat); void setSampler2D(const std::string &name, GLuint po, Sampler2D &data); Sampler2D *getSampler2D(const std::string &name); template struct UniformStruct { UniformType type; T val; UniformStruct(UniformType type, const T &data) : type(type), val(data) {}; }; typedef UniformStruct UNIFORM_BOOL_t; typedef UniformStruct UNIFORM_INT_t; typedef UniformStruct UNIFORM_FLOAT_t; typedef UniformStruct UNIFORM_VEC2_t; typedef UniformStruct UNIFORM_VEC3_t; typedef UniformStruct UNIFORM_VEC4_t; typedef UniformStruct UNIFORM_MAT2_t; typedef UniformStruct UNIFORM_MAT3_t; typedef UniformStruct UNIFORM_MAT4_t; typedef UniformStruct UNIFORM_SAMPLER2D_t; std::map uniforms; static GLuint programObject; }; #endif // UNIFORM_QUEUE_H ================================================ FILE: test/flutter_opengl_method_channel_test.dart ================================================ import 'package:flutter/services.dart'; import 'package:flutter_opengl/src/flutter_opengl_method_channel.dart'; import 'package:flutter_test/flutter_test.dart'; void main() { MethodChannelFlutterOpengl platform = MethodChannelFlutterOpengl(); const MethodChannel channel = MethodChannel('flutter_opengl_plugin'); TestWidgetsFlutterBinding.ensureInitialized(); setUp(() { channel.setMockMethodCallHandler((MethodCall methodCall) async { return '42'; }); }); tearDown(() { channel.setMockMethodCallHandler(null); }); } ================================================ FILE: test/flutter_opengl_test.dart ================================================ import 'package:flutter_opengl/src/flutter_opengl_method_channel.dart'; import 'package:flutter_opengl/src/flutter_opengl_platform_interface.dart'; import 'package:flutter_test/flutter_test.dart'; // class MockFlutterOpenglPlatform // with MockPlatformInterfaceMixin // implements FlutterOpenglPlatform { // // @override // Future getPlatformVersion() => Future.value('42'); // } void main() { final FlutterOpenglPlatform initialPlatform = FlutterOpenglPlatform.instance; test('$MethodChannelFlutterOpengl is the default instance', () { expect(initialPlatform, isInstanceOf()); }); // test('getPlatformVersion', () async { // FlutterOpengl flutterOpenglPlugin = FlutterOpengl(); // MockFlutterOpenglPlatform fakePlatform = MockFlutterOpenglPlatform(); // FlutterOpenglPlatform.instance = fakePlatform; // // expect(await flutterOpenglPlugin.getPlatformVersion(), '42'); // }); } ================================================ FILE: windows/.gitignore ================================================ flutter/ # Visual Studio user-specific files. *.suo *.user *.userosscache *.sln.docstates # Visual Studio build-related files. x64/ x86/ # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !*.[Cc]ache/ ================================================ FILE: windows/CMakeLists.txt ================================================ # The Flutter tooling requires that developers have a version of Visual Studio # installed that includes CMake 3.14 or later. You should not increase this # version, as doing so will cause the plugin to fail to compile for some # customers of the plugin. cmake_minimum_required(VERSION 3.14) # Project-level configuration. set(PROJECT_NAME "flutter_opengl") project(${PROJECT_NAME} LANGUAGES CXX) set(CMAKE_CXX_STANDARD 20) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) set(POWERVR ${CMAKE_CURRENT_LIST_DIR}/Native_SDK) set(GLEW ${CMAKE_CURRENT_LIST_DIR}/glew) set(GLM ${CMAKE_CURRENT_LIST_DIR}/glm) # This value is used when generating builds using this plugin, so it must # not be changed set(PLUGIN_NAME "flutter_opengl_plugin") # Any new source files that you add to the plugin should be added here. list(APPEND PLUGIN_SOURCES "flutter_opengl_plugin.cpp" "flutter_opengl_plugin.h" "fl_my_texture_gl.cc" ../src/common.h ../src/ffi.cpp ../src/Renderer.cpp ../src/Shader.cpp ../src/Sampler2D.cpp ../src/uniformQueue.cpp ../src/opencv_capture.cpp ) # Define the plugin library target. Its name must not be changed (see comment # on PLUGIN_NAME above). add_library(${PLUGIN_NAME} SHARED "include/flutter_opengl/flutter_opengl_plugin_c_api.h" "flutter_opengl_plugin_c_api.cpp" ${PLUGIN_SOURCES} ) # Apply a standard set of build settings that are configured in the # application-level CMakeLists.txt. This can be removed for plugins that want # full control over build settings. apply_standard_settings(${PLUGIN_NAME}) # Symbols are hidden by default to reduce the chance of accidental conflicts # between plugins. This should not be removed; any symbols that should be # exported should be explicitly exported with the FLUTTER_PLUGIN_EXPORT macro. set_target_properties(${PLUGIN_NAME} PROPERTIES CXX_VISIBILITY_PRESET hidden) target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL) # don't treat warnings as compile errors in this plugin. Itt will be removed target_compile_options(${PLUGIN_NAME} PRIVATE "/WX-") # Source include directories and library dependencies. Add any plugin-specific # dependencies here. target_include_directories(${PLUGIN_NAME} INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include") target_include_directories(${PLUGIN_NAME} PUBLIC "${POWERVR}/include" "${GLM}" "${GLEW}/include" "${OPENCV_INCLUDE_DIRS}" ) find_package(OpenGL REQUIRED) # set(OpenCV_DIR ${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/lib) find_package(OpenCV REQUIRED PATHS ${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/lib NO_DEFAULT_PATH) message(STATUS "*************************OpenCV_LIBS ${OpenCV_LIBS}") message(STATUS "*************************OpenCV_INCLUDE_DIRS ${OpenCV_INCLUDE_DIRS}") message(STATUS "*************************CONFIGURATIONS ${CONFIGURATIONS}") message(STATUS "*************************CMAKE_CONFIGURATION_TYPES ${CMAKE_CONFIGURATION_TYPES}") message(STATUS "*************************IS_MULTICONFIG ${IS_MULTICONFIG}") target_link_libraries(${PLUGIN_NAME} PRIVATE flutter flutter_wrapper_plugin OpenGL::GL "${POWERVR}/lib/Windows_x86_64/libEGL.lib" "${POWERVR}/lib/Windows_x86_64/libGLESv2.lib" "${GLEW}/lib/Release/x64/glew32.lib" "${GLEW}/lib/Release/x64/glew32s.lib" "${OpenCV_LIBS}" ) # import OpenCV debug or release lib target_link_libraries(${PLUGIN_NAME} PRIVATE optimized "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/lib/opencv_world470.lib" debug "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/lib/opencv_world470d.lib" ) # List of absolute paths to libraries that should be bundled with the plugin. # This list could contain prebuilt libraries, or libraries created by an # external build triggered from this build file. ## why openCV in debug mode doesn't work with release libs?? if(IS_MULTICONFIG) set(flutter_opengl_bundled_libraries "" "${POWERVR}/lib/Windows_x86_64/libEGL.dll" "${POWERVR}/lib/Windows_x86_64/libGLESv2.dll" "${GLEW}/bin/Release/x64/glew32.dll" "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/bin/opencv_world470.dll" "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/bin/opencv_videoio_msmf470_64.dll" "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/bin/opencv_world470d.dll" "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/bin/opencv_videoio_msmf470_64d.dll" PARENT_SCOPE ) elseif( CMAKE_BUILD_TYPE STREQUAL "Debug" ) set(flutter_opengl_bundled_libraries "" "${POWERVR}/lib/Windows_x86_64/libEGL.dll" "${POWERVR}/lib/Windows_x86_64/libGLESv2.dll" "${GLEW}/bin/Release/x64/glew32.dll" "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/bin/opencv_world470d.dll" "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/bin/opencv_videoio_msmf470_64d.dll" PARENT_SCOPE ) elseif( CMAKE_BUILD_TYPE STREQUAL "Release" ) set(flutter_opengl_bundled_libraries "" "${POWERVR}/lib/Windows_x86_64/libEGL.dll" "${POWERVR}/lib/Windows_x86_64/libGLESv2.dll" "${GLEW}/bin/Release/x64/glew32.dll" "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/bin/opencv_world470.dll" "${CMAKE_CURRENT_LIST_DIR}/../SCRIPTS/opencv/build/x64/vc16/bin/opencv_videoio_msmf470_64.dll" PARENT_SCOPE ) endif() ================================================ FILE: windows/fl_my_texture_gl.cc ================================================ #include "fl_my_texture_gl.h" FlMyTextureGL::FlMyTextureGL(flutter::TextureRegistrar *texture_registrar, int w, int h) : texture_registrar_(texture_registrar) { width = w; height = h; buffer = std::vector(width * height * 4 * 4); texture_ = std::make_unique( flutter::PixelBufferTexture( [=](size_t width, size_t height) -> const FlutterDesktopPixelBuffer * { const std::lock_guard lock(mutex_); return &flutter_pixel_buffer_; })); texture_id_ = texture_registrar_->RegisterTexture(texture_.get()); } void FlMyTextureGL::Update() { // const std::lock_guard lock(mutex_); flutter_pixel_buffer_.buffer = buffer.data(); flutter_pixel_buffer_.width = width; flutter_pixel_buffer_.height = height; texture_registrar_->MarkTextureFrameAvailable(texture_id_); } FlMyTextureGL::~FlMyTextureGL() { texture_registrar_->UnregisterTexture(texture_id_); buffer.clear(); // free(flutter_pixel_buffer_.release_context); } void FlMyTextureGL::SetReleaseCallback(void(* release_callback)(void* release_context)) { this->flutter_pixel_buffer_.release_callback = release_callback; } void FlMyTextureGL::SetReleaseContext(void* release_context) { this->flutter_pixel_buffer_.release_context = release_context; } ================================================ FILE: windows/fl_my_texture_gl.h ================================================ #ifndef FLUTTER_MY_TEXTURE_H #define FLUTTER_MY_TEXTURE_H #include #include #include #include class FlMyTextureGL { public: FlMyTextureGL(flutter::TextureRegistrar *texture_registrar, int w, int h); int64_t texture_id() const { return texture_id_; } void Update(); ~FlMyTextureGL(); void SetReleaseCallback(void (* release_callback)(void* release_context)); void SetReleaseContext(void *release_context); FlutterDesktopPixelBuffer flutter_pixel_buffer_{}; std::vector buffer; int32_t width; int32_t height; private: flutter::TextureRegistrar *texture_registrar_ = nullptr; std::unique_ptr texture_ = nullptr; int64_t texture_id_; mutable std::mutex mutex_; }; typedef struct { flutter::MethodChannel* channel; uint8_t* buffer; } user_release_context; #endif // FLUTTER_MY_TEXTURE_H ================================================ FILE: windows/flutter_opengl_plugin.cpp ================================================ #include "flutter_opengl_plugin.h" #include "../src/common.h" #include "../src/Shader.h" #include "fl_my_texture_gl.h" #include "../src/ffi.h" // This must be included before many other Windows headers. #include // For getPlatformVersion; remove unless needed for your plugin implementation. #include #include #include #include #include #include #include #include // #include // #include namespace flutter_opengl { GLint MySetPixelFormat() { // https://learn.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-choosepixelformat static PIXELFORMATDESCRIPTOR pfd= { sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd 1, // version number PFD_DRAW_TO_WINDOW | // support window PFD_SUPPORT_OPENGL | // support OpenGL PFD_DOUBLEBUFFER, // double buffered PFD_TYPE_RGBA, // RGBA type 24, // 24-bit color depth 0, 0, 0, 0, 0, 0, // color bits ignored 0, // no alpha buffer 0, // shift bit ignored 0, // no accumulation buffer 0, 0, 0, 0, // accum bits ignored 32, // 32-bit z-buffer 0, // no stencil buffer 0, // no auxiliary buffer PFD_MAIN_PLANE, // main layer 0, // reserved 0, 0, 0 // layer masks ignored }; GLint iPixelFormat; // get the device context's best, available pixel format match if((iPixelFormat = ChoosePixelFormat(ctx_f.hdc, &pfd)) == 0) { std::cout << "ChoosePixelFormat Failed" << std::endl; return 0; } // make that match the device context's current pixel format if(SetPixelFormat(ctx_f.hdc, iPixelFormat, &pfd) == FALSE) { std::cout << "SetPixelFormat Failed" << std::endl; return 0; } if((ctx_f.hrc = wglCreateContext(ctx_f.hdc)) == NULL) { std::cout << "wglCreateContext Failed" << std::endl; return 0; } if((wglMakeCurrent(ctx_f.hdc, ctx_f.hrc)) == NULL) { std::cout << "wglMakeCurrent Failed" << std::endl; return 0; } return 1; } void initGL() { ctx_f. m_hWnd = ctx_f.registrar->GetView()->GetNativeWindow(); // rendering context variable /* Get the handle of the windows device context. */ ctx_f.hdc = GetDC(ctx_f.m_hWnd); wglMakeCurrent(ctx_f.hdc, NULL); MySetPixelFormat(); // Initialize GL glewExperimental = GL_TRUE; GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ std::cout << "Error: " << glewGetErrorString(err) << std::endl; return; } } void FlutterOpenglPlugin::RegisterWithRegistrar( flutter::PluginRegistrarWindows *registrar) { auto channel = std::make_unique>( registrar->messenger(), "flutter_opengl_plugin", &flutter::StandardMethodCodec::GetInstance()); auto plugin = std::make_unique(); channel->SetMethodCallHandler( [plugin_pointer = plugin.get()](const auto &call, auto result) { plugin_pointer->HandleMethodCall(call, std::move(result)); }); ctx_f.registrar = registrar; ctx_f.texture_registrar = registrar->texture_registrar(); registrar->AddPlugin(std::move(plugin)); } FlutterOpenglPlugin::FlutterOpenglPlugin() {} FlutterOpenglPlugin::~FlutterOpenglPlugin() { deleteRenderer(); } std::vector buffer; void FlutterOpenglPlugin::HandleMethodCall( const flutter::MethodCall &method_call, std::unique_ptr> result) { if (method_call.method_name().compare("draw") == 0) { buffer.clear(); std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> distr(0, 255); for (int i = 0; i < ctx_f.height * ctx_f.width * 4; ++i) { buffer.push_back( distr(gen) ); } bool b = wglMakeCurrent(ctx_f.hdc, ctx_f.hrc); eglPrintError("glGenTextures"); glBindTexture(GL_TEXTURE_2D, ctx_f.texture_name); eglPrintError("glBindTexture"); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ctx_f.width, ctx_f.height, 0, GL_BGR, GL_UNSIGNED_BYTE, buffer.data()); eglPrintError("glTexImage2D"); SwapBuffers( ctx_f.hdc ); // ctx_f.myTexture->Update(buffer.data(), ctx_f.height, ctx_f.width); ctx_f.texture_registrar->MarkTextureFrameAvailable(ctx_f.texture_id); result->Success( flutter::EncodableValue(true) ); } else if (method_call.method_name().compare("createSurface") == 0) { flutter::EncodableMap arguments = std::get(*method_call.arguments()); // initGL(); // bool b = wglMakeCurrent(ctx_f.hdc, ctx_f.hrc); // glGenTextures(1, &ctx_f.texture_name); // eglPrintError("glGenTextures"); // glBindTexture(GL_TEXTURE_2D, ctx_f.texture_name); createRenderer(&ctx_f); ctx_f.width = std::get(arguments[flutter::EncodableValue("width")]); ctx_f.height = std::get(arguments[flutter::EncodableValue("height")]); ctx_f.m_hWnd = ctx_f.registrar->GetView()->GetNativeWindow(); if (ctx_f.myTexture != nullptr) { delete ctx_f.myTexture; ctx_f.myTexture = nullptr; } ctx_f.myTexture = new FlMyTextureGL(ctx_f.texture_registrar, ctx_f.width, ctx_f.height); ctx_f.texture_id = ctx_f.myTexture->texture_id(); result->Success( flutter::EncodableValue(ctx_f.texture_id) ); } else { result->NotImplemented(); } } } // namespace flutter_opengl ================================================ FILE: windows/flutter_opengl_plugin.h ================================================ #ifndef FLUTTER_PLUGIN_FLUTTER_OPENGL_PLUGIN_H_ #define FLUTTER_PLUGIN_FLUTTER_OPENGL_PLUGIN_H_ #include #include #include namespace flutter_opengl { class FlutterOpenglPlugin : public flutter::Plugin { public: static void RegisterWithRegistrar(flutter::PluginRegistrarWindows *registrar); FlutterOpenglPlugin(); virtual ~FlutterOpenglPlugin(); // Disallow copy and assign. FlutterOpenglPlugin(const FlutterOpenglPlugin&) = delete; FlutterOpenglPlugin& operator=(const FlutterOpenglPlugin&) = delete; private: // Called when a method is called on this plugin's channel from Dart. void HandleMethodCall( const flutter::MethodCall &method_call, std::unique_ptr> result); }; } // namespace flutter_opengl #endif // FLUTTER_PLUGIN_FLUTTER_OPENGL_PLUGIN_H_ ================================================ FILE: windows/flutter_opengl_plugin_c_api.cpp ================================================ #include "include/flutter_opengl/flutter_opengl_plugin_c_api.h" #include #include "flutter_opengl_plugin.h" void FlutterOpenglPluginCApiRegisterWithRegistrar( FlutterDesktopPluginRegistrarRef registrar) { flutter_opengl::FlutterOpenglPlugin::RegisterWithRegistrar( flutter::PluginRegistrarManager::GetInstance() ->GetRegistrar(registrar)); } ================================================ FILE: windows/include/flutter_opengl/flutter_opengl_plugin_c_api.h ================================================ #ifndef FLUTTER_PLUGIN_FLUTTER_OPENGL_PLUGIN_C_API_H_ #define FLUTTER_PLUGIN_FLUTTER_OPENGL_PLUGIN_C_API_H_ #include #ifdef FLUTTER_PLUGIN_IMPL #define FLUTTER_PLUGIN_EXPORT __declspec(dllexport) #else #define FLUTTER_PLUGIN_EXPORT __declspec(dllimport) #endif #if defined(__cplusplus) extern "C" { #endif FLUTTER_PLUGIN_EXPORT void FlutterOpenglPluginCApiRegisterWithRegistrar( FlutterDesktopPluginRegistrarRef registrar); #if defined(__cplusplus) } // extern "C" #endif #endif // FLUTTER_PLUGIN_FLUTTER_OPENGL_PLUGIN_C_API_H_