├── .gitignore ├── Examples ├── Components │ ├── Bounds.h │ └── Transforms.h ├── GameContext.cpp ├── GameContext.h ├── GameGroup.cpp ├── GameGroup.h ├── TransformUtils.cpp ├── TransformUtils.h ├── Utils.cpp └── Utils.h ├── GTests ├── ExampleTests.cpp ├── GTests.sln ├── GTests.vcxproj ├── GTests.vcxproj.filters ├── UnitTests.cpp ├── packages.config └── packages │ └── Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0 │ ├── Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0.nupkg │ ├── ThirdPartyNotices.txt │ ├── build │ └── native │ │ ├── Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.propertiesui.xml │ │ ├── Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.targets │ │ └── include │ │ └── gtest │ │ ├── gtest-death-test.h │ │ ├── gtest-message.h │ │ ├── gtest-param-test.h │ │ ├── gtest-param-test.h.pump │ │ ├── gtest-printers.h │ │ ├── gtest-spi.h │ │ ├── gtest-test-part.h │ │ ├── gtest-typed-test.h │ │ ├── gtest.h │ │ ├── gtest_pred_impl.h │ │ ├── gtest_prod.h │ │ └── internal │ │ ├── custom │ │ ├── gtest-port.h │ │ ├── gtest-printers.h │ │ └── gtest.h │ │ ├── gtest-death-test-internal.h │ │ ├── gtest-filepath.h │ │ ├── gtest-internal.h │ │ ├── gtest-linked_ptr.h │ │ ├── gtest-param-util-generated.h │ │ ├── gtest-param-util-generated.h.pump │ │ ├── gtest-param-util.h │ │ ├── gtest-port-arch.h │ │ ├── gtest-port.h │ │ ├── gtest-string.h │ │ ├── gtest-tuple.h │ │ ├── gtest-tuple.h.pump │ │ ├── gtest-type-util.h │ │ └── gtest-type-util.h.pump │ ├── lib │ └── native │ │ └── v140 │ │ └── windesktop │ │ └── msvcstl │ │ └── static │ │ └── rt-dyn │ │ ├── x64 │ │ ├── Debug │ │ │ ├── gtest.lib │ │ │ ├── gtest.pdb │ │ │ ├── gtest_main.lib │ │ │ └── gtest_main.pdb │ │ └── Release │ │ │ ├── gtest.lib │ │ │ ├── gtest.pdb │ │ │ ├── gtest_main.lib │ │ │ └── gtest_main.pdb │ │ └── x86 │ │ ├── Debug │ │ ├── gtest.lib │ │ ├── gtest.pdb │ │ ├── gtest_main.lib │ │ └── gtest_main.pdb │ │ └── Release │ │ ├── gtest.lib │ │ ├── gtest.pdb │ │ ├── gtest_main.lib │ │ └── gtest_main.pdb │ └── license (MIT).txt ├── Images ├── RunTest1.png └── RunTest2.png ├── LICENSE ├── Lib ├── Common.h ├── ECS.cpp ├── ECS.h └── ECSIter.h ├── OldTests ├── BitArray.h ├── Common.h ├── ECS.sln ├── ECS.vcxproj ├── ECS.vcxproj.filters ├── EntityManager.cpp ├── EntityManager.h └── main.cpp ├── README.md └── RunTest ├── Framework3 ├── Audio │ ├── Audio.cpp │ ├── Audio.h │ ├── al.h │ ├── alc.h │ ├── alut.h │ ├── codec.h │ ├── ogg.h │ ├── os_types.h │ └── vorbisfile.h ├── BaseApp.cpp ├── BaseApp.h ├── CPU.cpp ├── CPU.h ├── Config.cpp ├── Config.h ├── Direct3D │ ├── D3DApp.cpp │ ├── D3DApp.h │ ├── Direct3DRenderer.cpp │ └── Direct3DRenderer.h ├── Direct3D10 │ ├── D3D10App.cpp │ ├── D3D10App.h │ ├── Direct3D10Renderer.cpp │ └── Direct3D10Renderer.h ├── GUI │ ├── Button.cpp │ ├── Button.h │ ├── CheckBox.cpp │ ├── CheckBox.h │ ├── Dialog.cpp │ ├── Dialog.h │ ├── DropDownList.cpp │ ├── DropDownList.h │ ├── Label.cpp │ ├── Label.h │ ├── Slider.cpp │ ├── Slider.h │ ├── Widget.cpp │ └── Widget.h ├── Imaging │ ├── Image.cpp │ ├── Image.h │ ├── jconfig.h │ ├── jmorecfg.h │ ├── jpeglib.h │ ├── png.h │ ├── pngconf.h │ ├── zconf.h │ └── zlib.h ├── Libs │ ├── ALut.lib │ ├── OpenAL32.lib │ ├── libjpeg.lib │ ├── libpng.lib │ ├── ogg_static.lib │ ├── vorbis_static.lib │ ├── vorbisfile_static.lib │ └── zlib.lib ├── Linux │ └── LinuxBase.cpp ├── Mac │ └── MacBase.cpp ├── Math │ ├── Frustum.cpp │ ├── Frustum.h │ ├── MathTools.cpp │ ├── MathTools.h │ ├── MyMath.h │ ├── Noise.cpp │ ├── Noise.h │ ├── Reorder.cpp │ ├── Reorder.h │ ├── SIMD.cpp │ ├── SIMD.h │ ├── Scissor.cpp │ ├── Scissor.h │ ├── SphericalHarmonics.cpp │ ├── SphericalHarmonics.h │ ├── Vector.cpp │ └── Vector.h ├── OpenGL │ ├── OpenGLApp.cpp │ ├── OpenGLApp.h │ ├── OpenGLExtensions.cpp │ ├── OpenGLExtensions.h │ ├── OpenGLRenderer.cpp │ ├── OpenGLRenderer.h │ ├── gl_Extensions.c │ ├── gl_Extensions.h │ ├── project.cpp │ ├── wgl_Extensions.c │ └── wgl_Extensions.h ├── Platform.cpp ├── Platform.h ├── Renderer.cpp ├── Renderer.h ├── Renderer.h.bak ├── Util │ ├── Array.h │ ├── BSP.cpp │ ├── BSP.h │ ├── ConvexHull.cpp │ ├── ConvexHull.h │ ├── Hash.h │ ├── KdTree.h │ ├── Model.cpp │ ├── Model.h │ ├── Queue.h │ ├── String.cpp │ ├── String.h │ ├── TexturePacker.cpp │ ├── TexturePacker.h │ ├── Thread.cpp │ ├── Thread.h │ ├── Tokenizer.cpp │ └── Tokenizer.h ├── Windows │ ├── Resources.aps │ ├── Resources.rc │ ├── WindowsBase.cpp │ ├── mainicon.ico │ └── resource.h ├── glm │ ├── CMakeLists.txt │ ├── common.hpp │ ├── detail │ │ ├── _features.hpp │ │ ├── _fixes.hpp │ │ ├── _noise.hpp │ │ ├── _swizzle.hpp │ │ ├── _swizzle_func.hpp │ │ ├── _vectorize.hpp │ │ ├── compute_vector_relational.hpp │ │ ├── dummy.cpp │ │ ├── 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_gentype.hpp │ │ ├── type_gentype.inl │ │ ├── type_half.hpp │ │ ├── type_half.inl │ │ ├── type_int.hpp │ │ ├── type_mat.hpp │ │ ├── type_mat.inl │ │ ├── type_mat2x2.hpp │ │ ├── type_mat2x2.inl │ │ ├── type_mat2x3.hpp │ │ ├── type_mat2x3.inl │ │ ├── type_mat2x4.hpp │ │ ├── type_mat2x4.inl │ │ ├── type_mat3x2.hpp │ │ ├── type_mat3x2.inl │ │ ├── type_mat3x3.hpp │ │ ├── type_mat3x3.inl │ │ ├── type_mat3x4.hpp │ │ ├── type_mat3x4.inl │ │ ├── type_mat4x2.hpp │ │ ├── type_mat4x2.inl │ │ ├── type_mat4x3.hpp │ │ ├── type_mat4x3.inl │ │ ├── type_mat4x4.hpp │ │ ├── type_mat4x4.inl │ │ ├── type_mat4x4_simd.inl │ │ ├── type_vec.hpp │ │ ├── type_vec.inl │ │ ├── type_vec1.hpp │ │ ├── type_vec1.inl │ │ ├── type_vec2.hpp │ │ ├── type_vec2.inl │ │ ├── type_vec3.hpp │ │ ├── type_vec3.inl │ │ ├── type_vec4.hpp │ │ ├── type_vec4.inl │ │ └── type_vec4_simd.inl │ ├── exponential.hpp │ ├── ext.hpp │ ├── ext │ │ ├── vec1.hpp │ │ ├── vec1.inl │ │ ├── vector_relational.hpp │ │ └── vector_relational.inl │ ├── 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 │ │ └── vec1.inl │ ├── gtx │ │ ├── associated_min_max.hpp │ │ ├── associated_min_max.inl │ │ ├── bit.hpp │ │ ├── bit.inl │ │ ├── closest_point.hpp │ │ ├── closest_point.inl │ │ ├── color_encoding.hpp │ │ ├── color_encoding.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── color_space_YCoCg.hpp │ │ ├── color_space_YCoCg.inl │ │ ├── common.hpp │ │ ├── common.inl │ │ ├── compatibility.hpp │ │ ├── compatibility.inl │ │ ├── component_wise.hpp │ │ ├── component_wise.inl │ │ ├── dual_quaternion.hpp │ │ ├── dual_quaternion.inl │ │ ├── easing.hpp │ │ ├── easing.inl │ │ ├── euler_angles.hpp │ │ ├── euler_angles.inl │ │ ├── extend.hpp │ │ ├── extend.inl │ │ ├── extended_min_max.hpp │ │ ├── extended_min_max.inl │ │ ├── exterior_product.hpp │ │ ├── exterior_product.inl │ │ ├── fast_exponential.hpp │ │ ├── fast_exponential.inl │ │ ├── fast_square_root.hpp │ │ ├── fast_square_root.inl │ │ ├── fast_trigonometry.hpp │ │ ├── fast_trigonometry.inl │ │ ├── float_notmalize.inl │ │ ├── functions.hpp │ │ ├── functions.inl │ │ ├── gradient_paint.hpp │ │ ├── gradient_paint.inl │ │ ├── handed_coordinate_space.hpp │ │ ├── handed_coordinate_space.inl │ │ ├── hash.hpp │ │ ├── hash.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── intersect.hpp │ │ ├── intersect.inl │ │ ├── io.hpp │ │ ├── io.inl │ │ ├── log_base.hpp │ │ ├── log_base.inl │ │ ├── matrix_cross_product.hpp │ │ ├── matrix_cross_product.inl │ │ ├── matrix_decompose.hpp │ │ ├── matrix_decompose.inl │ │ ├── matrix_factorisation.hpp │ │ ├── matrix_factorisation.inl │ │ ├── matrix_interpolation.hpp │ │ ├── matrix_interpolation.inl │ │ ├── matrix_major_storage.hpp │ │ ├── matrix_major_storage.inl │ │ ├── matrix_operation.hpp │ │ ├── matrix_operation.inl │ │ ├── matrix_query.hpp │ │ ├── matrix_query.inl │ │ ├── matrix_transform_2d.hpp │ │ ├── matrix_transform_2d.inl │ │ ├── mixed_product.hpp │ │ ├── mixed_product.inl │ │ ├── norm.hpp │ │ ├── norm.inl │ │ ├── normal.hpp │ │ ├── normal.inl │ │ ├── normalize_dot.hpp │ │ ├── normalize_dot.inl │ │ ├── number_precision.hpp │ │ ├── number_precision.inl │ │ ├── optimum_pow.hpp │ │ ├── optimum_pow.inl │ │ ├── orthonormalize.hpp │ │ ├── orthonormalize.inl │ │ ├── perpendicular.hpp │ │ ├── perpendicular.inl │ │ ├── polar_coordinates.hpp │ │ ├── polar_coordinates.inl │ │ ├── projection.hpp │ │ ├── projection.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── range.hpp │ │ ├── raw_data.hpp │ │ ├── raw_data.inl │ │ ├── rotate_normalized_axis.hpp │ │ ├── rotate_normalized_axis.inl │ │ ├── rotate_vector.hpp │ │ ├── rotate_vector.inl │ │ ├── scalar_multiplication.hpp │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── spline.hpp │ │ ├── spline.inl │ │ ├── std_based_type.hpp │ │ ├── std_based_type.inl │ │ ├── string_cast.hpp │ │ ├── string_cast.inl │ │ ├── texture.hpp │ │ ├── texture.inl │ │ ├── transform.hpp │ │ ├── transform.inl │ │ ├── transform2.hpp │ │ ├── transform2.inl │ │ ├── type_aligned.hpp │ │ ├── type_aligned.inl │ │ ├── type_trait.hpp │ │ ├── type_trait.inl │ │ ├── vec_swizzle.hpp │ │ ├── vector_angle.hpp │ │ ├── vector_angle.inl │ │ ├── vector_query.hpp │ │ ├── vector_query.inl │ │ ├── wrap.hpp │ │ └── wrap.inl │ ├── integer.hpp │ ├── mat2x2.hpp │ ├── mat2x3.hpp │ ├── mat2x4.hpp │ ├── mat3x2.hpp │ ├── mat3x3.hpp │ ├── mat3x4.hpp │ ├── mat4x2.hpp │ ├── mat4x3.hpp │ ├── mat4x4.hpp │ ├── matrix.hpp │ ├── packing.hpp │ ├── simd │ │ ├── common.h │ │ ├── exponential.h │ │ ├── geometric.h │ │ ├── integer.h │ │ ├── matrix.h │ │ ├── packing.h │ │ ├── platform.h │ │ ├── trigonometric.h │ │ └── vector_relational.h │ ├── trigonometric.hpp │ ├── vec2.hpp │ ├── vec3.hpp │ ├── vec4.hpp │ └── vector_relational.hpp └── readme.txt ├── RunTest ├── App.cpp ├── App.h ├── RunTest.exe ├── RunTest.sln ├── RunTest.vcxproj └── RunTest.vcxproj.filters └── Textures └── Fonts ├── Future.dds └── Future.font /.gitignore: -------------------------------------------------------------------------------- 1 | RunTest/RunTest/.vs/ 2 | RunTest/RunTest/RunTest_d.pdb 3 | RunTest/RunTest/RunTest_d.ilk 4 | RunTest/RunTest/Debug/ 5 | RunTest/RunTest/RunTest.map 6 | RunTest/RunTest/Release/ 7 | RunTest/RunTest/RunTest.vcxproj.user 8 | RunTest/RunTest/*.exe 9 | !RunTest/RunTest/RunTest.exe 10 | OldTests/.vs/ 11 | OldTests/Debug/ 12 | OldTests/x64/ 13 | UnitTests/UnitTests.vcxproj.user 14 | UnitTests/.vs/UnitTests/v15/ 15 | UnitTests/Debug/ 16 | UnitTests/Release/ 17 | UnitTests/x64/ 18 | GTests/.vs/ 19 | GTests/GTests.vcxproj.user 20 | GTests/Debug/ 21 | GTests/Release/ 22 | GTests/x64/ 23 | -------------------------------------------------------------------------------- /Examples/GameContext.cpp: -------------------------------------------------------------------------------- 1 | #include "GameContext.h" 2 | #include "TransformUtils.h" 3 | #include "Components/Transforms.h" 4 | 5 | 6 | void GameContext::RemoveEntity(EntityID i_entity) 7 | { 8 | AT_ASSERT(IsValid(i_entity)); 9 | 10 | // Unhook any transforms 11 | if (HasComponent(i_entity)) 12 | { 13 | SetParent_NoUpdate(*this, i_entity, EntityID_None); 14 | 15 | // Delete all child entities 16 | EntityID childID = GetComponent(i_entity).GetChild(); 17 | while (childID != EntityID_None) 18 | { 19 | // Get the next sibling before unhooking from the parent 20 | EntityID nextChildID = GetComponent(childID).GetSibling(); 21 | RemoveEntity(childID); 22 | childID = nextChildID; 23 | } 24 | } 25 | 26 | Context::RemoveEntity(i_entity); 27 | } 28 | 29 | void GameContext::RemoveEntityGroup(GroupID i_group) 30 | { 31 | AT_ASSERT(IsValid(i_group)); 32 | 33 | // Unhook all transforms 34 | Transforms& transforms = GetManager(*m_groups[(uint16_t)i_group]); 35 | for (Transforms::ParentChild& parentChild : transforms.m_parentChilds) 36 | { 37 | // If the parent is not of this group - un-hook all children to be deleted 38 | if (parentChild.m_parent != EntityID_None && 39 | parentChild.m_parent.m_groupID != i_group) 40 | { 41 | auto parent = GetComponent(parentChild.m_parent); 42 | EntityID childID = parent.GetChild(); 43 | while (childID != EntityID_None) 44 | { 45 | // Get the next sibling before unhooking from the parent 46 | EntityID nextChildID = GetComponent(childID).GetSibling(); 47 | if (childID.m_groupID == i_group) 48 | { 49 | SetParent_NoUpdate(*this, childID, EntityID_None); 50 | } 51 | childID = nextChildID; 52 | } 53 | } 54 | 55 | // Loop through any children not in this group - unhook and delete 56 | EntityID childID = parentChild.m_child; 57 | while (childID != EntityID_None) 58 | { 59 | // Get the next sibling before unhooking from the parent 60 | EntityID nextChildID = GetComponent(childID).GetSibling(); 61 | if (childID.m_groupID != i_group) 62 | { 63 | RemoveEntity(childID); 64 | } 65 | childID = nextChildID; 66 | } 67 | } 68 | 69 | Context::RemoveEntityGroup(i_group); 70 | } 71 | 72 | -------------------------------------------------------------------------------- /Examples/GameContext.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "GameGroup.h" 5 | 6 | /// \brief A ECS game context. This context overrides deletion of entities and groups due to 7 | /// transform component needing custom code to unregister from the hierarchy. 8 | class GameContext : public Context 9 | { 10 | public: 11 | 12 | /// \brief Overridden removal of an entity. Does component specific delete operations. 13 | /// NOTE: This will also recursively delete child entities. 14 | /// \param i_entity The entity to delete 15 | void RemoveEntity(EntityID i_entity) override; 16 | 17 | /// \brief Overridden removal of a group. Does component specific delete operations. 18 | /// NOTE: This also deletes entities that are children of entities in this group. To optimize, always delete child groups first if possible. 19 | /// \param The group to delete. 20 | void RemoveEntityGroup(GroupID i_group) override; 21 | 22 | }; 23 | 24 | -------------------------------------------------------------------------------- /Examples/GameGroup.cpp: -------------------------------------------------------------------------------- 1 | #include "GameGroup.h" 2 | #include "Components/Transforms.h" 3 | #include "Components/Bounds.h" 4 | 5 | GameGroup::GameGroup() 6 | { 7 | m_transforms = std::make_unique(); 8 | m_worldTransforms = std::make_unique(); 9 | 10 | m_bounds = std::make_unique(); 11 | m_worldBounds = std::make_unique(); 12 | 13 | AddManager(&*m_transforms); 14 | AddManager(&*m_worldTransforms); 15 | 16 | AddManager(&*m_bounds); 17 | AddManager(&*m_worldBounds); 18 | } 19 | 20 | GameGroup::~GameGroup() 21 | { 22 | } 23 | 24 | -------------------------------------------------------------------------------- /Examples/GameGroup.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | class Transforms; 7 | class WorldTransforms; 8 | class Bounds; 9 | class WorldBounds; 10 | 11 | class GameGroup : public EntityGroup 12 | { 13 | public: 14 | 15 | GameGroup(); 16 | ~GameGroup(); 17 | 18 | std::unique_ptr m_transforms; 19 | std::unique_ptr m_worldTransforms; 20 | 21 | std::unique_ptr m_bounds; 22 | std::unique_ptr m_worldBounds; 23 | }; 24 | 25 | template<> inline Transforms& GetManager(GameGroup& i_group) { return *i_group.m_transforms; } 26 | template<> inline WorldTransforms& GetManager(GameGroup& i_group) { return *i_group.m_worldTransforms; } 27 | template<> inline Bounds& GetManager(GameGroup& i_group) { return *i_group.m_bounds; } 28 | template<> inline WorldBounds& GetManager(GameGroup& i_group) { return *i_group.m_worldBounds; } 29 | 30 | -------------------------------------------------------------------------------- /Examples/Utils.cpp: -------------------------------------------------------------------------------- 1 | #include "Utils.h" 2 | -------------------------------------------------------------------------------- /GTests/GTests.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 15 4 | VisualStudioVersion = 15.0.28010.2036 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTests", "GTests.vcxproj", "{533BE099-444F-49EF-B57B-402CCFF48571}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {533BE099-444F-49EF-B57B-402CCFF48571}.Debug|x64.ActiveCfg = Debug|x64 17 | {533BE099-444F-49EF-B57B-402CCFF48571}.Debug|x64.Build.0 = Debug|x64 18 | {533BE099-444F-49EF-B57B-402CCFF48571}.Debug|x86.ActiveCfg = Debug|Win32 19 | {533BE099-444F-49EF-B57B-402CCFF48571}.Debug|x86.Build.0 = Debug|Win32 20 | {533BE099-444F-49EF-B57B-402CCFF48571}.Release|x64.ActiveCfg = Release|x64 21 | {533BE099-444F-49EF-B57B-402CCFF48571}.Release|x64.Build.0 = Release|x64 22 | {533BE099-444F-49EF-B57B-402CCFF48571}.Release|x86.ActiveCfg = Release|Win32 23 | {533BE099-444F-49EF-B57B-402CCFF48571}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {524DD2D9-746D-4469-8D36-6A8A2646CCAB} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /GTests/GTests.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | ECS 6 | 7 | 8 | Examples 9 | 10 | 11 | Examples 12 | 13 | 14 | Examples 15 | 16 | 17 | 18 | Examples 19 | 20 | 21 | 22 | 23 | 24 | ECS 25 | 26 | 27 | ECS 28 | 29 | 30 | ECS 31 | 32 | 33 | Examples 34 | 35 | 36 | Examples 37 | 38 | 39 | Examples 40 | 41 | 42 | Examples\Components 43 | 44 | 45 | Examples\Components 46 | 47 | 48 | Examples 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | {bbcc5a42-b9c7-4426-8d12-966445963ef9} 57 | 58 | 59 | {f5c81846-e0e3-4863-9f65-bca86bdfc188} 60 | 61 | 62 | {659dd6b2-7775-48fb-8920-0abd61e385cc} 63 | 64 | 65 | -------------------------------------------------------------------------------- /GTests/packages.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0.nupkg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0.nupkg -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/ThirdPartyNotices.txt: -------------------------------------------------------------------------------- 1 | 2 | THIRD-PARTY SOFTWARE NOTICES AND INFORMATION 3 | Do Not Translate or Localize 4 | 5 | This package incorporates components from the projects listed below. Microsoft licenses these components to you under the license terms for the Microsoft package. The original copyright notices and the licenses under which Microsoft received such components are set forth below for informational purposes. Microsoft reserves all rights not expressly granted herein, whether by implication, estoppel or otherwise. 6 | 7 | 8 | 9 | 1. Google Test Framework (https://github.com/google/googletest) 10 | 11 | 12 | %% Google Test Framework NOTICES, INFORMATION, AND LICENSE BEGIN HERE 13 | ========================================= 14 | Copyright 2008, Google Inc. 15 | All rights reserved. 16 | 17 | Redistribution and use in source and binary forms, with or without 18 | modification, are permitted provided that the following conditions are 19 | met: 20 | 21 | * Redistributions of source code must retain the above copyright 22 | notice, this list of conditions and the following disclaimer. 23 | * Redistributions in binary form must reproduce the above 24 | copyright notice, this list of conditions and the following disclaimer 25 | in the documentation and/or other materials provided with the 26 | distribution. 27 | * Neither the name of Google Inc. nor the names of its 28 | contributors may be used to endorse or promote products derived from 29 | this software without specific prior written permission. 30 | 31 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 34 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 36 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 37 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 38 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 39 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 40 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 41 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 42 | ========================================= 43 | END OF Google Test Framework NOTICES, INFORMATION, AND LICENSE 44 | 45 | 46 | -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/build/native/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.propertiesui.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/build/native/include/gtest/internal/custom/gtest-printers.h: -------------------------------------------------------------------------------- 1 | // Copyright 2015, Google Inc. 2 | // All rights reserved. 3 | // 4 | // Redistribution and use in source and binary forms, with or without 5 | // modification, are permitted provided that the following conditions are 6 | // met: 7 | // 8 | // * Redistributions of source code must retain the above copyright 9 | // notice, this list of conditions and the following disclaimer. 10 | // * Redistributions in binary form must reproduce the above 11 | // copyright notice, this list of conditions and the following disclaimer 12 | // in the documentation and/or other materials provided with the 13 | // distribution. 14 | // * Neither the name of Google Inc. nor the names of its 15 | // contributors may be used to endorse or promote products derived from 16 | // this software without specific prior written permission. 17 | // 18 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | // 30 | // This file provides an injection point for custom printers in a local 31 | // installation of gTest. 32 | // It will be included from gtest-printers.h and the overrides in this file 33 | // will be visible to everyone. 34 | // See documentation at gtest/gtest-printers.h for details on how to define a 35 | // custom printer. 36 | // 37 | // ** Custom implementation starts here ** 38 | 39 | #ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ 40 | #define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ 41 | 42 | #endif // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ 43 | -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/build/native/include/gtest/internal/custom/gtest.h: -------------------------------------------------------------------------------- 1 | // Copyright 2015, Google Inc. 2 | // All rights reserved. 3 | // 4 | // Redistribution and use in source and binary forms, with or without 5 | // modification, are permitted provided that the following conditions are 6 | // met: 7 | // 8 | // * Redistributions of source code must retain the above copyright 9 | // notice, this list of conditions and the following disclaimer. 10 | // * Redistributions in binary form must reproduce the above 11 | // copyright notice, this list of conditions and the following disclaimer 12 | // in the documentation and/or other materials provided with the 13 | // distribution. 14 | // * Neither the name of Google Inc. nor the names of its 15 | // contributors may be used to endorse or promote products derived from 16 | // this software without specific prior written permission. 17 | // 18 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | // 30 | // Injection point for custom user configurations. 31 | // The following macros can be defined: 32 | // 33 | // GTEST_OS_STACK_TRACE_GETTER_ - The name of an implementation of 34 | // OsStackTraceGetterInterface. 35 | // 36 | // ** Custom implementation starts here ** 37 | 38 | #ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_ 39 | #define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_ 40 | 41 | #endif // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_ 42 | -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Debug/gtest.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Debug/gtest.lib -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Debug/gtest.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Debug/gtest.pdb -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Debug/gtest_main.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Debug/gtest_main.lib -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Debug/gtest_main.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Debug/gtest_main.pdb -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Release/gtest.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Release/gtest.lib -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Release/gtest.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Release/gtest.pdb -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Release/gtest_main.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Release/gtest_main.lib -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Release/gtest_main.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x64/Release/gtest_main.pdb -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Debug/gtest.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Debug/gtest.lib -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Debug/gtest.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Debug/gtest.pdb -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Debug/gtest_main.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Debug/gtest_main.lib -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Debug/gtest_main.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Debug/gtest_main.pdb -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Release/gtest.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Release/gtest.lib -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Release/gtest.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Release/gtest.pdb -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Release/gtest_main.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Release/gtest_main.lib -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Release/gtest_main.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/lib/native/v140/windesktop/msvcstl/static/rt-dyn/x86/Release/gtest_main.pdb -------------------------------------------------------------------------------- /GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/license (MIT).txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/GTests/packages/Microsoft.googletest.v140.windesktop.msvcstl.static.rt-dyn.1.8.0/license (MIT).txt -------------------------------------------------------------------------------- /Images/RunTest1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/Images/RunTest1.png -------------------------------------------------------------------------------- /Images/RunTest2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/Images/RunTest2.png -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 Damian Trebilco 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Lib/Common.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #ifndef NDEBUG 7 | 8 | #define AT_ASSERT(x) assert(x) 9 | #include 10 | 11 | /// \brief A debug access check that asserts if the lock becomes invalid. 12 | class DebugAccessCheck 13 | { 14 | public: 15 | inline ~DebugAccessCheck() { AT_ASSERT(m_counter == 0); } 16 | inline void AddLock() { m_counter++; AT_ASSERT(m_counter > 0); } 17 | inline void ReleaseLock() { m_counter--; AT_ASSERT(m_counter >= 0); } 18 | inline void CheckLock() { AT_ASSERT(m_counter == 0); } 19 | private: 20 | std::atomic_int32_t m_counter = 0; 21 | }; 22 | 23 | 24 | #else 25 | 26 | #define AT_ASSERT(x) 27 | 28 | class DebugAccessCheck 29 | { 30 | public: 31 | inline void AddLock() {} 32 | inline void ReleaseLock() {} 33 | inline void CheckLock(){} 34 | }; 35 | 36 | #endif 37 | 38 | 39 | /// \brief Get the count of the number of bits set 40 | /// Taken from https://en.wikipedia.org/wiki/Hamming_weight 41 | inline uint16_t PopCount64(uint64_t x) 42 | { 43 | const uint64_t m1 = 0x5555555555555555; //binary: 0101... 44 | const uint64_t m2 = 0x3333333333333333; //binary: 00110011.. 45 | const uint64_t m4 = 0x0f0f0f0f0f0f0f0f; //binary: 4 zeros, 4 ones ... 46 | const uint64_t h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3... 47 | 48 | x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits 49 | x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits 50 | x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits 51 | return uint16_t((x * h01) >> 56); //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... 52 | } 53 | 54 | -------------------------------------------------------------------------------- /OldTests/Common.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #define AT_ASSERT(x) 6 | 7 | enum class ComponentType 8 | { 9 | 10 | 11 | }; 12 | 13 | // Taken from https://en.wikipedia.org/wiki/Hamming_weight 14 | inline uint32_t PopCount64(uint64_t x) 15 | { 16 | const uint64_t m1 = 0x5555555555555555; //binary: 0101... 17 | const uint64_t m2 = 0x3333333333333333; //binary: 00110011.. 18 | const uint64_t m4 = 0x0f0f0f0f0f0f0f0f; //binary: 4 zeros, 4 ones ... 19 | const uint64_t h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3... 20 | 21 | x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits 22 | x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits 23 | x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits 24 | return (x * h01) >> 56; //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... 25 | } 26 | 27 | -------------------------------------------------------------------------------- /OldTests/ECS.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 15 4 | VisualStudioVersion = 15.0.27004.2005 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ECS", "ECS.vcxproj", "{FD805D79-A0D6-42FF-905E-C65039CA54F8}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {FD805D79-A0D6-42FF-905E-C65039CA54F8}.Debug|x64.ActiveCfg = Debug|x64 17 | {FD805D79-A0D6-42FF-905E-C65039CA54F8}.Debug|x64.Build.0 = Debug|x64 18 | {FD805D79-A0D6-42FF-905E-C65039CA54F8}.Debug|x86.ActiveCfg = Debug|Win32 19 | {FD805D79-A0D6-42FF-905E-C65039CA54F8}.Debug|x86.Build.0 = Debug|Win32 20 | {FD805D79-A0D6-42FF-905E-C65039CA54F8}.Release|x64.ActiveCfg = Release|x64 21 | {FD805D79-A0D6-42FF-905E-C65039CA54F8}.Release|x64.Build.0 = Release|x64 22 | {FD805D79-A0D6-42FF-905E-C65039CA54F8}.Release|x86.ActiveCfg = Release|Win32 23 | {FD805D79-A0D6-42FF-905E-C65039CA54F8}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {462C8ED8-092F-42C8-8480-DF690D356505} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /OldTests/ECS.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /RunTest/Framework3/Config.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _CONFIG_H_ 23 | #define _CONFIG_H_ 24 | 25 | #include "Platform.h" 26 | #include "Util/Array.h" 27 | 28 | struct Entry; 29 | 30 | class Config { 31 | public: 32 | Config(); 33 | ~Config(); 34 | 35 | bool init(const char *subPath = NULL); 36 | bool flush(); 37 | 38 | bool getBoolDef(const char *name, const bool def) const; 39 | int getIntegerDef(const char *name, const int def) const; 40 | float getFloatDef(const char *name, const float def) const; 41 | bool getInteger(const char *name, int &dest) const; 42 | void setBool(const char *name, const bool val); 43 | void setInteger(const char *name, const int val); 44 | void setFloat(const char *name, const float val); 45 | private: 46 | 47 | Array entries; 48 | char *path; 49 | }; 50 | 51 | 52 | #endif // _CONFIG_H_ 53 | -------------------------------------------------------------------------------- /RunTest/Framework3/Direct3D/D3DApp.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _D3DAPP_H_ 23 | #define _D3DAPP_H_ 24 | 25 | #include "Direct3DRenderer.h" 26 | #include "../BaseApp.h" 27 | 28 | class D3DApp : public BaseApp { 29 | public: 30 | D3DApp(); 31 | 32 | bool initCaps(); 33 | bool initAPI(); 34 | void exitAPI(); 35 | 36 | void beginFrame(); 37 | void endFrame(); 38 | 39 | virtual void onSize(const int w, const int h); 40 | virtual bool onReset(){ return true; } 41 | 42 | bool captureScreenshot(Image &img); 43 | 44 | protected: 45 | D3DCAPS9 caps; 46 | LPDIRECT3D9 d3d; 47 | LPDIRECT3DDEVICE9 dev; 48 | D3DPRESENT_PARAMETERS d3dpp; 49 | }; 50 | 51 | #endif // _D3DAPP_H_ 52 | -------------------------------------------------------------------------------- /RunTest/Framework3/GUI/CheckBox.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _CHECKBOX_H_ 23 | #define _CHECKBOX_H_ 24 | 25 | #include "Widget.h" 26 | 27 | class CheckBox; 28 | class CheckBoxListener { 29 | public: 30 | virtual ~CheckBoxListener(){} 31 | 32 | virtual void onCheckBoxClicked(CheckBox *checkBox) = 0; 33 | }; 34 | 35 | 36 | class CheckBox : public Widget { 37 | public: 38 | CheckBox(const float x, const float y, const float w, const float h, const char *txt, const bool isCheck = false); 39 | virtual ~CheckBox(); 40 | 41 | void setListener(CheckBoxListener *listener){ checkBoxListener = listener; } 42 | 43 | void setChecked(const bool ch){ checked = ch; } 44 | bool isChecked() const { return checked; } 45 | 46 | bool onMouseButton(const int x, const int y, const MouseButton button, const bool pressed); 47 | bool onKey(const unsigned int key, const bool pressed); 48 | 49 | void draw(Renderer *renderer, const FontID defaultFont, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState); 50 | 51 | protected: 52 | char *text; 53 | 54 | CheckBoxListener *checkBoxListener; 55 | 56 | bool checked; 57 | }; 58 | 59 | #endif // _CHECKBOX_H_ 60 | -------------------------------------------------------------------------------- /RunTest/Framework3/GUI/Label.cpp: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #include "Label.h" 23 | 24 | Label::Label(const float x, const float y, const float w, const float h, const char *txt): 25 | text(NULL) 26 | { 27 | setPosition(x, y); 28 | setSize(w, h); 29 | 30 | setText(txt); 31 | 32 | enabled = false; 33 | } 34 | 35 | Label::~Label(){ 36 | delete [] text; 37 | } 38 | 39 | void Label::setText(const char *txt) 40 | { 41 | delete [] text; 42 | text = new char[strlen(txt) + 1]; 43 | strcpy(text, txt); 44 | } 45 | 46 | void Label::draw(Renderer *renderer, const FontID defaultFont, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState){ 47 | float textWidth = 0.75f * height; 48 | 49 | float tw = renderer->getTextWidth(defaultFont, text); 50 | float maxW = width / tw; 51 | if (textWidth > maxW) textWidth = maxW; 52 | 53 | renderer->drawText(text, xPos, yPos, textWidth, height, defaultFont, linearClamp, blendSrcAlpha, depthState); 54 | } 55 | -------------------------------------------------------------------------------- /RunTest/Framework3/GUI/Label.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _LABEL_H_ 23 | #define _LABEL_H_ 24 | 25 | #include "Widget.h" 26 | 27 | class Label : public Widget { 28 | public: 29 | Label(const float x, const float y, const float w, const float h, const char *txt); 30 | virtual ~Label(); 31 | 32 | void setText(const char *txt); 33 | 34 | void draw(Renderer *renderer, const FontID defaultFont, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState); 35 | 36 | protected: 37 | char *text; 38 | }; 39 | 40 | #endif // _LABEL_H_ 41 | -------------------------------------------------------------------------------- /RunTest/Framework3/Imaging/jconfig.h: -------------------------------------------------------------------------------- 1 | /* jconfig.h. Generated automatically by configure. */ 2 | /* jconfig.cfg --- source file edited by configure script */ 3 | /* see jconfig.doc for explanations */ 4 | 5 | #define HAVE_PROTOTYPES 6 | #define HAVE_UNSIGNED_CHAR 7 | #define HAVE_UNSIGNED_SHORT 8 | #undef void 9 | #undef const 10 | #undef CHAR_IS_UNSIGNED 11 | #define HAVE_STDDEF_H 12 | #define HAVE_STDLIB_H 13 | #undef NEED_BSD_STRINGS 14 | #undef NEED_SYS_TYPES_H 15 | #undef NEED_FAR_POINTERS 16 | #undef NEED_SHORT_EXTERNAL_NAMES 17 | /* Define this if you get warnings about undefined structures. */ 18 | #undef INCOMPLETE_TYPES_BROKEN 19 | 20 | #ifdef JPEG_INTERNALS 21 | 22 | #undef RIGHT_SHIFT_IS_UNSIGNED 23 | #define INLINE __inline__ 24 | /* These are for configuring the JPEG memory manager. */ 25 | #undef DEFAULT_MAX_MEM 26 | #undef NO_MKTEMP 27 | 28 | #endif /* JPEG_INTERNALS */ 29 | 30 | #ifdef JPEG_CJPEG_DJPEG 31 | 32 | #undef BMP_SUPPORTED /* BMP image file format */ 33 | #undef GIF_SUPPORTED /* GIF image file format */ 34 | #undef PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ 35 | #undef RLE_SUPPORTED /* Utah RLE image file format */ 36 | #undef TARGA_SUPPORTED /* Targa image file format */ 37 | 38 | #undef TWO_FILE_COMMANDLINE 39 | #undef NEED_SIGNAL_CATCHER 40 | #undef DONT_USE_B_MODE 41 | 42 | /* Define this if you want percent-done progress reports from cjpeg/djpeg. */ 43 | #undef PROGRESS_REPORT 44 | 45 | #endif /* JPEG_CJPEG_DJPEG */ 46 | -------------------------------------------------------------------------------- /RunTest/Framework3/Libs/ALut.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Libs/ALut.lib -------------------------------------------------------------------------------- /RunTest/Framework3/Libs/OpenAL32.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Libs/OpenAL32.lib -------------------------------------------------------------------------------- /RunTest/Framework3/Libs/libjpeg.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Libs/libjpeg.lib -------------------------------------------------------------------------------- /RunTest/Framework3/Libs/libpng.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Libs/libpng.lib -------------------------------------------------------------------------------- /RunTest/Framework3/Libs/ogg_static.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Libs/ogg_static.lib -------------------------------------------------------------------------------- /RunTest/Framework3/Libs/vorbis_static.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Libs/vorbis_static.lib -------------------------------------------------------------------------------- /RunTest/Framework3/Libs/vorbisfile_static.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Libs/vorbisfile_static.lib -------------------------------------------------------------------------------- /RunTest/Framework3/Libs/zlib.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Libs/zlib.lib -------------------------------------------------------------------------------- /RunTest/Framework3/Math/Frustum.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _FRUSTUM_H_ 23 | #define _FRUSTUM_H_ 24 | 25 | #include "Vector.h" 26 | 27 | #define FRUSTUM_LEFT 0 28 | #define FRUSTUM_RIGHT 1 29 | #define FRUSTUM_TOP 2 30 | #define FRUSTUM_BOTTOM 3 31 | #define FRUSTUM_FAR 4 32 | #define FRUSTUM_NEAR 5 33 | 34 | struct Plane { 35 | Plane(){} 36 | Plane(const float x, const float y, const float z, const float o){ 37 | normal = vec3(x, y, z); 38 | float invLen = 1.0f / length(normal); 39 | normal *= invLen; 40 | offset = o * invLen; 41 | } 42 | 43 | float dist(const vec3 &pos) const { 44 | return dot(normal, pos) + offset; 45 | } 46 | 47 | vec3 normal; 48 | float offset; 49 | }; 50 | 51 | class Frustum { 52 | public: 53 | void loadFrustum(const mat4 &mvp); 54 | 55 | bool pointInFrustum(const vec3 &pos) const; 56 | bool sphereInFrustum(const vec3 &pos, const float radius) const; 57 | bool cubeInFrustum(const float minX, const float maxX, const float minY, const float maxY, const float minZ, const float maxZ) const; 58 | 59 | const Plane &getPlane(const int plane) const { return planes[plane]; } 60 | 61 | protected: 62 | Plane planes[6]; 63 | }; 64 | 65 | 66 | #endif // _FRUSTUM_H_ 67 | -------------------------------------------------------------------------------- /RunTest/Framework3/Math/MathTools.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _MATHTOOLS_H_ 23 | #define _MATHTOOLS_H_ 24 | 25 | #include "Vector.h" 26 | 27 | // Generates Poisson disk samples using the Dart throwing method 28 | bool generatePoissonSamples(vec2 *samples, const int nSamples, const float minDist, const int maxFailedTries, const int nRetries, const bool includeCenter); 29 | 30 | 31 | #endif // _MATHTOOLS_H_ 32 | -------------------------------------------------------------------------------- /RunTest/Framework3/Math/Noise.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _NOISE_H_ 23 | #define _NOISE_H_ 24 | 25 | float noise1(const float x); 26 | float noise2(const float x, const float y); 27 | float noise3(const float x, const float y, const float z); 28 | 29 | float turbulence2(const float x, const float y, float freq); 30 | float turbulence3(const float x, const float y, const float z, float freq); 31 | 32 | float tileableNoise1(const float x, const float w); 33 | float tileableNoise2(const float x, const float y, const float w, const float h); 34 | float tileableNoise3(const float x, const float y, const float z, const float w, const float h, const float d); 35 | 36 | float tileableTurbulence2(const float x, const float y, const float w, const float h, float freq); 37 | float tileableTurbulence3(const float x, const float y, const float z, const float w, const float h, const float d, float freq); 38 | 39 | void initNoise(); 40 | 41 | 42 | #endif // _NOISE_H_ 43 | -------------------------------------------------------------------------------- /RunTest/Framework3/Math/Reorder.cpp: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #include "Reorder.h" 23 | 24 | unsigned int evenDilate(const unsigned int val){ 25 | unsigned int u = ((val & 0x0000ff00) << 8) | (val & 0x000000ff); 26 | unsigned int v = (( u & 0x00f000f0) << 4) | ( u & 0x000f000f); 27 | unsigned int w = (( v & 0x0c0c0c0c) << 2) | ( v & 0x03030303); 28 | unsigned int r = (( w & 0x22222222) << 1) | ( w & 0x11111111); 29 | return r; 30 | } 31 | 32 | #define oddDilate(val) ((evenDilate(val) << 1)) 33 | 34 | unsigned int mortonToLinear(unsigned int x, unsigned int y){ 35 | return (evenDilate(x) | oddDilate(y)); 36 | } 37 | 38 | 39 | static const unsigned char ihtab[] = { 0x2, 0x4, 0xD, 0x8, 0x9, 0x5, 0xC, 0x3, 0x0, 0xF, 0x6, 0xA, 0xB, 0xE, 0x7, 0x1 }; 40 | 41 | unsigned int hilbertToLinear(unsigned int x, unsigned int y){ 42 | unsigned int t = 0; 43 | unsigned int c = 0; 44 | for (unsigned int i = 0; i < 16; i++){ 45 | unsigned int xi = (x >> 14) & 2; 46 | unsigned int yi = (y >> 15) & 1; 47 | x <<= 1; 48 | y <<= 1; 49 | 50 | unsigned char st = ihtab[(c << 2) | xi | yi]; 51 | t <<= 2; 52 | t |= (st >> 2); 53 | c = st & 3; 54 | } 55 | 56 | return t; 57 | } 58 | -------------------------------------------------------------------------------- /RunTest/Framework3/Math/Reorder.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _REORDER_H_ 23 | #define _REORDER_H_ 24 | 25 | unsigned int mortonToLinear(unsigned int x, unsigned int y); 26 | unsigned int hilbertToLinear(unsigned int x, unsigned int y); 27 | 28 | #endif // _REORDER_H_ 29 | -------------------------------------------------------------------------------- /RunTest/Framework3/Math/SIMD.cpp: -------------------------------------------------------------------------------- 1 | #include "SIMD.h" 2 | 3 | -------------------------------------------------------------------------------- /RunTest/Framework3/Math/SIMD.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _SIMD_H_ 23 | #define _SIMD_H_ 24 | 25 | #include "Vector.h" 26 | /* 27 | #undef pfacc 28 | #undef pfmul 29 | __forceinline void planeDistance3DNow(const vec4 *plane, const vec4 *point, int *result){ 30 | __asm { 31 | mov eax, plane 32 | mov ebx, point 33 | mov ecx, result 34 | 35 | movq mm0, [eax] // [nx, ny] 36 | movq mm1, [eax + 8] // [nz, d] 37 | 38 | movq mm2, [ebx] // [px, py] 39 | movq mm3, [ebx + 8] // [pz, 1] 40 | 41 | pfmul mm0, mm2 // [nx * px, ny * py] 42 | pfmul mm1, mm3 // [nz * pz, d] 43 | 44 | pfacc mm0, mm1 45 | pfacc mm0, mm0 46 | 47 | movd [ecx], mm0 48 | } 49 | } 50 | */ 51 | 52 | #include "../CPU.h" 53 | 54 | forceinline v4sf dot4(v4sf u, v4sf v){ 55 | v4sf m = mulps(u, v); 56 | v4sf f = shufps(m, m, SHUFFLE(2, 3, 0, 1)); 57 | m = addps(m, f); 58 | f = shufps(m, m, SHUFFLE(1, 0, 3, 2)); 59 | return addps(m, f); 60 | } 61 | 62 | #endif 63 | -------------------------------------------------------------------------------- /RunTest/Framework3/Math/Scissor.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _SCISSOR_H_ 23 | #define _SCISSOR_H_ 24 | 25 | #include "Vector.h" 26 | 27 | //bool getScissorRectangle(const mat4 &projection, const mat4 &modelview, const vec3 &camPos, const vec3 &lightPos, const float radius, const int width, const int height, int *x, int *y, int *w, int *h); 28 | bool getScissorRectangle(const mat4 &modelview, const vec3 &pos, const float radius, const float fov, const int width, const int height, int *x, int *y, int *w, int *h); 29 | 30 | #endif // _SCISSOR_H_ 31 | -------------------------------------------------------------------------------- /RunTest/Framework3/Math/SphericalHarmonics.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _SPHERICALHARMONICS_H_ 23 | #define _SPHERICALHARMONICS_H_ 24 | 25 | #include "../Imaging/Image.h" 26 | #include "Vector.h" 27 | 28 | #define MAX_BANDS 256 29 | 30 | void initSH(); 31 | 32 | float SH(const int l, const int m, const float theta, const float phi); 33 | float SH(const int l, const int m, const float3 &pos); 34 | float SH_A(const int l, const int m, const float3 &pos); 35 | float SH_A2(const int l, const int m, const float3 &pos); 36 | 37 | template 38 | bool cubemapToSH(FLOAT *dst, const Image &img, const int bands); 39 | 40 | template 41 | bool shToCubemap(Image &img, const int size, const FLOAT *src, const int bands); 42 | 43 | template 44 | void computeSHCoefficients(FLOAT *dest, const int bands, const float3 &pos, const bool fade); 45 | 46 | #endif // _SPHERICALHARMONICS_H_ 47 | -------------------------------------------------------------------------------- /RunTest/Framework3/OpenGL/OpenGLApp.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _GLAPP_H_ 23 | #define _GLAPP_H_ 24 | 25 | #include "OpenGLRenderer.h" 26 | #include "../BaseApp.h" 27 | 28 | #ifdef LINUX 29 | #include 30 | #endif 31 | 32 | class OpenGLApp : public BaseApp { 33 | public: 34 | OpenGLApp(); 35 | 36 | virtual bool initCaps(); 37 | 38 | virtual bool initAPI(); 39 | virtual void exitAPI(); 40 | 41 | void beginFrame(); 42 | void endFrame(); 43 | 44 | bool checkForErrors(); 45 | 46 | virtual void onSize(const int w, const int h); 47 | 48 | bool captureScreenshot(Image &img); 49 | 50 | void drawFPSChart(); 51 | 52 | protected: 53 | 54 | float m_frameDeltas[500]; //!< The array of frame delta history 55 | unsigned int m_frameDeltaIndex; //!< The current frame delta index 56 | 57 | #if defined(_WIN32) 58 | HDC hdc; 59 | HGLRC glContext; 60 | DISPLAY_DEVICE device; 61 | #elif defined(LINUX) 62 | GLXContext glContext; 63 | XF86VidModeModeInfo **dmodes; 64 | #elif defined(__APPLE__) 65 | AGLContext glContext; 66 | CFArrayRef dmodes; 67 | CFDictionaryRef initialMode; 68 | #endif 69 | }; 70 | 71 | #endif // _GLAPP_H_ 72 | -------------------------------------------------------------------------------- /RunTest/Framework3/Renderer.h.bak: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Renderer.h.bak -------------------------------------------------------------------------------- /RunTest/Framework3/Util/ConvexHull.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _CONVEXHULL_H_ 23 | #define _CONVEXHULL_H_ 24 | 25 | #include "../Platform.h" 26 | #include "../Math/Vector.h" 27 | 28 | struct CHNode 29 | { 30 | CHNode *Prev; 31 | CHNode *Next; 32 | float2 Point; 33 | }; 34 | 35 | class ConvexHull 36 | { 37 | public: 38 | ConvexHull(); 39 | ~ConvexHull(); 40 | 41 | void Clear(); 42 | bool InsertPoint(const float2 &point); 43 | bool RemoveLeastRelevantEdge(); 44 | uint FindOptimalPolygon(float2 *dest, uint vertex_count, float *area = NULL); 45 | 46 | bool GoToFirst() { return (m_Curr = m_Root) != NULL; } 47 | bool GoToNext () { return (m_Curr = m_Curr->Next) != m_Root; } 48 | 49 | const float2 &GetCurrPoint() const { return m_Curr->Point; } 50 | const float2 &GetNextPoint() const { return m_Curr->Next->Point; } 51 | const float2 &GetPrevPoint() const { return m_Curr->Prev->Point; } 52 | 53 | uint GetCount() const { return m_Count; } 54 | float GetArea() const; 55 | 56 | protected: 57 | CHNode *m_Root; 58 | CHNode *m_Curr; 59 | uint m_Count; 60 | 61 | }; 62 | 63 | #endif // _CONVEXHULL_H_ 64 | -------------------------------------------------------------------------------- /RunTest/Framework3/Util/TexturePacker.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _TEXTUREPACKER_H_ 23 | #define _TEXTUREPACKER_H_ 24 | 25 | #include "../Platform.h" 26 | #include "Array.h" 27 | 28 | struct TextureRectangle { 29 | uint x, y; 30 | uint width, height; 31 | }; 32 | 33 | 34 | typedef int (*compareRectFunc)(TextureRectangle *const &elem0, TextureRectangle *const &elem1); 35 | 36 | int originalAreaComp(TextureRectangle *const &elem0, TextureRectangle *const &elem1); 37 | int areaComp(TextureRectangle *const &elem0, TextureRectangle *const &elem1); 38 | int widthComp(TextureRectangle *const &elem0, TextureRectangle *const &elem1); 39 | int heightComp(TextureRectangle *const &elem0, TextureRectangle *const &elem1); 40 | 41 | class TexturePacker { 42 | public: 43 | ~TexturePacker(); 44 | 45 | void addRectangle(uint width, uint height); 46 | bool assignCoords(uint *width, uint *height, compareRectFunc compRectFunc = originalAreaComp); 47 | 48 | TextureRectangle *getRectangle(uint index) const { return rects[index]; } 49 | 50 | protected: 51 | Array rects; 52 | }; 53 | 54 | #endif // _TEXTUREPACKER_H_ 55 | -------------------------------------------------------------------------------- /RunTest/Framework3/Util/Tokenizer.h: -------------------------------------------------------------------------------- 1 | 2 | /* * * * * * * * * * * * * Author's note * * * * * * * * * * * *\ 3 | * _ _ _ _ _ _ _ _ _ _ _ _ * 4 | * |_| |_| |_| |_| |_|_ _|_| |_| |_| _|_|_|_|_| * 5 | * |_|_ _ _|_| |_| |_| |_|_|_|_|_| |_| |_| |_|_ _ _ * 6 | * |_|_|_|_|_| |_| |_| |_| |_| |_| |_| |_| |_|_|_|_ * 7 | * |_| |_| |_|_ _ _|_| |_| |_| |_|_ _ _|_| _ _ _ _|_| * 8 | * |_| |_| |_|_|_| |_| |_| |_|_|_| |_|_|_|_| * 9 | * * 10 | * http://www.humus.name * 11 | * * 12 | * This file is a part of the work done by Humus. You are free to * 13 | * use the code in any way you like, modified, unmodified or copied * 14 | * into your own work. However, I expect you to respect these points: * 15 | * - If you use this file and its contents unmodified, or use a major * 16 | * part of this file, please credit the author and leave this note. * 17 | * - For use in anything commercial, please request my approval. * 18 | * - Share your work and ideas too as much as you can. * 19 | * * 20 | \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 21 | 22 | #ifndef _TOKENIZER_H_ 23 | #define _TOKENIZER_H_ 24 | 25 | #include "../Platform.h" 26 | #include "Array.h" 27 | 28 | typedef bool (*BOOLFUNC)(const char ch); 29 | 30 | bool isWhiteSpace(const char ch); 31 | bool isNumeric(const char ch); 32 | bool isAlphabetical(const char ch); 33 | bool isNewLine(const char ch); 34 | 35 | struct TokBuffer { 36 | char *buffer; 37 | unsigned int bufferSize; 38 | }; 39 | 40 | class Tokenizer { 41 | public: 42 | Tokenizer(unsigned int nBuffers = 1); 43 | ~Tokenizer(); 44 | 45 | void setString(const char *string); 46 | bool setFile(const char *fileName); 47 | void reset(); 48 | 49 | bool goToNext(BOOLFUNC isAlpha = isAlphabetical); 50 | bool goToNextLine(); 51 | char *next(BOOLFUNC isAlpha = isAlphabetical); 52 | char *nextAfterToken(const char *token, BOOLFUNC isAlpha = isAlphabetical); 53 | char *nextLine(); 54 | private: 55 | char *str; 56 | unsigned int length; 57 | unsigned int start, end; 58 | unsigned int capacity; 59 | 60 | unsigned int currentBuffer; 61 | Array buffers; 62 | 63 | char *getBuffer(unsigned int size); 64 | }; 65 | 66 | #endif // _TOKENIZER_H_ 67 | -------------------------------------------------------------------------------- /RunTest/Framework3/Windows/Resources.aps: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Windows/Resources.aps -------------------------------------------------------------------------------- /RunTest/Framework3/Windows/Resources.rc: -------------------------------------------------------------------------------- 1 | //Microsoft Developer Studio generated resource script. 2 | // 3 | #include "resource.h" 4 | 5 | #define APSTUDIO_READONLY_SYMBOLS 6 | ///////////////////////////////////////////////////////////////////////////// 7 | // 8 | // Generated from the TEXTINCLUDE 2 resource. 9 | // 10 | #include "windows.h" 11 | 12 | ///////////////////////////////////////////////////////////////////////////// 13 | #undef APSTUDIO_READONLY_SYMBOLS 14 | 15 | ///////////////////////////////////////////////////////////////////////////// 16 | // English (U.S.) resources 17 | 18 | #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) 19 | #ifdef _WIN32 20 | LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US 21 | #pragma code_page(1252) 22 | #endif //_WIN32 23 | 24 | ///////////////////////////////////////////////////////////////////////////// 25 | // 26 | // Icon 27 | // 28 | 29 | // Icon with lowest ID value placed first to ensure application icon 30 | // remains consistent on all systems. 31 | IDI_MAINICON ICON DISCARDABLE "mainicon.ico" 32 | #endif // English (U.S.) resources 33 | ///////////////////////////////////////////////////////////////////////////// 34 | 35 | 36 | ///////////////////////////////////////////////////////////////////////////// 37 | // Swedish resources 38 | 39 | #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_SVE) 40 | #ifdef _WIN32 41 | LANGUAGE LANG_SWEDISH, SUBLANG_DEFAULT 42 | #pragma code_page(1252) 43 | #endif //_WIN32 44 | 45 | #ifdef APSTUDIO_INVOKED 46 | ///////////////////////////////////////////////////////////////////////////// 47 | // 48 | // TEXTINCLUDE 49 | // 50 | 51 | 1 TEXTINCLUDE DISCARDABLE 52 | BEGIN 53 | "resource.h\0" 54 | END 55 | 56 | 2 TEXTINCLUDE DISCARDABLE 57 | BEGIN 58 | "#include ""afxres.h""\r\n" 59 | "\0" 60 | END 61 | 62 | 3 TEXTINCLUDE DISCARDABLE 63 | BEGIN 64 | "\r\n" 65 | "\0" 66 | END 67 | 68 | #endif // APSTUDIO_INVOKED 69 | 70 | #endif // Swedish resources 71 | ///////////////////////////////////////////////////////////////////////////// 72 | 73 | 74 | 75 | #ifndef APSTUDIO_INVOKED 76 | ///////////////////////////////////////////////////////////////////////////// 77 | // 78 | // Generated from the TEXTINCLUDE 3 resource. 79 | // 80 | 81 | 82 | ///////////////////////////////////////////////////////////////////////////// 83 | #endif // not APSTUDIO_INVOKED 84 | 85 | -------------------------------------------------------------------------------- /RunTest/Framework3/Windows/mainicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/Windows/mainicon.ico -------------------------------------------------------------------------------- /RunTest/Framework3/Windows/resource.h: -------------------------------------------------------------------------------- 1 | //{{NO_DEPENDENCIES}} 2 | // Microsoft Developer Studio generated include file. 3 | // Used by Resources.rc 4 | // 5 | #define IDI_MAINICON 101 6 | 7 | // Next default values for new objects 8 | // 9 | #ifdef APSTUDIO_INVOKED 10 | #ifndef APSTUDIO_READONLY_SYMBOLS 11 | #define _APS_NEXT_RESOURCE_VALUE 110 12 | #define _APS_NEXT_COMMAND_VALUE 40001 13 | #define _APS_NEXT_CONTROL_VALUE 1000 14 | #define _APS_NEXT_SYMED_VALUE 101 15 | #endif 16 | #endif 17 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/_fixes.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/_fixes.hpp 3 | 4 | #include 5 | 6 | //! Workaround for compatibility with other libraries 7 | #ifdef max 8 | #undef max 9 | #endif 10 | 11 | //! Workaround for compatibility with other libraries 12 | #ifdef min 13 | #undef min 14 | #endif 15 | 16 | //! Workaround for Android 17 | #ifdef isnan 18 | #undef isnan 19 | #endif 20 | 21 | //! Workaround for Android 22 | #ifdef isinf 23 | #undef isinf 24 | #endif 25 | 26 | //! Workaround for Chrone Native Client 27 | #ifdef log2 28 | #undef log2 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/_noise.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/_noise.hpp 3 | 4 | #pragma once 5 | 6 | #include "../vec2.hpp" 7 | #include "../vec3.hpp" 8 | #include "../vec4.hpp" 9 | #include "../common.hpp" 10 | 11 | namespace glm{ 12 | namespace detail 13 | { 14 | template 15 | GLM_FUNC_QUALIFIER T mod289(T const& x) 16 | { 17 | return x - floor(x * (static_cast(1.0) / static_cast(289.0))) * static_cast(289.0); 18 | } 19 | 20 | template 21 | GLM_FUNC_QUALIFIER T permute(T const& x) 22 | { 23 | return mod289(((x * static_cast(34)) + static_cast(1)) * x); 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x) 28 | { 29 | return mod289(((x * static_cast(34)) + static_cast(1)) * x); 30 | } 31 | 32 | template 33 | GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x) 34 | { 35 | return mod289(((x * static_cast(34)) + static_cast(1)) * x); 36 | } 37 | 38 | template 39 | GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x) 40 | { 41 | return mod289(((x * static_cast(34)) + static_cast(1)) * x); 42 | } 43 | 44 | template 45 | GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r) 46 | { 47 | return T(1.79284291400159) - T(0.85373472095314) * r; 48 | } 49 | 50 | template 51 | GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r) 52 | { 53 | return T(1.79284291400159) - T(0.85373472095314) * r; 54 | } 55 | 56 | template 57 | GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r) 58 | { 59 | return T(1.79284291400159) - T(0.85373472095314) * r; 60 | } 61 | 62 | template 63 | GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r) 64 | { 65 | return T(1.79284291400159) - T(0.85373472095314) * r; 66 | } 67 | 68 | template 69 | GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t) 70 | { 71 | return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); 72 | } 73 | 74 | template 75 | GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t) 76 | { 77 | return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); 78 | } 79 | 80 | template 81 | GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t) 82 | { 83 | return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); 84 | } 85 | }//namespace detail 86 | }//namespace glm 87 | 88 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/compute_vector_relational.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "setup.hpp" 4 | #include 5 | #include 6 | 7 | namespace glm{ 8 | namespace detail 9 | { 10 | template ::is_iec559> 11 | struct compute_equal 12 | { 13 | GLM_FUNC_QUALIFIER static bool call(T a, T b) 14 | { 15 | return a == b; 16 | } 17 | }; 18 | 19 | template 20 | struct compute_equal 21 | { 22 | GLM_FUNC_QUALIFIER static bool call(T a, T b) 23 | { 24 | return std::memcmp(&a, &b, sizeof(T)) == 0; 25 | } 26 | }; 27 | }//namespace detail 28 | }//namespace glm 29 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/func_exponential_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_exponential_simd.inl 3 | 4 | #include "../simd/exponential.h" 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | template 12 | struct compute_sqrt<4, float, Q, true> 13 | { 14 | GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) 15 | { 16 | vec<4, float, Q> Result; 17 | Result.data = _mm_sqrt_ps(v.data); 18 | return Result; 19 | } 20 | }; 21 | 22 | template<> 23 | struct compute_sqrt<4, float, aligned_lowp, true> 24 | { 25 | GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v) 26 | { 27 | vec<4, float, aligned_lowp> Result; 28 | Result.data = glm_vec4_sqrt_lowp(v.data); 29 | return Result; 30 | } 31 | }; 32 | }//namespace detail 33 | }//namespace glm 34 | 35 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 36 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/func_integer_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_integer_simd.inl 3 | 4 | #include "../simd/integer.h" 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | template 12 | struct compute_bitfieldReverseStep<4, uint32, Q, true, true> 13 | { 14 | GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v, uint32 Mask, uint32 Shift) 15 | { 16 | __m128i const set0 = v.data; 17 | 18 | __m128i const set1 = _mm_set1_epi32(static_cast(Mask)); 19 | __m128i const and1 = _mm_and_si128(set0, set1); 20 | __m128i const sft1 = _mm_slli_epi32(and1, Shift); 21 | 22 | __m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1)); 23 | __m128i const and2 = _mm_and_si128(set0, set2); 24 | __m128i const sft2 = _mm_srai_epi32(and2, Shift); 25 | 26 | __m128i const or0 = _mm_or_si128(sft1, sft2); 27 | 28 | return or0; 29 | } 30 | }; 31 | 32 | template 33 | struct compute_bitfieldBitCountStep<4, uint32, Q, true, true> 34 | { 35 | GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v, uint32 Mask, uint32 Shift) 36 | { 37 | __m128i const set0 = v.data; 38 | 39 | __m128i const set1 = _mm_set1_epi32(static_cast(Mask)); 40 | __m128i const and0 = _mm_and_si128(set0, set1); 41 | __m128i const sft0 = _mm_slli_epi32(set0, Shift); 42 | __m128i const and1 = _mm_and_si128(sft0, set1); 43 | __m128i const add0 = _mm_add_epi32(and0, and1); 44 | 45 | return add0; 46 | } 47 | }; 48 | }//namespace detail 49 | 50 | # if GLM_ARCH & GLM_ARCH_AVX_BIT 51 | template<> 52 | GLM_FUNC_QUALIFIER int bitCount(uint32 x) 53 | { 54 | return _mm_popcnt_u32(x); 55 | } 56 | 57 | # if(GLM_MODEL == GLM_MODEL_64) 58 | template<> 59 | GLM_FUNC_QUALIFIER int bitCount(uint64 x) 60 | { 61 | return static_cast(_mm_popcnt_u64(x)); 62 | } 63 | # endif//GLM_MODEL 64 | # endif//GLM_ARCH 65 | 66 | }//namespace glm 67 | 68 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 69 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_packing_simd.inl 3 | 4 | namespace glm{ 5 | namespace detail 6 | { 7 | 8 | }//namespace detail 9 | }//namespace glm 10 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_vector_relational_simd.inl 3 | 4 | namespace glm{ 5 | namespace detail 6 | { 7 | 8 | }//namespace detail 9 | }//namespace glm 10 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/type_half.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_half.hpp 3 | 4 | #pragma once 5 | 6 | #include "setup.hpp" 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | typedef short hdata; 12 | 13 | GLM_FUNC_DECL float toFloat32(hdata value); 14 | GLM_FUNC_DECL hdata toFloat16(float const& value); 15 | 16 | }//namespace detail 17 | }//namespace glm 18 | 19 | #include "type_half.inl" 20 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/type_mat.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_mat.inl 3 | 4 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_mat4x4_sse2.inl 3 | 4 | namespace glm 5 | { 6 | 7 | }//namespace glm 8 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/type_vec.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_vec.inl 3 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/detail/type_vec1.hpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/glm/detail/type_vec1.hpp -------------------------------------------------------------------------------- /RunTest/Framework3/glm/ext/vec1.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/glm/ext/vec1.inl -------------------------------------------------------------------------------- /RunTest/Framework3/glm/ext/vector_relational.inl: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_relational 2 | /// @file glm/ext/vector_relational.inl 3 | 4 | // Dependency: 5 | #include "../vector_relational.hpp" 6 | #include "../common.hpp" 7 | #include "../detail/type_vec.hpp" 8 | 9 | namespace glm 10 | { 11 | template 12 | GLM_FUNC_QUALIFIER bool equal(genType const& x, genType const& y, genType const& epsilon) 13 | { 14 | return abs(x - y) < epsilon; 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER vec equal(vec const& x, vec const& y, T const& epsilon) 19 | { 20 | return lessThan(abs(x - y), vec(epsilon)); 21 | } 22 | 23 | template 24 | GLM_FUNC_QUALIFIER vec equal(vec const& x, vec const& y, vec const& epsilon) 25 | { 26 | return lessThan(abs(x - y), epsilon); 27 | } 28 | 29 | template 30 | GLM_FUNC_QUALIFIER bool notEqual(genType const& x, genType const& y, genType const& epsilon) 31 | { 32 | return abs(x - y) >= epsilon; 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER vec notEqual(vec const& x, vec const& y, T const& epsilon) 37 | { 38 | return greaterThanEqual(abs(x - y), vec(epsilon)); 39 | } 40 | 41 | template 42 | GLM_FUNC_QUALIFIER vec notEqual(vec const& x, vec const& y, vec const& epsilon) 43 | { 44 | return greaterThanEqual(abs(x - y), epsilon); 45 | } 46 | }//namespace glm 47 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/color_space.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_color_space 2 | /// @file glm/gtc/color_space.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_color_space (dependence) 6 | /// 7 | /// @defgroup gtc_color_space GLM_GTC_color_space 8 | /// @ingroup gtc 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Allow to perform bit operations on integer values 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | #include "../exponential.hpp" 20 | #include "../vec3.hpp" 21 | #include "../vec4.hpp" 22 | #include 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTC_color_space extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtc_color_space 31 | /// @{ 32 | 33 | /// Convert a linear color to sRGB color using a standard gamma correction. 34 | /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 35 | template 36 | GLM_FUNC_DECL vec convertLinearToSRGB(vec const& ColorLinear); 37 | 38 | /// Convert a linear color to sRGB color using a custom gamma correction. 39 | /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 40 | template 41 | GLM_FUNC_DECL vec convertLinearToSRGB(vec const& ColorLinear, T Gamma); 42 | 43 | /// Convert a sRGB color to linear color using a standard gamma correction. 44 | /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 45 | template 46 | GLM_FUNC_DECL vec convertSRGBToLinear(vec const& ColorSRGB); 47 | 48 | /// Convert a sRGB color to linear color using a custom gamma correction. 49 | // IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 50 | template 51 | GLM_FUNC_DECL vec convertSRGBToLinear(vec const& ColorSRGB, T Gamma); 52 | 53 | /// @} 54 | } //namespace glm 55 | 56 | #include "color_space.inl" 57 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/epsilon.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_epsilon 2 | /// @file glm/gtc/epsilon.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_quaternion (dependence) 6 | /// 7 | /// @defgroup gtc_epsilon GLM_GTC_epsilon 8 | /// @ingroup gtc 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Comparison functions for a user defined epsilon values. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTC_epsilon extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtc_epsilon 27 | /// @{ 28 | 29 | /// Returns the component-wise comparison of |x - y| < epsilon. 30 | /// True if this expression is satisfied. 31 | /// 32 | /// @see gtc_epsilon 33 | template 34 | GLM_FUNC_DECL vec epsilonEqual(vec const& x, vec const& y, T const& epsilon); 35 | 36 | /// Returns the component-wise comparison of |x - y| < epsilon. 37 | /// True if this expression is satisfied. 38 | /// 39 | /// @see gtc_epsilon 40 | template 41 | GLM_FUNC_DECL bool epsilonEqual(genType const& x, genType const& y, genType const& epsilon); 42 | 43 | /// Returns the component-wise comparison of |x - y| < epsilon. 44 | /// True if this expression is not satisfied. 45 | /// 46 | /// @see gtc_epsilon 47 | template 48 | GLM_FUNC_DECL vec epsilonNotEqual(vec const& x, vec const& y, T const& epsilon); 49 | 50 | /// Returns the component-wise comparison of |x - y| >= epsilon. 51 | /// True if this expression is not satisfied. 52 | /// 53 | /// @see gtc_epsilon 54 | template 55 | GLM_FUNC_DECL bool epsilonNotEqual(genType const& x, genType const& y, genType const& epsilon); 56 | 57 | /// @} 58 | }//namespace glm 59 | 60 | #include "epsilon.inl" 61 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/integer.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_integer 2 | /// @file glm/gtc/integer.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_integer (dependence) 6 | /// 7 | /// @defgroup gtc_integer GLM_GTC_integer 8 | /// @ingroup gtc 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// @brief Allow to perform bit operations on integer values 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | #include "../common.hpp" 20 | #include "../integer.hpp" 21 | #include "../exponential.hpp" 22 | #include 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTC_integer extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtc_integer 31 | /// @{ 32 | 33 | /// Returns the log2 of x for integer values. Can be reliably using to compute mipmap count from the texture size. 34 | /// @see gtc_integer 35 | template 36 | GLM_FUNC_DECL genIUType log2(genIUType x); 37 | 38 | /// Returns a value equal to the nearest integer to x. 39 | /// The fraction 0.5 will round in a direction chosen by the 40 | /// implementation, presumably the direction that is fastest. 41 | /// 42 | /// @param x The values of the argument must be greater or equal to zero. 43 | /// @tparam T floating point scalar types. 44 | /// 45 | /// @see GLSL round man page 46 | /// @see gtc_integer 47 | template 48 | GLM_FUNC_DECL vec iround(vec const& x); 49 | 50 | /// Returns a value equal to the nearest integer to x. 51 | /// The fraction 0.5 will round in a direction chosen by the 52 | /// implementation, presumably the direction that is fastest. 53 | /// 54 | /// @param x The values of the argument must be greater or equal to zero. 55 | /// @tparam T floating point scalar types. 56 | /// 57 | /// @see GLSL round man page 58 | /// @see gtc_integer 59 | template 60 | GLM_FUNC_DECL vec uround(vec const& x); 61 | 62 | /// @} 63 | } //namespace glm 64 | 65 | #include "integer.inl" 66 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/matrix_access.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_access 2 | /// @file glm/gtc/matrix_access.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_matrix_access GLM_GTC_matrix_access 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines functions to access rows or columns of a matrix easily. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../detail/setup.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_GTC_matrix_access extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup gtc_matrix_access 25 | /// @{ 26 | 27 | /// Get a specific row of a matrix. 28 | /// @see gtc_matrix_access 29 | template 30 | GLM_FUNC_DECL typename genType::row_type row( 31 | genType const& m, 32 | length_t index); 33 | 34 | /// Set a specific row to a matrix. 35 | /// @see gtc_matrix_access 36 | template 37 | GLM_FUNC_DECL genType row( 38 | genType const& m, 39 | length_t index, 40 | typename genType::row_type const& x); 41 | 42 | /// Get a specific column of a matrix. 43 | /// @see gtc_matrix_access 44 | template 45 | GLM_FUNC_DECL typename genType::col_type column( 46 | genType const& m, 47 | length_t index); 48 | 49 | /// Set a specific column to a matrix. 50 | /// @see gtc_matrix_access 51 | template 52 | GLM_FUNC_DECL genType column( 53 | genType const& m, 54 | length_t index, 55 | typename genType::col_type const& x); 56 | 57 | /// @} 58 | }//namespace glm 59 | 60 | #include "matrix_access.inl" 61 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/matrix_access.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_access 2 | /// @file glm/gtc/matrix_access.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType row 8 | ( 9 | genType const& m, 10 | length_t index, 11 | typename genType::row_type const& x 12 | ) 13 | { 14 | assert(index >= 0 && index < m[0].length()); 15 | 16 | genType Result = m; 17 | for(length_t i = 0; i < m.length(); ++i) 18 | Result[i][index] = x[i]; 19 | return Result; 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER typename genType::row_type row 24 | ( 25 | genType const& m, 26 | length_t index 27 | ) 28 | { 29 | assert(index >= 0 && index < m[0].length()); 30 | 31 | typename genType::row_type Result(0); 32 | for(length_t i = 0; i < m.length(); ++i) 33 | Result[i] = m[i][index]; 34 | return Result; 35 | } 36 | 37 | template 38 | GLM_FUNC_QUALIFIER genType column 39 | ( 40 | genType const& m, 41 | length_t index, 42 | typename genType::col_type const& x 43 | ) 44 | { 45 | assert(index >= 0 && index < m.length()); 46 | 47 | genType Result = m; 48 | Result[index] = x; 49 | return Result; 50 | } 51 | 52 | template 53 | GLM_FUNC_QUALIFIER typename genType::col_type column 54 | ( 55 | genType const& m, 56 | length_t index 57 | ) 58 | { 59 | assert(index >= 0 && index < m.length()); 60 | 61 | return m[index]; 62 | } 63 | }//namespace glm 64 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/matrix_inverse.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_inverse 2 | /// @file glm/gtc/matrix_inverse.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines additional matrix inverting functions. 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | #include "../matrix.hpp" 18 | #include "../mat2x2.hpp" 19 | #include "../mat3x3.hpp" 20 | #include "../mat4x4.hpp" 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTC_matrix_inverse extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtc_matrix_inverse 29 | /// @{ 30 | 31 | /// Fast matrix inverse for affine matrix. 32 | /// 33 | /// @param m Input matrix to invert. 34 | /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. 35 | /// @see gtc_matrix_inverse 36 | template 37 | GLM_FUNC_DECL genType affineInverse(genType const& m); 38 | 39 | /// Compute the inverse transpose of a matrix. 40 | /// 41 | /// @param m Input matrix to invert transpose. 42 | /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. 43 | /// @see gtc_matrix_inverse 44 | template 45 | GLM_FUNC_DECL genType inverseTranspose(genType const& m); 46 | 47 | /// @} 48 | }//namespace glm 49 | 50 | #include "matrix_inverse.inl" 51 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/noise.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_noise 2 | /// @file glm/gtc/noise.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_noise GLM_GTC_noise 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines 2D, 3D and 4D procedural noise functions 12 | /// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 13 | /// https://github.com/ashima/webgl-noise 14 | /// Following Stefan Gustavson's paper "Simplex noise demystified": 15 | /// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf 16 | 17 | #pragma once 18 | 19 | // Dependencies 20 | #include "../detail/setup.hpp" 21 | #include "../detail/qualifier.hpp" 22 | #include "../detail/_noise.hpp" 23 | #include "../geometric.hpp" 24 | #include "../common.hpp" 25 | #include "../vector_relational.hpp" 26 | #include "../vec2.hpp" 27 | #include "../vec3.hpp" 28 | #include "../vec4.hpp" 29 | 30 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 31 | # pragma message("GLM: GLM_GTC_noise extension included") 32 | #endif 33 | 34 | namespace glm 35 | { 36 | /// @addtogroup gtc_noise 37 | /// @{ 38 | 39 | /// Classic perlin noise. 40 | /// @see gtc_noise 41 | template 42 | GLM_FUNC_DECL T perlin( 43 | vec const& p); 44 | 45 | /// Periodic perlin noise. 46 | /// @see gtc_noise 47 | template 48 | GLM_FUNC_DECL T perlin( 49 | vec const& p, 50 | vec const& rep); 51 | 52 | /// Simplex noise. 53 | /// @see gtc_noise 54 | template 55 | GLM_FUNC_DECL T simplex( 56 | vec const& p); 57 | 58 | /// @} 59 | }//namespace glm 60 | 61 | #include "noise.inl" 62 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_swizzle 2 | /// @file glm/gtc/swizzle.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/ulp.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_ulp 2 | /// @file glm/gtc/ulp.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_ulp GLM_GTC_ulp 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Allow the measurement of the accuracy of a function against a reference 12 | /// implementation. This extension works on floating-point data and provide results 13 | /// in ULP. 14 | 15 | #pragma once 16 | 17 | // Dependencies 18 | #include "../detail/setup.hpp" 19 | #include "../detail/qualifier.hpp" 20 | #include "../detail/type_int.hpp" 21 | #include "../detail/compute_vector_relational.hpp" 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTC_ulp extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtc_ulp 30 | /// @{ 31 | 32 | /// Return the next ULP value(s) after the input value(s). 33 | /// @see gtc_ulp 34 | template 35 | GLM_FUNC_DECL genType next_float(genType const& x); 36 | 37 | /// Return the previous ULP value(s) before the input value(s). 38 | /// @see gtc_ulp 39 | template 40 | GLM_FUNC_DECL genType prev_float(genType const& x); 41 | 42 | /// Return the value(s) ULP distance after the input value(s). 43 | /// @see gtc_ulp 44 | template 45 | GLM_FUNC_DECL genType next_float(genType const& x, uint const& Distance); 46 | 47 | /// Return the value(s) ULP distance before the input value(s). 48 | /// @see gtc_ulp 49 | template 50 | GLM_FUNC_DECL genType prev_float(genType const& x, uint const& Distance); 51 | 52 | /// Return the distance in the number of ULP between 2 scalars. 53 | /// @see gtc_ulp 54 | template 55 | GLM_FUNC_DECL uint float_distance(T const& x, T const& y); 56 | 57 | /// Return the distance in the number of ULP between 2 vectors. 58 | /// @see gtc_ulp 59 | template 60 | GLM_FUNC_DECL vec<2, uint, Q> float_distance(vec<2, T, Q> const& x, vec<2, T, Q> const& y); 61 | 62 | /// @} 63 | }// namespace glm 64 | 65 | #include "ulp.inl" 66 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/vec1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_vec1 2 | /// @file glm/gtc/vec1.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_vec1 GLM_GTC_vec1 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Add vec1, ivec1, uvec1 and bvec1 types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../ext/vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_GTC_vec1 extension included") 20 | #endif 21 | 22 | #include "vec1.inl" 23 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtc/vec1.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_vec1 2 | /// @file glm/gtc/vec1.inl 3 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/closest_point.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_closest_point 2 | /// @file glm/gtx/closest_point.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_closest_point GLM_GTX_closest_point 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Find the point on a straight line which is the closet of a point. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_closest_point extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_closest_point 29 | /// @{ 30 | 31 | /// Find the point on a straight line which is the closet of a point. 32 | /// @see gtx_closest_point 33 | template 34 | GLM_FUNC_DECL vec<3, T, Q> closestPointOnLine( 35 | vec<3, T, Q> const& point, 36 | vec<3, T, Q> const& a, 37 | vec<3, T, Q> const& b); 38 | 39 | /// 2d lines work as well 40 | template 41 | GLM_FUNC_DECL vec<2, T, Q> closestPointOnLine( 42 | vec<2, T, Q> const& point, 43 | vec<2, T, Q> const& a, 44 | vec<2, T, Q> const& b); 45 | 46 | /// @} 47 | }// namespace glm 48 | 49 | #include "closest_point.inl" 50 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/closest_point.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_closest_point 2 | /// @file glm/gtx/closest_point.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, Q> closestPointOnLine 8 | ( 9 | vec<3, T, Q> const& point, 10 | vec<3, T, Q> const& a, 11 | vec<3, T, Q> const& b 12 | ) 13 | { 14 | T LineLength = distance(a, b); 15 | vec<3, T, Q> Vector = point - a; 16 | vec<3, T, Q> LineDirection = (b - a) / LineLength; 17 | 18 | // Project Vector to LineDirection to get the distance of point from a 19 | T Distance = dot(Vector, LineDirection); 20 | 21 | if(Distance <= T(0)) return a; 22 | if(Distance >= LineLength) return b; 23 | return a + LineDirection * Distance; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER vec<2, T, Q> closestPointOnLine 28 | ( 29 | vec<2, T, Q> const& point, 30 | vec<2, T, Q> const& a, 31 | vec<2, T, Q> const& b 32 | ) 33 | { 34 | T LineLength = distance(a, b); 35 | vec<2, T, Q> Vector = point - a; 36 | vec<2, T, Q> LineDirection = (b - a) / LineLength; 37 | 38 | // Project Vector to LineDirection to get the distance of point from a 39 | T Distance = dot(Vector, LineDirection); 40 | 41 | if(Distance <= T(0)) return a; 42 | if(Distance >= LineLength) return b; 43 | return a + LineDirection * Distance; 44 | } 45 | 46 | }//namespace glm 47 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/color_encoding.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_encoding 2 | /// @file glm/gtx/color_encoding.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_color_encoding (dependence) 6 | /// 7 | /// @defgroup gtx_color_encoding GLM_GTX_color_encoding 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// @brief Allow to perform bit operations on integer values 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | #include "../vec3.hpp" 20 | #include 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTC_color_encoding extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_encoding 29 | /// @{ 30 | 31 | /// Convert a linear sRGB color to D65 YUV. 32 | template 33 | GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB); 34 | 35 | /// Convert a linear sRGB color to D50 YUV. 36 | template 37 | GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB); 38 | 39 | /// Convert a D65 YUV color to linear sRGB. 40 | template 41 | GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ); 42 | 43 | /// Convert a D65 YUV color to D50 YUV. 44 | template 45 | GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ); 46 | 47 | /// @} 48 | } //namespace glm 49 | 50 | #include "color_encoding.inl" 51 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/color_encoding.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_encoding 2 | /// @file glm/gtx/color_encoding.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB) 8 | { 9 | vec<3, T, Q> const M(0.490f, 0.17697f, 0.2f); 10 | vec<3, T, Q> const N(0.31f, 0.8124f, 0.01063f); 11 | vec<3, T, Q> const O(0.490f, 0.01f, 0.99f); 12 | 13 | return (M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB) * static_cast(5.650675255693055f); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB) 18 | { 19 | vec<3, T, Q> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f); 20 | vec<3, T, Q> const N(0.385101860087134f, 0.716942745571917f, 0.097076381494207f); 21 | vec<3, T, Q> const O(0.143067806654203f, 0.060618777416563f, 0.713926257896652f); 22 | 23 | return M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ) 28 | { 29 | vec<3, T, Q> const M(0.41847f, -0.091169f, 0.0009209f); 30 | vec<3, T, Q> const N(-0.15866f, 0.25243f, 0.015708f); 31 | vec<3, T, Q> const O(0.0009209f, -0.0025498f, 0.1786f); 32 | 33 | return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ) 38 | { 39 | vec<3, T, Q> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f); 40 | vec<3, T, Q> const N(+0.022898981050086f, +0.990508028941971f, +0.015072338237051f); 41 | vec<3, T, Q> const O(-0.050206647741605f, -0.017074711360960f, +0.751717835079977f); 42 | 43 | return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; 44 | } 45 | 46 | }//namespace glm 47 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/color_space.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_space 2 | /// @file glm/gtx/color_space.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_color_space GLM_GTX_color_space 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Related to RGB to HSV conversions and operations. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_color_space extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_space 29 | /// @{ 30 | 31 | /// Converts a color from HSV color space to its color in RGB color space. 32 | /// @see gtx_color_space 33 | template 34 | GLM_FUNC_DECL vec<3, T, Q> rgbColor( 35 | vec<3, T, Q> const& hsvValue); 36 | 37 | /// Converts a color from RGB color space to its color in HSV color space. 38 | /// @see gtx_color_space 39 | template 40 | GLM_FUNC_DECL vec<3, T, Q> hsvColor( 41 | vec<3, T, Q> const& rgbValue); 42 | 43 | /// Build a saturation matrix. 44 | /// @see gtx_color_space 45 | template 46 | GLM_FUNC_DECL mat<4, 4, T, defaultp> saturation( 47 | T const s); 48 | 49 | /// Modify the saturation of a color. 50 | /// @see gtx_color_space 51 | template 52 | GLM_FUNC_DECL vec<3, T, Q> saturation( 53 | T const s, 54 | vec<3, T, Q> const& color); 55 | 56 | /// Modify the saturation of a color. 57 | /// @see gtx_color_space 58 | template 59 | GLM_FUNC_DECL vec<4, T, Q> saturation( 60 | T const s, 61 | vec<4, T, Q> const& color); 62 | 63 | /// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals. 64 | /// @see gtx_color_space 65 | template 66 | GLM_FUNC_DECL T luminosity( 67 | vec<3, T, Q> const& color); 68 | 69 | /// @} 70 | }//namespace glm 71 | 72 | #include "color_space.inl" 73 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/color_space_YCoCg.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_space_YCoCg 2 | /// @file glm/gtx/color_space_YCoCg.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// RGB to YCoCg conversions and operations 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_color_space_YCoCg extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_space_YCoCg 29 | /// @{ 30 | 31 | /// Convert a color from RGB color space to YCoCg color space. 32 | /// @see gtx_color_space_YCoCg 33 | template 34 | GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCg( 35 | vec<3, T, Q> const& rgbColor); 36 | 37 | /// Convert a color from YCoCg color space to RGB color space. 38 | /// @see gtx_color_space_YCoCg 39 | template 40 | GLM_FUNC_DECL vec<3, T, Q> YCoCg2rgb( 41 | vec<3, T, Q> const& YCoCgColor); 42 | 43 | /// Convert a color from RGB color space to YCoCgR color space. 44 | /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" 45 | /// @see gtx_color_space_YCoCg 46 | template 47 | GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCgR( 48 | vec<3, T, Q> const& rgbColor); 49 | 50 | /// Convert a color from YCoCgR color space to RGB color space. 51 | /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" 52 | /// @see gtx_color_space_YCoCg 53 | template 54 | GLM_FUNC_DECL vec<3, T, Q> YCoCgR2rgb( 55 | vec<3, T, Q> const& YCoCgColor); 56 | 57 | /// @} 58 | }//namespace glm 59 | 60 | #include "color_space_YCoCg.inl" 61 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/compatibility.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_compatibility 2 | /// @file glm/gtx/compatibility.inl 3 | 4 | #include 5 | 6 | namespace glm 7 | { 8 | // isfinite 9 | template 10 | GLM_FUNC_QUALIFIER bool isfinite( 11 | genType const& x) 12 | { 13 | # if GLM_HAS_CXX11_STL 14 | return std::isfinite(x) != 0; 15 | # elif GLM_COMPILER & GLM_COMPILER_VC 16 | return _finite(x); 17 | # elif GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID 18 | return _isfinite(x) != 0; 19 | # else 20 | if (std::numeric_limits::is_integer || std::denorm_absent == std::numeric_limits::has_denorm) 21 | return std::numeric_limits::min() <= x && std::numeric_limits::max() >= x; 22 | else 23 | return -std::numeric_limits::max() <= x && std::numeric_limits::max() >= x; 24 | # endif 25 | } 26 | 27 | template 28 | GLM_FUNC_QUALIFIER vec<1, bool, Q> isfinite( 29 | vec<1, T, Q> const& x) 30 | { 31 | return vec<1, bool, Q>( 32 | isfinite(x.x)); 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER vec<2, bool, Q> isfinite( 37 | vec<2, T, Q> const& x) 38 | { 39 | return vec<2, bool, Q>( 40 | isfinite(x.x), 41 | isfinite(x.y)); 42 | } 43 | 44 | template 45 | GLM_FUNC_QUALIFIER vec<3, bool, Q> isfinite( 46 | vec<3, T, Q> const& x) 47 | { 48 | return vec<3, bool, Q>( 49 | isfinite(x.x), 50 | isfinite(x.y), 51 | isfinite(x.z)); 52 | } 53 | 54 | template 55 | GLM_FUNC_QUALIFIER vec<4, bool, Q> isfinite( 56 | vec<4, T, Q> const& x) 57 | { 58 | return vec<4, bool, Q>( 59 | isfinite(x.x), 60 | isfinite(x.y), 61 | isfinite(x.z), 62 | isfinite(x.w)); 63 | } 64 | 65 | }//namespace glm 66 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/extend.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_extend 2 | /// @file glm/gtx/extend.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_extend GLM_GTX_extend 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Extend a position from a source to a position at a defined length. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_extend extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_extend 29 | /// @{ 30 | 31 | /// Extends of Length the Origin position using the (Source - Origin) direction. 32 | /// @see gtx_extend 33 | template 34 | GLM_FUNC_DECL genType extend( 35 | genType const& Origin, 36 | genType const& Source, 37 | typename genType::value_type const Length); 38 | 39 | /// @} 40 | }//namespace glm 41 | 42 | #include "extend.inl" 43 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/extend.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_extend 2 | /// @file glm/gtx/extend.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType extend 8 | ( 9 | genType const& Origin, 10 | genType const& Source, 11 | genType const& Distance 12 | ) 13 | { 14 | return Origin + (Source - Origin) * Distance; 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER vec<2, T, Q> extend 19 | ( 20 | vec<2, T, Q> const& Origin, 21 | vec<2, T, Q> const& Source, 22 | T const& Distance 23 | ) 24 | { 25 | return Origin + (Source - Origin) * Distance; 26 | } 27 | 28 | template 29 | GLM_FUNC_QUALIFIER vec<3, T, Q> extend 30 | ( 31 | vec<3, T, Q> const& Origin, 32 | vec<3, T, Q> const& Source, 33 | T const& Distance 34 | ) 35 | { 36 | return Origin + (Source - Origin) * Distance; 37 | } 38 | 39 | template 40 | GLM_FUNC_QUALIFIER vec<4, T, Q> extend 41 | ( 42 | vec<4, T, Q> const& Origin, 43 | vec<4, T, Q> const& Source, 44 | T const& Distance 45 | ) 46 | { 47 | return Origin + (Source - Origin) * Distance; 48 | } 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/exterior_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_exterior_product 2 | /// @file glm/gtx/exterior_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_exterior_product (dependence) 6 | /// 7 | /// @defgroup gtx_exterior_product GLM_GTX_exterior_product 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// @brief Allow to perform bit operations on integer values 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTX_exterior_product extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtx_exterior_product 27 | /// @{ 28 | 29 | /// Returns the cross product of x and y. 30 | /// 31 | /// @tparam T Floating-point scalar types 32 | /// @tparam Q Value from qualifier enum 33 | /// 34 | /// @see Exterior product 35 | template 36 | GLM_FUNC_DECL T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u); 37 | 38 | /// @} 39 | } //namespace glm 40 | 41 | #include "exterior_product.inl" 42 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/exterior_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_geometric.inl 3 | 4 | #include 5 | 6 | namespace glm { 7 | namespace detail 8 | { 9 | template 10 | struct compute_cross_vec2 11 | { 12 | GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) 13 | { 14 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); 15 | 16 | return v.x * u.y - u.x * v.y; 17 | } 18 | }; 19 | }//namespace detail 20 | 21 | template 22 | GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y) 23 | { 24 | return detail::compute_cross_vec2::value>::call(x, y); 25 | } 26 | }//namespace glm 27 | 28 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/float_notmalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_float_normalize 2 | /// @file glm/gtx/float_normalize.inl 3 | 4 | #include 5 | 6 | namespace glm 7 | { 8 | template 9 | GLM_FUNC_QUALIFIER vec floatNormalize(vec const& v) 10 | { 11 | return vec(v) / static_cast(std::numeric_limits::max()); 12 | } 13 | 14 | }//namespace glm 15 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/functions.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_functions 2 | /// @file glm/gtx/functions.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_quaternion (dependence) 6 | /// 7 | /// @defgroup gtx_functions GLM_GTX_functions 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// List of useful common functions. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | #include "../detail/type_vec2.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 22 | # pragma message("GLM: GLM_GTX_functions extension included") 23 | #endif 24 | 25 | namespace glm 26 | { 27 | /// @addtogroup gtx_functions 28 | /// @{ 29 | 30 | /// 1D gauss function 31 | /// 32 | /// @see gtc_epsilon 33 | template 34 | GLM_FUNC_DECL T gauss( 35 | T x, 36 | T ExpectedValue, 37 | T StandardDeviation); 38 | 39 | /// 2D gauss function 40 | /// 41 | /// @see gtc_epsilon 42 | template 43 | GLM_FUNC_DECL T gauss( 44 | vec<2, T, Q> const& Coord, 45 | vec<2, T, Q> const& ExpectedValue, 46 | vec<2, T, Q> const& StandardDeviation); 47 | 48 | /// @} 49 | }//namespace glm 50 | 51 | #include "functions.inl" 52 | 53 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/functions.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_functions 2 | /// @file glm/gtx/functions.inl 3 | 4 | #include "../exponential.hpp" 5 | 6 | namespace glm 7 | { 8 | template 9 | GLM_FUNC_QUALIFIER T gauss 10 | ( 11 | T x, 12 | T ExpectedValue, 13 | T StandardDeviation 14 | ) 15 | { 16 | return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER T gauss 21 | ( 22 | vec<2, T, Q> const& Coord, 23 | vec<2, T, Q> const& ExpectedValue, 24 | vec<2, T, Q> const& StandardDeviation 25 | ) 26 | { 27 | vec<2, T, Q> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation); 28 | return exp(-(Squared.x + Squared.y)); 29 | } 30 | }//namespace glm 31 | 32 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/gradient_paint.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | /// @file glm/gtx/gradient_paint.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_optimum_pow (dependence) 6 | /// 7 | /// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Functions that return the color of procedural gradient for specific coordinates. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include "../gtx/optimum_pow.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_gradient_paint is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 22 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_gradient_paint extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_gradient_paint 31 | /// @{ 32 | 33 | /// Return a color from a radial gradient. 34 | /// @see - gtx_gradient_paint 35 | template 36 | GLM_FUNC_DECL T radialGradient( 37 | vec<2, T, Q> const& Center, 38 | T const& Radius, 39 | vec<2, T, Q> const& Focal, 40 | vec<2, T, Q> const& Position); 41 | 42 | /// Return a color from a linear gradient. 43 | /// @see - gtx_gradient_paint 44 | template 45 | GLM_FUNC_DECL T linearGradient( 46 | vec<2, T, Q> const& Point0, 47 | vec<2, T, Q> const& Point1, 48 | vec<2, T, Q> const& Position); 49 | 50 | /// @} 51 | }// namespace glm 52 | 53 | #include "gradient_paint.inl" 54 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/gradient_paint.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | /// @file glm/gtx/gradient_paint.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER T radialGradient 8 | ( 9 | vec<2, T, Q> const& Center, 10 | T const& Radius, 11 | vec<2, T, Q> const& Focal, 12 | vec<2, T, Q> const& Position 13 | ) 14 | { 15 | vec<2, T, Q> F = Focal - Center; 16 | vec<2, T, Q> D = Position - Focal; 17 | T Radius2 = pow2(Radius); 18 | T Fx2 = pow2(F.x); 19 | T Fy2 = pow2(F.y); 20 | 21 | 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)); 22 | T Denominator = Radius2 - (Fx2 + Fy2); 23 | return Numerator / Denominator; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER T linearGradient 28 | ( 29 | vec<2, T, Q> const& Point0, 30 | vec<2, T, Q> const& Point1, 31 | vec<2, T, Q> const& Position 32 | ) 33 | { 34 | vec<2, T, Q> Dist = Point1 - Point0; 35 | return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist); 36 | } 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/handed_coordinate_space.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | /// @file glm/gtx/handed_coordinate_space.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// To know if a set of three basis vectors defines a right or left-handed coordinate system. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_handed_coordinate_space extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_handed_coordinate_space 29 | /// @{ 30 | 31 | //! Return if a trihedron right handed or not. 32 | //! From GLM_GTX_handed_coordinate_space extension. 33 | template 34 | GLM_FUNC_DECL bool rightHanded( 35 | vec<3, T, Q> const& tangent, 36 | vec<3, T, Q> const& binormal, 37 | vec<3, T, Q> const& normal); 38 | 39 | //! Return if a trihedron left handed or not. 40 | //! From GLM_GTX_handed_coordinate_space extension. 41 | template 42 | GLM_FUNC_DECL bool leftHanded( 43 | vec<3, T, Q> const& tangent, 44 | vec<3, T, Q> const& binormal, 45 | vec<3, T, Q> const& normal); 46 | 47 | /// @} 48 | }// namespace glm 49 | 50 | #include "handed_coordinate_space.inl" 51 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/handed_coordinate_space.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | /// @file glm/gtx/handed_coordinate_space.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER bool rightHanded 8 | ( 9 | vec<3, T, Q> const& tangent, 10 | vec<3, T, Q> const& binormal, 11 | vec<3, T, Q> const& normal 12 | ) 13 | { 14 | return dot(cross(normal, tangent), binormal) > T(0); 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER bool leftHanded 19 | ( 20 | vec<3, T, Q> const& tangent, 21 | vec<3, T, Q> const& binormal, 22 | vec<3, T, Q> const& normal 23 | ) 24 | { 25 | return dot(cross(normal, tangent), binormal) < T(0); 26 | } 27 | }//namespace glm 28 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/integer.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_integer 2 | /// @file glm/gtx/integer.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_integer GLM_GTX_integer 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Add support for integer for core functions 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtc/integer.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "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." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_integer extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_integer 30 | /// @{ 31 | 32 | //! Returns x raised to the y power. 33 | //! From GLM_GTX_integer extension. 34 | GLM_FUNC_DECL int pow(int x, uint y); 35 | 36 | //! Returns the positive square root of x. 37 | //! From GLM_GTX_integer extension. 38 | GLM_FUNC_DECL int sqrt(int x); 39 | 40 | //! Returns the floor log2 of x. 41 | //! From GLM_GTX_integer extension. 42 | GLM_FUNC_DECL unsigned int floor_log2(unsigned int x); 43 | 44 | //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. 45 | //! From GLM_GTX_integer extension. 46 | GLM_FUNC_DECL int mod(int x, int y); 47 | 48 | //! Return the factorial value of a number (!12 max, integer only) 49 | //! From GLM_GTX_integer extension. 50 | template 51 | GLM_FUNC_DECL genType factorial(genType const& x); 52 | 53 | //! 32bit signed integer. 54 | //! From GLM_GTX_integer extension. 55 | typedef signed int sint; 56 | 57 | //! Returns x raised to the y power. 58 | //! From GLM_GTX_integer extension. 59 | GLM_FUNC_DECL uint pow(uint x, uint y); 60 | 61 | //! Returns the positive square root of x. 62 | //! From GLM_GTX_integer extension. 63 | GLM_FUNC_DECL uint sqrt(uint x); 64 | 65 | //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. 66 | //! From GLM_GTX_integer extension. 67 | GLM_FUNC_DECL uint mod(uint x, uint y); 68 | 69 | //! Returns the number of leading zeros. 70 | //! From GLM_GTX_integer extension. 71 | GLM_FUNC_DECL uint nlz(uint x); 72 | 73 | /// @} 74 | }//namespace glm 75 | 76 | #include "integer.inl" 77 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/log_base.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | /// @file glm/gtx/log_base.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_log_base GLM_GTX_log_base 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Logarithm for any base. base can be a vector or a scalar. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_log_base is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_log_base extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_log_base 29 | /// @{ 30 | 31 | /// Logarithm for any base. 32 | /// From GLM_GTX_log_base. 33 | template 34 | GLM_FUNC_DECL genType log( 35 | genType const& x, 36 | genType const& base); 37 | 38 | /// Logarithm for any base. 39 | /// From GLM_GTX_log_base. 40 | template 41 | GLM_FUNC_DECL vec sign( 42 | vec const& x, 43 | vec const& base); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "log_base.inl" 49 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/log_base.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | /// @file glm/gtx/log_base.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base) 8 | { 9 | assert(!detail::compute_equal::call(x, static_cast(0))); 10 | return glm::log(x) / glm::log(base); 11 | } 12 | 13 | template 14 | GLM_FUNC_QUALIFIER vec log(vec const& x, vec const& base) 15 | { 16 | return glm::log(x) / glm::log(base); 17 | } 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/matrix_cross_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | /// @file glm/gtx/matrix_cross_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Build cross product matrices 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_matrix_cross_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_matrix_cross_product extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_matrix_cross_product 30 | /// @{ 31 | 32 | //! Build a cross product matrix. 33 | //! From GLM_GTX_matrix_cross_product extension. 34 | template 35 | GLM_FUNC_DECL mat<3, 3, T, Q> matrixCross3( 36 | vec<3, T, Q> const& x); 37 | 38 | //! Build a cross product matrix. 39 | //! From GLM_GTX_matrix_cross_product extension. 40 | template 41 | GLM_FUNC_DECL mat<4, 4, T, Q> matrixCross4( 42 | vec<3, T, Q> const& x); 43 | 44 | /// @} 45 | }//namespace glm 46 | 47 | #include "matrix_cross_product.inl" 48 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/matrix_cross_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | /// @file glm/gtx/matrix_cross_product.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> matrixCross3 8 | ( 9 | vec<3, T, Q> const& x 10 | ) 11 | { 12 | mat<3, 3, T, Q> Result(T(0)); 13 | Result[0][1] = x.z; 14 | Result[1][0] = -x.z; 15 | Result[0][2] = -x.y; 16 | Result[2][0] = x.y; 17 | Result[1][2] = x.x; 18 | Result[2][1] = -x.x; 19 | return Result; 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> matrixCross4 24 | ( 25 | vec<3, T, Q> const& x 26 | ) 27 | { 28 | mat<4, 4, T, Q> Result(T(0)); 29 | Result[0][1] = x.z; 30 | Result[1][0] = -x.z; 31 | Result[0][2] = -x.y; 32 | Result[2][0] = x.y; 33 | Result[1][2] = x.x; 34 | Result[2][1] = -x.x; 35 | return Result; 36 | } 37 | 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/matrix_decompose.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_decompose 2 | /// @file glm/gtx/matrix_decompose.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Decomposes a model matrix to translations, rotation and scale components 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../mat4x4.hpp" 17 | #include "../vec3.hpp" 18 | #include "../vec4.hpp" 19 | #include "../geometric.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | #include "../gtc/matrix_transform.hpp" 22 | 23 | #ifndef GLM_ENABLE_EXPERIMENTAL 24 | # error "GLM: GLM_GTX_matrix_decompose is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 25 | #endif 26 | 27 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTX_matrix_decompose extension included") 29 | #endif 30 | 31 | namespace glm 32 | { 33 | /// @addtogroup gtx_matrix_decompose 34 | /// @{ 35 | 36 | /// Decomposes a model matrix to translations, rotation and scale components 37 | /// @see gtx_matrix_decompose 38 | template 39 | GLM_FUNC_DECL bool decompose( 40 | mat<4, 4, T, Q> const& modelMatrix, 41 | vec<3, T, Q> & scale, tquat & orientation, vec<3, T, Q> & translation, vec<3, T, Q> & skew, vec<4, T, Q> & perspective); 42 | 43 | /// @} 44 | }//namespace glm 45 | 46 | #include "matrix_decompose.inl" 47 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Framework3/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/matrix_interpolation.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_interpolation 2 | /// @file glm/gtx/matrix_interpolation.hpp 3 | /// @author Ghenadii Ursachi (the.asteroth@gmail.com) 4 | /// 5 | /// @see core (dependence) 6 | /// 7 | /// @defgroup gtx_matrix_interpolation GLM_GTX_matrix_interpolation 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Allows to directly interpolate two matrices. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "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." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_matrix_interpolation extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_matrix_interpolation 30 | /// @{ 31 | 32 | /// Get the axis and angle of the rotation from a matrix. 33 | /// From GLM_GTX_matrix_interpolation extension. 34 | template 35 | GLM_FUNC_DECL void axisAngle( 36 | mat<4, 4, T, Q> const& mat, 37 | vec<3, T, Q> & axis, 38 | T & angle); 39 | 40 | /// Build a matrix from axis and angle. 41 | /// From GLM_GTX_matrix_interpolation extension. 42 | template 43 | GLM_FUNC_DECL mat<4, 4, T, Q> axisAngleMatrix( 44 | vec<3, T, Q> const& axis, 45 | T const angle); 46 | 47 | /// Extracts the rotation part of a matrix. 48 | /// From GLM_GTX_matrix_interpolation extension. 49 | template 50 | GLM_FUNC_DECL mat<4, 4, T, Q> extractMatrixRotation( 51 | mat<4, 4, T, Q> const& mat); 52 | 53 | /// Build a interpolation of 4 * 4 matrixes. 54 | /// From GLM_GTX_matrix_interpolation extension. 55 | /// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results. 56 | template 57 | GLM_FUNC_DECL mat<4, 4, T, Q> interpolate( 58 | mat<4, 4, T, Q> const& m1, 59 | mat<4, 4, T, Q> const& m2, 60 | T const delta); 61 | 62 | /// @} 63 | }//namespace glm 64 | 65 | #include "matrix_interpolation.inl" 66 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/matrix_transform_2d.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_transform_2d 2 | /// @file glm/gtc/matrix_transform_2d.inl 3 | /// @author Miguel Ángel Pérez Martínez 4 | 5 | #include "../trigonometric.hpp" 6 | 7 | namespace glm 8 | { 9 | 10 | template 11 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate( 12 | mat<3, 3, T, Q> const& m, 13 | vec<2, T, Q> const& v) 14 | { 15 | mat<3, 3, T, Q> Result(m); 16 | Result[2] = m[0] * v[0] + m[1] * v[1] + m[2]; 17 | return Result; 18 | } 19 | 20 | 21 | template 22 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate( 23 | mat<3, 3, T, Q> const& m, 24 | T angle) 25 | { 26 | T const a = angle; 27 | T const c = cos(a); 28 | T const s = sin(a); 29 | 30 | mat<3, 3, T, Q> Result; 31 | Result[0] = m[0] * c + m[1] * s; 32 | Result[1] = m[0] * -s + m[1] * c; 33 | Result[2] = m[2]; 34 | return Result; 35 | } 36 | 37 | template 38 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale( 39 | mat<3, 3, T, Q> const& m, 40 | vec<2, T, Q> const& v) 41 | { 42 | mat<3, 3, T, Q> Result; 43 | Result[0] = m[0] * v[0]; 44 | Result[1] = m[1] * v[1]; 45 | Result[2] = m[2]; 46 | return Result; 47 | } 48 | 49 | template 50 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX( 51 | mat<3, 3, T, Q> const& m, 52 | T y) 53 | { 54 | mat<3, 3, T, Q> Result(1); 55 | Result[0][1] = y; 56 | return m * Result; 57 | } 58 | 59 | template 60 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY( 61 | mat<3, 3, T, Q> const& m, 62 | T x) 63 | { 64 | mat<3, 3, T, Q> Result(1); 65 | Result[1][0] = x; 66 | return m * Result; 67 | } 68 | 69 | }//namespace glm 70 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/mixed_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | /// @file glm/gtx/mixed_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_mixed_product GLM_GTX_mixed_producte 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Mixed product of 3 vectors. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_mixed_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_mixed_product extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_mixed_product 29 | /// @{ 30 | 31 | /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) 32 | template 33 | GLM_FUNC_DECL T mixedProduct( 34 | vec<3, T, Q> const& v1, 35 | vec<3, T, Q> const& v2, 36 | vec<3, T, Q> const& v3); 37 | 38 | /// @} 39 | }// namespace glm 40 | 41 | #include "mixed_product.inl" 42 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/mixed_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | /// @file glm/gtx/mixed_product.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER T mixedProduct 8 | ( 9 | vec<3, T, Q> const& v1, 10 | vec<3, T, Q> const& v2, 11 | vec<3, T, Q> const& v3 12 | ) 13 | { 14 | return dot(cross(v1, v2), v3); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/normal.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | /// @file glm/gtx/normal.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_normal GLM_GTX_normal 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Compute the normal of a triangle. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_normal is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_normal extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normal 30 | /// @{ 31 | 32 | /// Computes triangle normal from triangle points. 33 | /// 34 | /// @see gtx_normal 35 | template 36 | GLM_FUNC_DECL vec<3, T, Q> triangleNormal(vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "normal.inl" 42 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/normal.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | /// @file glm/gtx/normal.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, Q> triangleNormal 8 | ( 9 | vec<3, T, Q> const& p1, 10 | vec<3, T, Q> const& p2, 11 | vec<3, T, Q> const& p3 12 | ) 13 | { 14 | return normalize(cross(p1 - p2, p1 - p3)); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/normalize_dot.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | /// @file glm/gtx/normalize_dot.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_fast_square_root (dependence) 6 | /// 7 | /// @defgroup gtx_normalize_dot GLM_GTX_normalize_dot 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Dot product of vectors that need to be normalize with a single square root. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../gtx/fast_square_root.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "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." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_normalize_dot extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normalize_dot 30 | /// @{ 31 | 32 | /// Normalize parameters and returns the dot product of x and y. 33 | /// It's faster that dot(normalize(x), normalize(y)). 34 | /// 35 | /// @see gtx_normalize_dot extension. 36 | template 37 | GLM_FUNC_DECL T normalizeDot(vec const& x, vec const& y); 38 | 39 | /// Normalize parameters and returns the dot product of x and y. 40 | /// Faster that dot(fastNormalize(x), fastNormalize(y)). 41 | /// 42 | /// @see gtx_normalize_dot extension. 43 | template 44 | GLM_FUNC_DECL T fastNormalizeDot(vec const& x, vec const& y); 45 | 46 | /// @} 47 | }//namespace glm 48 | 49 | #include "normalize_dot.inl" 50 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/normalize_dot.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | /// @file glm/gtx/normalize_dot.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER T normalizeDot(vec const& x, vec const& y) 8 | { 9 | return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER T fastNormalizeDot(vec const& x, vec const& y) 14 | { 15 | return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); 16 | } 17 | }//namespace glm 18 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/number_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | /// @file glm/gtx/number_precision.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_type_precision (dependence) 6 | /// @see gtc_quaternion (dependence) 7 | /// 8 | /// @defgroup gtx_number_precision GLM_GTX_number_precision 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Defined size types. 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/type_precision.hpp" 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "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." 23 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_number_precision extension included") 27 | #endif 28 | 29 | namespace glm{ 30 | namespace gtx 31 | { 32 | ///////////////////////////// 33 | // Unsigned int vector types 34 | 35 | /// @addtogroup gtx_number_precision 36 | /// @{ 37 | 38 | typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 39 | typedef u16 u16vec1; //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 40 | typedef u32 u32vec1; //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 41 | typedef u64 u64vec1; //!< \brief 64bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 42 | 43 | ////////////////////// 44 | // Float vector types 45 | 46 | typedef f32 f32vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 47 | typedef f64 f64vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 48 | 49 | ////////////////////// 50 | // Float matrix types 51 | 52 | typedef f32 f32mat1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 53 | typedef f32 f32mat1x1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 54 | typedef f64 f64mat1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 55 | typedef f64 f64mat1x1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 56 | 57 | /// @} 58 | }//namespace gtx 59 | }//namespace glm 60 | 61 | #include "number_precision.inl" 62 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | /// @file glm/gtx/number_precision.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/optimum_pow.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | /// @file glm/gtx/optimum_pow.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_optimum_pow GLM_GTX_optimum_pow 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Integer exponentiation of power functions. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_optimum_pow is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_optimum_pow extension included") 24 | #endif 25 | 26 | namespace glm{ 27 | namespace gtx 28 | { 29 | /// @addtogroup gtx_optimum_pow 30 | /// @{ 31 | 32 | /// Returns x raised to the power of 2. 33 | /// 34 | /// @see gtx_optimum_pow 35 | template 36 | GLM_FUNC_DECL genType pow2(genType const& x); 37 | 38 | /// Returns x raised to the power of 3. 39 | /// 40 | /// @see gtx_optimum_pow 41 | template 42 | GLM_FUNC_DECL genType pow3(genType const& x); 43 | 44 | /// Returns x raised to the power of 4. 45 | /// 46 | /// @see gtx_optimum_pow 47 | template 48 | GLM_FUNC_DECL genType pow4(genType const& x); 49 | 50 | /// @} 51 | }//namespace gtx 52 | }//namespace glm 53 | 54 | #include "optimum_pow.inl" 55 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/optimum_pow.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | /// @file glm/gtx/optimum_pow.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType pow2(genType const& x) 8 | { 9 | return x * x; 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER genType pow3(genType const& x) 14 | { 15 | return x * x * x; 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER genType pow4(genType const& x) 20 | { 21 | return (x * x) * (x * x); 22 | } 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/orthonormalize.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | /// @file glm/gtx/orthonormalize.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_orthonormalize GLM_GTX_orthonormalize 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Orthonormalize matrices. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../vec3.hpp" 18 | #include "../mat3x3.hpp" 19 | #include "../geometric.hpp" 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "GLM: GLM_GTX_orthonormalize is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 23 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_orthonormalize extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_orthonormalize 32 | /// @{ 33 | 34 | /// Returns the orthonormalized matrix of m. 35 | /// 36 | /// @see gtx_orthonormalize 37 | template 38 | GLM_FUNC_DECL mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m); 39 | 40 | /// Orthonormalizes x according y. 41 | /// 42 | /// @see gtx_orthonormalize 43 | template 44 | GLM_FUNC_DECL vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y); 45 | 46 | /// @} 47 | }//namespace glm 48 | 49 | #include "orthonormalize.inl" 50 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/orthonormalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | /// @file glm/gtx/orthonormalize.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m) 8 | { 9 | mat<3, 3, T, Q> r = m; 10 | 11 | r[0] = normalize(r[0]); 12 | 13 | T d0 = dot(r[0], r[1]); 14 | r[1] -= r[0] * d0; 15 | r[1] = normalize(r[1]); 16 | 17 | T d1 = dot(r[1], r[2]); 18 | d0 = dot(r[0], r[2]); 19 | r[2] -= r[0] * d0 + r[1] * d1; 20 | r[2] = normalize(r[2]); 21 | 22 | return r; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y) 27 | { 28 | return normalize(x - y * dot(y, x)); 29 | } 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/perpendicular.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | /// @file glm/gtx/perpendicular.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_projection (dependence) 6 | /// 7 | /// @defgroup gtx_perpendicular GLM_GTX_perpendicular 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Perpendicular of a vector from other one 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include "../gtx/projection.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_perpendicular is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 22 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_perpendicular extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_perpendicular 31 | /// @{ 32 | 33 | //! Projects x a perpendicular axis of Normal. 34 | //! From GLM_GTX_perpendicular extension. 35 | template 36 | GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "perpendicular.inl" 42 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/perpendicular.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | /// @file glm/gtx/perpendicular.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal) 8 | { 9 | return x - proj(x, Normal); 10 | } 11 | }//namespace glm 12 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/polar_coordinates.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | /// @file glm/gtx/polar_coordinates.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Conversion from Euclidean space to polar space and revert. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_polar_coordinates is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_polar_coordinates extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_polar_coordinates 29 | /// @{ 30 | 31 | /// Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude. 32 | /// 33 | /// @see gtx_polar_coordinates 34 | template 35 | GLM_FUNC_DECL vec<3, T, Q> polar( 36 | vec<3, T, Q> const& euclidean); 37 | 38 | /// Convert Polar to Euclidean coordinates. 39 | /// 40 | /// @see gtx_polar_coordinates 41 | template 42 | GLM_FUNC_DECL vec<3, T, Q> euclidean( 43 | vec<2, T, Q> const& polar); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "polar_coordinates.inl" 49 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/polar_coordinates.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | /// @file glm/gtx/polar_coordinates.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, Q> polar 8 | ( 9 | vec<3, T, Q> const& euclidean 10 | ) 11 | { 12 | T const Length(length(euclidean)); 13 | vec<3, T, Q> const tmp(euclidean / Length); 14 | T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z)); 15 | 16 | return vec<3, T, Q>( 17 | asin(tmp.y), // latitude 18 | atan(tmp.x, tmp.z), // longitude 19 | xz_dist); // xz distance 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER vec<3, T, Q> euclidean 24 | ( 25 | vec<2, T, Q> const& polar 26 | ) 27 | { 28 | T const latitude(polar.x); 29 | T const longitude(polar.y); 30 | 31 | return vec<3, T, Q>( 32 | cos(latitude) * sin(longitude), 33 | sin(latitude), 34 | cos(latitude) * cos(longitude)); 35 | } 36 | 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/projection.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | /// @file glm/gtx/projection.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_projection GLM_GTX_projection 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Projection of a vector to other one 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../geometric.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_projection is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_projection extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_projection 29 | /// @{ 30 | 31 | /// Projects x on Normal. 32 | /// 33 | /// @see gtx_projection 34 | template 35 | GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); 36 | 37 | /// @} 38 | }//namespace glm 39 | 40 | #include "projection.inl" 41 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/projection.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | /// @file glm/gtx/projection.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal) 8 | { 9 | return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; 10 | } 11 | }//namespace glm 12 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/raw_data.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | /// @file glm/gtx/raw_data.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_raw_data GLM_GTX_raw_data 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Projection of a vector to other one 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | #include "../detail/type_int.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_raw_data is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_raw_data extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_raw_data 30 | /// @{ 31 | 32 | //! Type for byte numbers. 33 | //! From GLM_GTX_raw_data extension. 34 | typedef detail::uint8 byte; 35 | 36 | //! Type for word numbers. 37 | //! From GLM_GTX_raw_data extension. 38 | typedef detail::uint16 word; 39 | 40 | //! Type for dword numbers. 41 | //! From GLM_GTX_raw_data extension. 42 | typedef detail::uint32 dword; 43 | 44 | //! Type for qword numbers. 45 | //! From GLM_GTX_raw_data extension. 46 | typedef detail::uint64 qword; 47 | 48 | /// @} 49 | }// namespace glm 50 | 51 | #include "raw_data.inl" 52 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | /// @file glm/gtx/raw_data.inl 3 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/rotate_normalized_axis.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_rotate_normalized_axis 2 | /// @file glm/gtx/rotate_normalized_axis.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_matrix_transform 6 | /// @see gtc_quaternion 7 | /// 8 | /// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Quaternions and matrices rotations around normalized axis. 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/epsilon.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | 22 | #ifndef GLM_ENABLE_EXPERIMENTAL 23 | # error "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." 24 | #endif 25 | 26 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 27 | # pragma message("GLM: GLM_GTX_rotate_normalized_axis extension included") 28 | #endif 29 | 30 | namespace glm 31 | { 32 | /// @addtogroup gtx_rotate_normalized_axis 33 | /// @{ 34 | 35 | /// Builds a rotation 4 * 4 matrix created from a normalized axis and an angle. 36 | /// 37 | /// @param m Input matrix multiplied by this rotation matrix. 38 | /// @param angle Rotation angle expressed in radians. 39 | /// @param axis Rotation axis, must be normalized. 40 | /// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double. 41 | /// 42 | /// @see gtx_rotate_normalized_axis 43 | /// @see - rotate(T angle, T x, T y, T z) 44 | /// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z) 45 | /// @see - rotate(T angle, vec<3, T, Q> const& v) 46 | template 47 | GLM_FUNC_DECL mat<4, 4, T, Q> rotateNormalizedAxis( 48 | mat<4, 4, T, Q> const& m, 49 | T const& angle, 50 | vec<3, T, Q> const& axis); 51 | 52 | /// Rotates a quaternion from a vector of 3 components normalized axis and an angle. 53 | /// 54 | /// @param q Source orientation 55 | /// @param angle Angle expressed in radians. 56 | /// @param axis Normalized axis of the rotation, must be normalized. 57 | /// 58 | /// @see gtx_rotate_normalized_axis 59 | template 60 | GLM_FUNC_DECL tquat rotateNormalizedAxis( 61 | tquat const& q, 62 | T const& angle, 63 | vec<3, T, Q> const& axis); 64 | 65 | /// @} 66 | }//namespace glm 67 | 68 | #include "rotate_normalized_axis.inl" 69 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/rotate_normalized_axis.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_rotate_normalized_axis 2 | /// @file glm/gtx/rotate_normalized_axis.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotateNormalizedAxis 8 | ( 9 | mat<4, 4, T, Q> const& m, 10 | T const& angle, 11 | vec<3, T, Q> const& v 12 | ) 13 | { 14 | T const a = angle; 15 | T const c = cos(a); 16 | T const s = sin(a); 17 | 18 | vec<3, T, Q> const axis(v); 19 | 20 | vec<3, T, Q> const temp((static_cast(1) - c) * axis); 21 | 22 | mat<4, 4, T, Q> Rotate; 23 | Rotate[0][0] = c + temp[0] * axis[0]; 24 | Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; 25 | Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; 26 | 27 | Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; 28 | Rotate[1][1] = c + temp[1] * axis[1]; 29 | Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; 30 | 31 | Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; 32 | Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; 33 | Rotate[2][2] = c + temp[2] * axis[2]; 34 | 35 | mat<4, 4, T, Q> Result; 36 | Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; 37 | Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; 38 | Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; 39 | Result[3] = m[3]; 40 | return Result; 41 | } 42 | 43 | template 44 | GLM_FUNC_QUALIFIER tquat rotateNormalizedAxis 45 | ( 46 | tquat const& q, 47 | T const& angle, 48 | vec<3, T, Q> const& v 49 | ) 50 | { 51 | vec<3, T, Q> const Tmp(v); 52 | 53 | T const AngleRad(angle); 54 | T const Sin = sin(AngleRad * T(0.5)); 55 | 56 | return q * tquat(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); 57 | //return gtc::quaternion::cross(q, tquat(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin)); 58 | } 59 | }//namespace glm 60 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/scalar_relational.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | /// @file glm/gtx/scalar_relational.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Extend a position from a source to a position at a defined length. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 20 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_extend extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_scalar_relational 29 | /// @{ 30 | 31 | 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "scalar_relational.inl" 37 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/scalar_relational.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | /// @file glm/gtx/scalar_relational.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER bool lessThan 8 | ( 9 | T const& x, 10 | T const& y 11 | ) 12 | { 13 | return x < y; 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER bool lessThanEqual 18 | ( 19 | T const& x, 20 | T const& y 21 | ) 22 | { 23 | return x <= y; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER bool greaterThan 28 | ( 29 | T const& x, 30 | T const& y 31 | ) 32 | { 33 | return x > y; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER bool greaterThanEqual 38 | ( 39 | T const& x, 40 | T const& y 41 | ) 42 | { 43 | return x >= y; 44 | } 45 | 46 | template 47 | GLM_FUNC_QUALIFIER bool equal 48 | ( 49 | T const& x, 50 | T const& y 51 | ) 52 | { 53 | return detail::compute_equal::call(x, y); 54 | } 55 | 56 | template 57 | GLM_FUNC_QUALIFIER bool notEqual 58 | ( 59 | T const& x, 60 | T const& y 61 | ) 62 | { 63 | return !detail::compute_equal::call(x, y); 64 | } 65 | 66 | GLM_FUNC_QUALIFIER bool any 67 | ( 68 | bool const& x 69 | ) 70 | { 71 | return x; 72 | } 73 | 74 | GLM_FUNC_QUALIFIER bool all 75 | ( 76 | bool const& x 77 | ) 78 | { 79 | return x; 80 | } 81 | 82 | GLM_FUNC_QUALIFIER bool not_ 83 | ( 84 | bool const& x 85 | ) 86 | { 87 | return !x; 88 | } 89 | }//namespace glm 90 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/spline.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_spline 2 | /// @file glm/gtx/spline.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_spline GLM_GTX_spline 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Spline functions 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtx/optimum_pow.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "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." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_spline extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_spline 30 | /// @{ 31 | 32 | /// Return a point from a catmull rom curve. 33 | /// @see gtx_spline extension. 34 | template 35 | GLM_FUNC_DECL genType catmullRom( 36 | genType const& v1, 37 | genType const& v2, 38 | genType const& v3, 39 | genType const& v4, 40 | typename genType::value_type const& s); 41 | 42 | /// Return a point from a hermite curve. 43 | /// @see gtx_spline extension. 44 | template 45 | GLM_FUNC_DECL genType hermite( 46 | genType const& v1, 47 | genType const& t1, 48 | genType const& v2, 49 | genType const& t2, 50 | typename genType::value_type const& s); 51 | 52 | /// Return a point from a cubic curve. 53 | /// @see gtx_spline extension. 54 | template 55 | GLM_FUNC_DECL genType cubic( 56 | genType const& v1, 57 | genType const& v2, 58 | genType const& v3, 59 | genType const& v4, 60 | typename genType::value_type const& s); 61 | 62 | /// @} 63 | }//namespace glm 64 | 65 | #include "spline.inl" 66 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/spline.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_spline 2 | /// @file glm/gtx/spline.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType catmullRom 8 | ( 9 | genType const& v1, 10 | genType const& v2, 11 | genType const& v3, 12 | genType const& v4, 13 | typename genType::value_type const& s 14 | ) 15 | { 16 | typename genType::value_type s2 = pow2(s); 17 | typename genType::value_type s3 = pow3(s); 18 | 19 | typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s; 20 | typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2); 21 | typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s; 22 | typename genType::value_type f4 = s3 - s2; 23 | 24 | return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2); 25 | 26 | } 27 | 28 | template 29 | GLM_FUNC_QUALIFIER genType hermite 30 | ( 31 | genType const& v1, 32 | genType const& t1, 33 | genType const& v2, 34 | genType const& t2, 35 | typename genType::value_type const& s 36 | ) 37 | { 38 | typename genType::value_type s2 = pow2(s); 39 | typename genType::value_type s3 = pow3(s); 40 | 41 | typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1); 42 | typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2; 43 | typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s; 44 | typename genType::value_type f4 = s3 - s2; 45 | 46 | return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2; 47 | } 48 | 49 | template 50 | GLM_FUNC_QUALIFIER genType cubic 51 | ( 52 | genType const& v1, 53 | genType const& v2, 54 | genType const& v3, 55 | genType const& v4, 56 | typename genType::value_type const& s 57 | ) 58 | { 59 | return ((v1 * s + v2) * s + v3) * s + v4; 60 | } 61 | }//namespace glm 62 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/std_based_type.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | /// @file glm/gtx/std_based_type.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_std_based_type GLM_GTX_std_based_type 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Adds vector types based on STL value types. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "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." 22 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_std_based_type extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_std_based_type 31 | /// @{ 32 | 33 | /// Vector type based of one std::size_t component. 34 | /// @see GLM_GTX_std_based_type 35 | typedef vec<1, std::size_t, defaultp> size1; 36 | 37 | /// Vector type based of two std::size_t components. 38 | /// @see GLM_GTX_std_based_type 39 | typedef vec<2, std::size_t, defaultp> size2; 40 | 41 | /// Vector type based of three std::size_t components. 42 | /// @see GLM_GTX_std_based_type 43 | typedef vec<3, std::size_t, defaultp> size3; 44 | 45 | /// Vector type based of four std::size_t components. 46 | /// @see GLM_GTX_std_based_type 47 | typedef vec<4, std::size_t, defaultp> size4; 48 | 49 | /// Vector type based of one std::size_t component. 50 | /// @see GLM_GTX_std_based_type 51 | typedef vec<1, std::size_t, defaultp> size1_t; 52 | 53 | /// Vector type based of two std::size_t components. 54 | /// @see GLM_GTX_std_based_type 55 | typedef vec<2, std::size_t, defaultp> size2_t; 56 | 57 | /// Vector type based of three std::size_t components. 58 | /// @see GLM_GTX_std_based_type 59 | typedef vec<3, std::size_t, defaultp> size3_t; 60 | 61 | /// Vector type based of four std::size_t components. 62 | /// @see GLM_GTX_std_based_type 63 | typedef vec<4, std::size_t, defaultp> size4_t; 64 | 65 | /// @} 66 | }//namespace glm 67 | 68 | #include "std_based_type.inl" 69 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | /// @file glm/gtx/std_based_type.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/string_cast.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_string_cast 2 | /// @file glm/gtx/string_cast.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_integer (dependence) 6 | /// @see gtx_quaternion (dependence) 7 | /// 8 | /// @defgroup gtx_string_cast GLM_GTX_string_cast 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Setup strings for GLM type values 14 | /// 15 | /// This extension is not supported with CUDA 16 | 17 | #pragma once 18 | 19 | // Dependency: 20 | #include "../glm.hpp" 21 | #include "../gtc/type_precision.hpp" 22 | #include "../gtc/quaternion.hpp" 23 | #include "../gtx/dual_quaternion.hpp" 24 | #include 25 | #include 26 | 27 | #ifndef GLM_ENABLE_EXPERIMENTAL 28 | # error "GLM: GLM_GTX_string_cast is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 29 | #endif 30 | 31 | #if(GLM_COMPILER & GLM_COMPILER_CUDA) 32 | # error "GLM_GTX_string_cast is not supported on CUDA compiler" 33 | #endif 34 | 35 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 36 | # pragma message("GLM: GLM_GTX_string_cast extension included") 37 | #endif 38 | 39 | namespace glm 40 | { 41 | /// @addtogroup gtx_string_cast 42 | /// @{ 43 | 44 | /// Create a string from a GLM vector or matrix typed variable. 45 | /// @see gtx_string_cast extension. 46 | template 47 | GLM_FUNC_DECL std::string to_string(genType const& x); 48 | 49 | /// @} 50 | }//namespace glm 51 | 52 | #include "string_cast.inl" 53 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/texture.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | /// @file glm/gtx/texture.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_texture GLM_GTX_texture 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Wrapping mode of texture coordinates. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtc/integer.hpp" 18 | #include "../gtx/component_wise.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_texture is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 22 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_texture extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_texture 31 | /// @{ 32 | 33 | /// Compute the number of mipmaps levels necessary to create a mipmap complete texture 34 | /// 35 | /// @param Extent Extent of the texture base level mipmap 36 | /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector 37 | /// @tparam T Floating-point or signed integer scalar types 38 | /// @tparam Q Value from qualifier enum 39 | template 40 | T levels(vec const& Extent); 41 | 42 | /// @} 43 | }// namespace glm 44 | 45 | #include "texture.inl" 46 | 47 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/texture.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | /// @file glm/gtx/texture.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | inline T levels(vec const& Extent) 8 | { 9 | return glm::log2(compMax(Extent)) + static_cast(1); 10 | } 11 | 12 | template 13 | inline T levels(T Extent) 14 | { 15 | return vec<1, T, defaultp>(Extent).x; 16 | } 17 | }//namespace glm 18 | 19 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/transform.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | /// @file glm/gtx/transform.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_matrix_transform (dependence) 6 | /// @see gtx_transform 7 | /// @see gtx_transform2 8 | /// 9 | /// @defgroup gtx_transform GLM_GTX_transform 10 | /// @ingroup gtx 11 | /// 12 | /// Include to use the features of this extension. 13 | /// 14 | /// Add transformation matrices 15 | 16 | #pragma once 17 | 18 | // Dependency: 19 | #include "../glm.hpp" 20 | #include "../gtc/matrix_transform.hpp" 21 | 22 | #ifndef GLM_ENABLE_EXPERIMENTAL 23 | # error "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." 24 | #endif 25 | 26 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 27 | # pragma message("GLM: GLM_GTX_transform extension included") 28 | #endif 29 | 30 | namespace glm 31 | { 32 | /// @addtogroup gtx_transform 33 | /// @{ 34 | 35 | /// Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 36 | /// @see gtc_matrix_transform 37 | /// @see gtx_transform 38 | template 39 | GLM_FUNC_DECL mat<4, 4, T, Q> translate( 40 | vec<3, T, Q> const& v); 41 | 42 | /// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians. 43 | /// @see gtc_matrix_transform 44 | /// @see gtx_transform 45 | template 46 | GLM_FUNC_DECL mat<4, 4, T, Q> rotate( 47 | T angle, 48 | vec<3, T, Q> const& v); 49 | 50 | /// Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components. 51 | /// @see gtc_matrix_transform 52 | /// @see gtx_transform 53 | template 54 | GLM_FUNC_DECL mat<4, 4, T, Q> scale( 55 | vec<3, T, Q> const& v); 56 | 57 | /// @} 58 | }// namespace glm 59 | 60 | #include "transform.inl" 61 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/transform.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | /// @file glm/gtx/transform.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(vec<3, T, Q> const& v) 8 | { 9 | return translate(mat<4, 4, T, Q>(static_cast(1)), v); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v) 14 | { 15 | return rotate(mat<4, 4, T, Q>(static_cast(1)), angle, v); 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(vec<3, T, Q> const& v) 20 | { 21 | return scale(mat<4, 4, T, Q>(static_cast(1)), v); 22 | } 23 | 24 | }//namespace glm 25 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | /// @file glm/gtc/type_aligned.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/type_trait.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_type_trait 2 | /// @file glm/gtx/type_trait.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_type_trait GLM_GTX_type_trait 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines traits for each type. 12 | 13 | #pragma once 14 | 15 | #ifndef GLM_ENABLE_EXPERIMENTAL 16 | # error "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." 17 | #endif 18 | 19 | // Dependency: 20 | #include "../detail/qualifier.hpp" 21 | #include "../gtc/quaternion.hpp" 22 | #include "../gtx/dual_quaternion.hpp" 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_type_trait extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_type_trait 31 | /// @{ 32 | 33 | template 34 | struct type 35 | { 36 | static bool const is_vec = false; 37 | static bool const is_mat = false; 38 | static bool const is_quat = false; 39 | static length_t const components = 0; 40 | static length_t const cols = 0; 41 | static length_t const rows = 0; 42 | }; 43 | 44 | template 45 | struct type > 46 | { 47 | static bool const is_vec = true; 48 | static bool const is_mat = false; 49 | static bool const is_quat = false; 50 | static length_t const components = L; 51 | }; 52 | 53 | template 54 | struct type > 55 | { 56 | static bool const is_vec = false; 57 | static bool const is_mat = true; 58 | static bool const is_quat = false; 59 | static length_t const components = C; 60 | static length_t const cols = C; 61 | static length_t const rows = R; 62 | }; 63 | 64 | template 65 | struct type > 66 | { 67 | static bool const is_vec = false; 68 | static bool const is_mat = false; 69 | static bool const is_quat = true; 70 | static length_t const components = 4; 71 | }; 72 | 73 | template 74 | struct type > 75 | { 76 | static bool const is_vec = false; 77 | static bool const is_mat = false; 78 | static bool const is_quat = true; 79 | static length_t const components = 8; 80 | }; 81 | 82 | /// @} 83 | }//namespace glm 84 | 85 | #include "type_trait.inl" 86 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/type_trait.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_type_trait 2 | /// @file glm/gtx/type_trait.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | bool const type::is_vec; 8 | template 9 | bool const type::is_mat; 10 | template 11 | bool const type::is_quat; 12 | template 13 | length_t const type::components; 14 | template 15 | length_t const type::cols; 16 | template 17 | length_t const type::rows; 18 | 19 | // vec 20 | template 21 | bool const type >::is_vec; 22 | template 23 | bool const type >::is_mat; 24 | template 25 | bool const type >::is_quat; 26 | template 27 | length_t const type >::components; 28 | 29 | // mat 30 | template 31 | bool const type >::is_vec; 32 | template 33 | bool const type >::is_mat; 34 | template 35 | bool const type >::is_quat; 36 | template 37 | length_t const type >::components; 38 | template 39 | length_t const type >::cols; 40 | template 41 | length_t const type >::rows; 42 | 43 | // tquat 44 | template 45 | bool const type >::is_vec; 46 | template 47 | bool const type >::is_mat; 48 | template 49 | bool const type >::is_quat; 50 | template 51 | length_t const type >::components; 52 | 53 | // tdualquat 54 | template 55 | bool const type >::is_vec; 56 | template 57 | bool const type >::is_mat; 58 | template 59 | bool const type >::is_quat; 60 | template 61 | length_t const type >::components; 62 | }//namespace glm 63 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/vector_angle.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_vector_angle 2 | /// @file glm/gtx/vector_angle.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_quaternion (dependence) 6 | /// @see gtx_epsilon (dependence) 7 | /// 8 | /// @defgroup gtx_vector_angle GLM_GTX_vector_angle 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Compute angle between vectors 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/epsilon.hpp" 20 | #include "../gtx/quaternion.hpp" 21 | #include "../gtx/rotate_vector.hpp" 22 | 23 | #ifndef GLM_ENABLE_EXPERIMENTAL 24 | # error "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." 25 | #endif 26 | 27 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTX_vector_angle extension included") 29 | #endif 30 | 31 | namespace glm 32 | { 33 | /// @addtogroup gtx_vector_angle 34 | /// @{ 35 | 36 | //! Returns the absolute angle between two vectors. 37 | //! Parameters need to be normalized. 38 | /// @see gtx_vector_angle extension. 39 | template 40 | GLM_FUNC_DECL T angle(vec const& x, vec const& y); 41 | 42 | //! Returns the oriented angle between two 2d vectors. 43 | //! Parameters need to be normalized. 44 | /// @see gtx_vector_angle extension. 45 | template 46 | GLM_FUNC_DECL T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y); 47 | 48 | //! Returns the oriented angle between two 3d vectors based from a reference axis. 49 | //! Parameters need to be normalized. 50 | /// @see gtx_vector_angle extension. 51 | template 52 | GLM_FUNC_DECL T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref); 53 | 54 | /// @} 55 | }// namespace glm 56 | 57 | #include "vector_angle.inl" 58 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/vector_angle.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_vector_angle 2 | /// @file glm/gtx/vector_angle.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType angle 8 | ( 9 | genType const& x, 10 | genType const& y 11 | ) 12 | { 13 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); 14 | return acos(clamp(dot(x, y), genType(-1), genType(1))); 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER T angle(vec const& x, vec const& y) 19 | { 20 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); 21 | return acos(clamp(dot(x, y), T(-1), T(1))); 22 | } 23 | 24 | //! \todo epsilon is hard coded to 0.01 25 | template 26 | GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y) 27 | { 28 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); 29 | T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); 30 | 31 | if(all(epsilonEqual(y, glm::rotate(x, Angle), T(0.0001)))) 32 | return Angle; 33 | else 34 | return -Angle; 35 | } 36 | 37 | template 38 | GLM_FUNC_QUALIFIER T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref) 39 | { 40 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); 41 | 42 | T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); 43 | return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0)); 44 | } 45 | }//namespace glm 46 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/vector_query.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_vector_query 2 | /// @file glm/gtx/vector_query.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_vector_query GLM_GTX_vector_query 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Query informations of vector types 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include 18 | #include 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "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." 22 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_vector_query extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_vector_query 31 | /// @{ 32 | 33 | //! Check whether two vectors are collinears. 34 | /// @see gtx_vector_query extensions. 35 | template 36 | GLM_FUNC_DECL bool areCollinear(vec const& v0, vec const& v1, T const& epsilon); 37 | 38 | //! Check whether two vectors are orthogonals. 39 | /// @see gtx_vector_query extensions. 40 | template 41 | GLM_FUNC_DECL bool areOrthogonal(vec const& v0, vec const& v1, T const& epsilon); 42 | 43 | //! Check whether a vector is normalized. 44 | /// @see gtx_vector_query extensions. 45 | template 46 | GLM_FUNC_DECL bool isNormalized(vec const& v, T const& epsilon); 47 | 48 | //! Check whether a vector is null. 49 | /// @see gtx_vector_query extensions. 50 | template 51 | GLM_FUNC_DECL bool isNull(vec const& v, T const& epsilon); 52 | 53 | //! Check whether a each component of a vector is null. 54 | /// @see gtx_vector_query extensions. 55 | template 56 | GLM_FUNC_DECL vec isCompNull(vec const& v, T const& epsilon); 57 | 58 | //! Check whether two vectors are orthonormal. 59 | /// @see gtx_vector_query extensions. 60 | template 61 | GLM_FUNC_DECL bool areOrthonormal(vec const& v0, vec const& v1, T const& epsilon); 62 | 63 | /// @} 64 | }// namespace glm 65 | 66 | #include "vector_query.inl" 67 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/wrap.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | /// @file glm/gtx/wrap.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_wrap GLM_GTX_wrap 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Wrapping mode of texture coordinates. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtc/vec1.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_wrap extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_wrap 30 | /// @{ 31 | 32 | /// Simulate GL_CLAMP OpenGL wrap mode 33 | /// @see gtx_wrap extension. 34 | template 35 | GLM_FUNC_DECL genType clamp(genType const& Texcoord); 36 | 37 | /// Simulate GL_REPEAT OpenGL wrap mode 38 | /// @see gtx_wrap extension. 39 | template 40 | GLM_FUNC_DECL genType repeat(genType const& Texcoord); 41 | 42 | /// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode 43 | /// @see gtx_wrap extension. 44 | template 45 | GLM_FUNC_DECL genType mirrorClamp(genType const& Texcoord); 46 | 47 | /// Simulate GL_MIRROR_REPEAT OpenGL wrap mode 48 | /// @see gtx_wrap extension. 49 | template 50 | GLM_FUNC_DECL genType mirrorRepeat(genType const& Texcoord); 51 | 52 | /// @} 53 | }// namespace glm 54 | 55 | #include "wrap.inl" 56 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | /// @file glm/gtx/wrap.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec clamp(vec const& Texcoord) 8 | { 9 | return glm::clamp(Texcoord, vec(0), vec(1)); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER genType clamp(genType const& Texcoord) 14 | { 15 | return clamp(vec<1, genType, defaultp>(Texcoord)).x; 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER vec repeat(vec const& Texcoord) 20 | { 21 | return glm::fract(Texcoord); 22 | } 23 | 24 | template 25 | GLM_FUNC_QUALIFIER genType repeat(genType const& Texcoord) 26 | { 27 | return repeat(vec<1, genType, defaultp>(Texcoord)).x; 28 | } 29 | 30 | template 31 | GLM_FUNC_QUALIFIER vec mirrorClamp(vec const& Texcoord) 32 | { 33 | return glm::fract(glm::abs(Texcoord)); 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER genType mirrorClamp(genType const& Texcoord) 38 | { 39 | return mirrorClamp(vec<1, genType, defaultp>(Texcoord)).x; 40 | } 41 | 42 | template 43 | GLM_FUNC_QUALIFIER vec mirrorRepeat(vec const& Texcoord) 44 | { 45 | vec const Abs = glm::abs(Texcoord); 46 | vec const Clamp = glm::mod(glm::floor(Abs), vec(2)); 47 | vec const Floor = glm::floor(Abs); 48 | vec const Rest = Abs - Floor; 49 | vec const Mirror = Clamp + Rest; 50 | return mix(Rest, vec(1) - Rest, glm::greaterThanEqual(Mirror, vec(1))); 51 | } 52 | 53 | template 54 | GLM_FUNC_QUALIFIER genType mirrorRepeat(genType const& Texcoord) 55 | { 56 | return mirrorRepeat(vec<1, genType, defaultp>(Texcoord)).x; 57 | } 58 | }//namespace glm 59 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/mat2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x3.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat2x3.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 2 columns of 3 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<2, 3, float, lowp> lowp_mat2x3; 18 | 19 | /// 2 columns of 3 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<2, 3, float, mediump> mediump_mat2x3; 25 | 26 | /// 2 columns of 3 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<2, 3, float, highp> highp_mat2x3; 32 | 33 | }//namespace glm 34 | 35 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/mat2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x4.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat2x4.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 2 columns of 4 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<2, 4, float, lowp> lowp_mat2x4; 18 | 19 | /// 2 columns of 4 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<2, 4, float, mediump> mediump_mat2x4; 25 | 26 | /// 2 columns of 4 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<2, 4, float, highp> highp_mat2x4; 32 | 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/mat3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x2.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat3x2.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 3 columns of 2 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<3, 2, float, lowp> lowp_mat3x2; 18 | 19 | /// 3 columns of 2 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<3, 2, float, mediump> mediump_mat3x2; 25 | 26 | /// 3 columns of 2 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<3, 2, float, highp> highp_mat3x2; 32 | 33 | }//namespace 34 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/mat3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x4.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat3x4.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 3 columns of 4 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<3, 4, float, lowp> lowp_mat3x4; 18 | 19 | /// 3 columns of 4 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<3, 4, float, mediump> mediump_mat3x4; 25 | 26 | /// 3 columns of 4 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<3, 4, float, highp> highp_mat3x4; 32 | 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/mat4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x2.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat4x2.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 4 columns of 2 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<4, 2, float, lowp> lowp_mat4x2; 18 | 19 | /// 4 columns of 2 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<4, 2, float, mediump> mediump_mat4x2; 25 | 26 | /// 4 columns of 2 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<4, 2, float, highp> highp_mat4x2; 32 | 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/mat4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x3.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat4x3.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 4 columns of 3 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<4, 3, float, lowp> lowp_mat4x3; 18 | 19 | /// 4 columns of 3 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<4, 3, float, mediump> mediump_mat4x3; 25 | 26 | /// 4 columns of 3 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<4, 3, float, highp> highp_mat4x3; 32 | 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/simd/exponential.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/experimental.h 3 | 4 | #pragma once 5 | 6 | #include "platform.h" 7 | 8 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_sqrt_lowp(glm_vec4 x) 11 | { 12 | return _mm_mul_ss(_mm_rsqrt_ss(x), x); 13 | } 14 | 15 | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sqrt_lowp(glm_vec4 x) 16 | { 17 | return _mm_mul_ps(_mm_rsqrt_ps(x), x); 18 | } 19 | 20 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 21 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/simd/packing.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/packing.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/simd/trigonometric.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/trigonometric.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/simd/vector_relational.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/vector_relational.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/vec2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec2.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_vec2.hpp" 9 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/vec3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec3.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_vec3.hpp" 9 | -------------------------------------------------------------------------------- /RunTest/Framework3/glm/vec4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec4.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_vec4.hpp" 9 | -------------------------------------------------------------------------------- /RunTest/Framework3/readme.txt: -------------------------------------------------------------------------------- 1 | Author 2 | ====== 3 | 4 | This framework was made by Emil Persson, AKA Humus. 5 | http://www.humus.name 6 | 7 | 8 | 9 | Legal stuff 10 | =========== 11 | 12 | This framework is freeware and may be used by anyone for any purpose 13 | and may be distributed freely to anyone using any distribution 14 | media or distribution method as long as this file is included. 15 | -------------------------------------------------------------------------------- /RunTest/RunTest/App.h: -------------------------------------------------------------------------------- 1 | //====================================================================== 2 | // ECS Runtime test 3 | // By Damian Trebilco 4 | //====================================================================== 5 | 6 | #include "../Framework3/OpenGL/OpenGLApp.h" 7 | #include "../Examples/GameContext.h" 8 | 9 | 10 | class App : public OpenGLApp { 11 | public: 12 | 13 | App(); 14 | 15 | char *getTitle() const override { return "ESC Test"; } 16 | bool init() override; 17 | 18 | bool onKey(const uint key, const bool pressed) override; 19 | bool onMouseButton(const int x, const int y, const MouseButton button, const bool pressed) override; 20 | bool onMouseMove(const int x, const int y, const int deltaX, const int deltaY) override; 21 | 22 | void resetCamera() override; 23 | bool load() override; 24 | 25 | void drawFrame() override; 26 | 27 | protected: 28 | 29 | mat4 m_projection; //!< The projection matrix used 30 | mat4 m_modelView; //!< The model-view matrix used 31 | 32 | GameContext m_context; 33 | GroupID m_staticGroup = GroupID(0); 34 | GroupID m_dynamicGroup = GroupID(0); 35 | 36 | bool m_freeCameraMode = false; //!< If in free camera mode 37 | mat4 m_fcSavedModelView; //!< The model view saved free camera 38 | vec4 m_fcFrustumPoints[8]; //!< The free camera saved frustum points 39 | }; 40 | -------------------------------------------------------------------------------- /RunTest/RunTest/RunTest.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/RunTest/RunTest.exe -------------------------------------------------------------------------------- /RunTest/RunTest/RunTest.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 15 4 | VisualStudioVersion = 15.0.27004.2005 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RunTest", "RunTest.vcxproj", "{E3216123-FBB1-4DE9-9989-5F58D1790484}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {E3216123-FBB1-4DE9-9989-5F58D1790484}.Debug|x64.ActiveCfg = Debug|x64 17 | {E3216123-FBB1-4DE9-9989-5F58D1790484}.Debug|x64.Build.0 = Debug|x64 18 | {E3216123-FBB1-4DE9-9989-5F58D1790484}.Debug|x86.ActiveCfg = Debug|Win32 19 | {E3216123-FBB1-4DE9-9989-5F58D1790484}.Debug|x86.Build.0 = Debug|Win32 20 | {E3216123-FBB1-4DE9-9989-5F58D1790484}.Release|x64.ActiveCfg = Release|x64 21 | {E3216123-FBB1-4DE9-9989-5F58D1790484}.Release|x64.Build.0 = Release|x64 22 | {E3216123-FBB1-4DE9-9989-5F58D1790484}.Release|x86.ActiveCfg = Release|Win32 23 | {E3216123-FBB1-4DE9-9989-5F58D1790484}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {F08241C7-D396-464A-A58F-87D46F8ED6F1} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /RunTest/Textures/Fonts/Future.dds: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Textures/Fonts/Future.dds -------------------------------------------------------------------------------- /RunTest/Textures/Fonts/Future.font: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dtrebilco/ECSAtto/86a04f0bdc521c79f758df94250c1898c39213c8/RunTest/Textures/Fonts/Future.font --------------------------------------------------------------------------------