diff --git a/Generate Function Reference.bat b/Generate Function Reference.bat new file mode 100644 index 00000000..e74b2c03 --- /dev/null +++ b/Generate Function Reference.bat @@ -0,0 +1,3 @@ +cd vs-project +python generate_function_reference.py +pause diff --git a/PyGLM build/.gitignore b/PyGLM build/.gitignore deleted file mode 100644 index f0f2feea..00000000 --- a/PyGLM build/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -Win32/ -x64/ diff --git a/PyGLM build/PyGLM build.vcxproj b/PyGLM build/PyGLM build.vcxproj deleted file mode 100644 index 41dbf08e..00000000 --- a/PyGLM build/PyGLM build.vcxproj +++ /dev/null @@ -1,365 +0,0 @@ - - - - - Debug - Win32 - - - Release - Win32 - - - Debug - x64 - - - Release - x64 - - - - 15.0 - {9908A257-6824-4543-B7E4-ACFD9F40AD85} - PyGLMbuild - 10.0 - - - - DynamicLibrary - true - v143 - MultiByte - - - DynamicLibrary - false - v143 - true - MultiByte - - - DynamicLibrary - true - v143 - MultiByte - - - DynamicLibrary - false - v143 - true - MultiByte - - - - - - - - - - - - - - - - - - - - - glm - .pyd - - - .pyd - glm - - - $(SolutionDir)$(Platform)\$(Configuration)\ - $(Platform)\$(Configuration)\ - glm - .pyd - - - $(SolutionDir)$(Platform)\$(Configuration)\ - $(Platform)\$(Configuration)\ - glm - .pyd - - - - Level3 - Disabled - true - true - PyGLM_DEBUG;%(PreprocessorDefinitions) - $(ProjectDir)..\PyGLM_lib\glm;C:\Python39\include;%(AdditionalIncludeDirectories) - - - C:\Python39\libs;%(AdditionalLibraryDirectories) - - - - - Level3 - Disabled - true - true - $(ProjectDir)..\PyGLM_lib\glm;C:\Python39\include;%(AdditionalIncludeDirectories) - MultiThreadedDLL - EnableFastChecks - PyGLM_DEBUG;%(PreprocessorDefinitions) - 4706;6282;%(DisableSpecificWarnings) - /bigobj %(AdditionalOptions) - - - C:\Python39\libs;%(AdditionalLibraryDirectories) - %(AdditionalDependencies) - - - - - Level3 - MaxSpeed - true - true - true - true - $(ProjectDir)..\PyGLM_lib\glm;C:\Python39\include;%(AdditionalIncludeDirectories) - - - true - true - C:\Python39\libs;%(AdditionalLibraryDirectories) - - - - - Level3 - MaxSpeed - true - true - true - true - $(ProjectDir)..\PyGLM_lib\glm;C:\Python39\include;%(AdditionalIncludeDirectories) - - - true - true - C:\Python39\libs;%(AdditionalLibraryDirectories) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/PyGLM build/PyGLM build.vcxproj.filters b/PyGLM build/PyGLM build.vcxproj.filters deleted file mode 100644 index 8d2aab9e..00000000 --- a/PyGLM build/PyGLM build.vcxproj.filters +++ /dev/null @@ -1,738 +0,0 @@ - - - - - {4FC737F1-C7A5-4376-A066-2A32D752A2FF} - cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx - - - {93995380-89BD-4b04-88EB-625FBE52EBFB} - h;hh;hpp;hxx;hm;inl;inc;ipp;xsd - - - {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} - rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms - - - {d93bf945-4c03-457f-aeba-cc08ef943ac5} - - - {3f71ae84-8e6d-46da-8d3e-1a6cb0431bce} - - - {a9c5658d-f855-4feb-adff-8938531bb467} - - - {a8ef72c0-c8d4-49be-9352-e28a6d9c7e53} - - - {f94804c9-2fd4-4727-9fba-10193a808b9d} - - - {91fc1aa6-030e-4a2e-93ae-a529391acf24} - - - {d91dc717-4ee5-4a11-8c49-aa7dd85ceaf9} - - - {86837062-3d03-403d-8a0f-6251bb31281b} - - - {989919bb-860f-484e-91a7-39890e432364} - - - {97504e6a-71c0-459c-b60e-adffd2de6397} - - - {0971f061-c871-459a-b9c1-1c8b93aaa6a6} - - - {50e02b2a-0ce5-4418-8ea1-b9864b0541e5} - - - {145e9a38-f295-49c9-ae38-33d20d4c3830} - - - {650253ba-6d79-40b0-b31f-dad50b3fd114} - - - {0e612982-f616-4550-b17d-13f8e0a372ab} - - - {5cf1e6fe-ce56-424d-97f2-672fc8b011da} - - - {668b47bb-5447-40ee-a242-38772b642df7} - - - {fd72c7af-27af-434b-a4bf-af8c36719f58} - - - {360afe8a-a253-4fa7-8db2-8ec052e5b443} - - - {8b909f83-8bb7-45ff-bc39-e101bbf4235d} - - - {3030b6ae-9322-4b96-bd5e-0b3c669b829a} - - - {6142d088-f7b0-49b8-b105-1a6a2646d137} - - - {ec62c849-01b6-4e71-97a8-fa23a46b2d04} - - - {14240a23-84d1-4c0e-b53b-e15e84291972} - - - {c498d64f-2c40-4601-bad7-f219c50a99d9} - - - {8b0e119c-7855-4179-aafb-f5334e320d3f} - - - {18e7d3dd-8dfc-4bf8-9e09-cba1262d33ef} - - - {1847a5e6-780a-4faf-8c52-e9124d276099} - - - {7d1459e6-6a98-4ab3-a1bc-4c2b309b01af} - - - {cc8ad1ac-68eb-4201-9d4f-ac075fb1ad3f} - - - {cf94377a-52e0-4533-a33b-c7ed3af9427c} - - - {9c1ef5d8-f6e3-4b55-81d4-37a331591355} - - - {fe2f4a1c-7980-41c6-8b20-169657425284} - - - {9a1c0558-9aa2-456e-81a1-69810e680b20} - - - {e30da7da-a8d1-490b-8537-99d2ee24ebf1} - - - {26a4ef7e-5751-405c-b536-464a1e3b70c0} - - - - - Quelldateien - - - - - Headerdateien - - - Headerdateien - - - Headerdateien\PyGLM\functions\detail - - - Headerdateien\PyGLM\functions\detail - - - Headerdateien\PyGLM\functions\detail - - - Headerdateien\PyGLM\functions\detail - - - Headerdateien\PyGLM\functions\detail - - - Headerdateien\PyGLM\functions\detail - - - Headerdateien\PyGLM\functions\detail - - - Headerdateien\PyGLM\functions\detail - - - Headerdateien\PyGLM\functions\detail - - - Headerdateien\PyGLM\functions\other - - - Headerdateien\PyGLM\functions\other - - - Headerdateien\PyGLM\functions\other - - - Headerdateien\PyGLM\functions\other - - - Headerdateien\PyGLM\functions\other - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\stable_extensions - - - Headerdateien\PyGLM\functions\unstable_extensions - - - Headerdateien\PyGLM\functions\unstable_extensions - - - Headerdateien\PyGLM\functions\unstable_extensions - - - Headerdateien\PyGLM\functions\unstable_extensions - - - Headerdateien\PyGLM\functions\unstable_extensions - - - Headerdateien\PyGLM\functions\unstable_extensions - - - Headerdateien\PyGLM\functions\unstable_extensions - - - Headerdateien\PyGLM\functions - - - Headerdateien\PyGLM\functions - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions\type_getters - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\internal_functions - - - Headerdateien\PyGLM\type_methods - - - Headerdateien\PyGLM\type_methods - - - Headerdateien\PyGLM\type_methods - - - Headerdateien\PyGLM\type_methods - - - Headerdateien\PyGLM\type_methods - - - Headerdateien\PyGLM\type_methods - - - Headerdateien\PyGLM\types\glmArray - - - Headerdateien\PyGLM\types\glmArray - - - Headerdateien\PyGLM\types\mat - - - Headerdateien\PyGLM\types\mat - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\double - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\float - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\int - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mat\uint - - - Headerdateien\PyGLM\types\mvec - - - Headerdateien\PyGLM\types\mvec - - - Headerdateien\PyGLM\types\mvec\double - - - Headerdateien\PyGLM\types\mvec\double - - - Headerdateien\PyGLM\types\mvec\double - - - Headerdateien\PyGLM\types\mvec\double - - - Headerdateien\PyGLM\types\mvec\float - - - Headerdateien\PyGLM\types\mvec\float - - - Headerdateien\PyGLM\types\mvec\float - - - Headerdateien\PyGLM\types\mvec\float - - - Headerdateien\PyGLM\types\mvec\int - - - Headerdateien\PyGLM\types\mvec\int - - - Headerdateien\PyGLM\types\mvec\int - - - Headerdateien\PyGLM\types\mvec\int - - - Headerdateien\PyGLM\types\mvec\uint - - - Headerdateien\PyGLM\types\mvec\uint - - - Headerdateien\PyGLM\types\mvec\uint - - - Headerdateien\PyGLM\types\mvec\uint - - - Headerdateien\PyGLM\types\qua\double - - - Headerdateien\PyGLM\types\qua - - - Headerdateien\PyGLM\types\qua - - - Headerdateien\PyGLM\types\qua\float - - - Headerdateien\PyGLM\types\vec\double - - - Headerdateien\PyGLM\types\vec\double - - - Headerdateien\PyGLM\types\vec\double - - - Headerdateien\PyGLM\types\vec\double - - - Headerdateien\PyGLM\types\vec\double - - - Headerdateien\PyGLM\types\vec\float - - - Headerdateien\PyGLM\types\vec\float - - - Headerdateien\PyGLM\types\vec\float - - - Headerdateien\PyGLM\types\vec\float - - - Headerdateien\PyGLM\types\vec\float - - - Headerdateien\PyGLM\types\vec\int8 - - - Headerdateien\PyGLM\types\vec\int8 - - - Headerdateien\PyGLM\types\vec\int8 - - - Headerdateien\PyGLM\types\vec\int8 - - - Headerdateien\PyGLM\types\vec\int8 - - - Headerdateien\PyGLM\types\vec\int16 - - - Headerdateien\PyGLM\types\vec\int16 - - - Headerdateien\PyGLM\types\vec\int16 - - - Headerdateien\PyGLM\types\vec\int16 - - - Headerdateien\PyGLM\types\vec\int16 - - - Headerdateien\PyGLM\types\vec\int32 - - - Headerdateien\PyGLM\types\vec\int32 - - - Headerdateien\PyGLM\types\vec\int32 - - - Headerdateien\PyGLM\types\vec\int32 - - - Headerdateien\PyGLM\types\vec\int32 - - - Headerdateien\PyGLM\types\vec\int64 - - - Headerdateien\PyGLM\types\vec\int64 - - - Headerdateien\PyGLM\types\vec\int64 - - - Headerdateien\PyGLM\types\vec\int64 - - - Headerdateien\PyGLM\types\vec\int64 - - - Headerdateien\PyGLM\types\vec\bool - - - Headerdateien\PyGLM\types\vec\bool - - - Headerdateien\PyGLM\types\vec\bool - - - Headerdateien\PyGLM\types\vec\bool - - - Headerdateien\PyGLM\types\vec\bool - - - Headerdateien\PyGLM\types\vec\uint64 - - - Headerdateien\PyGLM\types\vec\uint64 - - - Headerdateien\PyGLM\types\vec\uint64 - - - Headerdateien\PyGLM\types\vec\uint64 - - - Headerdateien\PyGLM\types\vec\uint64 - - - Headerdateien\PyGLM\types\vec\uint32 - - - Headerdateien\PyGLM\types\vec\uint32 - - - Headerdateien\PyGLM\types\vec\uint32 - - - Headerdateien\PyGLM\types\vec\uint32 - - - Headerdateien\PyGLM\types\vec\uint32 - - - Headerdateien\PyGLM\types\vec\uint16 - - - Headerdateien\PyGLM\types\vec\uint16 - - - Headerdateien\PyGLM\types\vec\uint16 - - - Headerdateien\PyGLM\types\vec\uint16 - - - Headerdateien\PyGLM\types\vec\uint16 - - - Headerdateien\PyGLM\types\vec\uint8 - - - Headerdateien\PyGLM\types\vec\uint8 - - - Headerdateien\PyGLM\types\vec\uint8 - - - Headerdateien\PyGLM\types\vec\uint8 - - - Headerdateien\PyGLM\types\vec\uint8 - - - Headerdateien\PyGLM\types\vec - - - Headerdateien\PyGLM\types\vec - - - Headerdateien\PyGLM\types - - - Headerdateien\PyGLM\types - - - Headerdateien\PyGLM\types - - - Headerdateien\PyGLM - - - Headerdateien\PyGLM - - - Headerdateien\PyGLM\types - - - Headerdateien - - - \ No newline at end of file diff --git a/PyGLM build/PyGLM build.vcxproj.user b/PyGLM build/PyGLM build.vcxproj.user deleted file mode 100644 index be250787..00000000 --- a/PyGLM build/PyGLM build.vcxproj.user +++ /dev/null @@ -1,4 +0,0 @@ - - - - \ No newline at end of file diff --git a/Update README.bat b/Update README.bat index 65489101..02b9a1f3 100644 --- a/Update README.bat +++ b/Update README.bat @@ -1,2 +1,2 @@ -python "PyGLM test/SlashBack.py" README.sb +python "vs-project/SlashBack.py" README.sb PAUSE \ No newline at end of file diff --git a/test/PyGLM vs NumPy.py b/test/PyGLM vs NumPy.py deleted file mode 100644 index fefe1450..00000000 --- a/test/PyGLM vs NumPy.py +++ /dev/null @@ -1,251 +0,0 @@ -import timeit, sys, random -import glm, numpy - -ON_WINDOWS = sys.platform == 'win32' - -print_horizontal_rule = lambda: print("+----------------------------------------+------------+------------+-----------+") - -pad_with_spaces = lambda text, length, align="left": text + " " * (length - len(text)) if align == "left" else " " * (length - len(text)) + text - -seconds_to_milliseconds = lambda seconds: int(round(seconds * 1000, 0)) - -pyglm_total_time = 0 -numpy_total_time = 0 - -def word_wrap(text, max_length): - out = [] - current_word = [] - current_length = 0 - for c in text: - if current_length >= max_length: - out.append("\n") - current_length = len(current_word) - - if c == " ": - out.append("".join(current_word)) - if (current_length < max_length): - out.append(" ") - current_word = [] - elif c == "\n": - out.append("".join(current_word)) - out.append("\n") - current_word = [] - current_length = 0 - else: - current_word.append(c) - - current_length += 1 - - if current_word: - out.append("".join(current_word)) - - return "".join(out).rstrip() - -def print_row(descr, pyglm, numpy, ratio, print_header=True, end="\n"): - descr = word_wrap(descr, 38) - - descr_lines = descr.split("\n") - - if print_header: - for line in descr_lines[:-1]: - print(f"| {pad_with_spaces(line, 38)} | {' ' * 10} | {' ' * 10} | {' ' * 9} |") - - descr_last_line = descr_lines[-1] - - print(f"| {pad_with_spaces(descr_last_line, 38)} | {pad_with_spaces(pyglm, 10, align='right')} | {pad_with_spaces(numpy, 10, align='right')} | {pad_with_spaces(ratio, 9, align='right')} |", end=end) - -def run_test(descr, pyglm_setup_code, pyglm_code, numpy_setup_code, numpy_code, number): - global pyglm_total_time, numpy_total_time - - descr += f"\n({number:,} times)" - - if ON_WINDOWS: - print_row(descr, "", "", "", end="\r") - - pyglm_result = 2**31 - numpy_result = 2**31 - - for i in range(10): - run_pyglm_first = random.choice((True,False)) - - if run_pyglm_first: - pyglm_result = min(pyglm_result, timeit.timeit(pyglm_code, pyglm_setup_code, number=number)) - numpy_result = min(numpy_result, timeit.timeit(numpy_code, numpy_setup_code, number=number)) - else: - numpy_result = min(numpy_result, timeit.timeit(numpy_code, numpy_setup_code, number=number)) - pyglm_result = min(pyglm_result, timeit.timeit(pyglm_code, pyglm_setup_code, number=number)) - - - if ON_WINDOWS: - print_row(descr, "{}ms".format(seconds_to_milliseconds(pyglm_result)), "{}ms".format(seconds_to_milliseconds(numpy_result)), "{:.02f}x".format(numpy_result / pyglm_result), end="\r", print_header=False) - - pyglm_total_time += pyglm_result - numpy_total_time += numpy_result - - print_row(descr, "{}ms".format(seconds_to_milliseconds(pyglm_result)), "{}ms".format(seconds_to_milliseconds(numpy_result)), "{:.02f}x".format(numpy_result / pyglm_result), print_header=not ON_WINDOWS) - print_horizontal_rule() - -print(f"""Evaluating performance of PyGLM compared to NumPy. - -Running on platform '{sys.platform}'. - -Python version: -{sys.version} - -Comparing the following module versions: -{glm.version} - vs -NumPy version {numpy.__version__} -________________________________________________________________________________ - -The following table shows information about a task to be achieved and the time -it took when using the given module. Lower time is better. -Each task is repeated ten times per module, only showing the best (i.e. lowest) -value. - -""") - -print_horizontal_rule() -print_row("Description", "PyGLM time", "NumPy time", "ratio") -print_horizontal_rule() - -############################ -# Actual tests start here: # -############################ - -run_test("3 component vector creation", - - "import glm", - "glm.vec3()", - - "import numpy", - "numpy.zeros((3,), numpy.float32)", - - 100000 -) - -run_test("3 component vector creation with custom components", - - "import glm", - "glm.vec3(1,2,3)", - - "import numpy", - "numpy.array((1,2,3), numpy.float32)", - - 50000 -) - -run_test("dot product", - - "import glm; v1 = glm.vec3(); v2 = glm.vec3()", - "glm.dot(v1, v2)", - - "import numpy; v1 = numpy.zeros((3,), numpy.float32); v2 = numpy.zeros((3,), numpy.float32)", - "numpy.dot(v1, v2)", - - 50000 -) - -run_test("cross product", - - "import glm; v1 = glm.vec3(1); v2 = glm.vec3(1,2,3)", - "glm.cross(v1, v2)", - - "import numpy; v1 = numpy.array((1,1,1), numpy.float32); v2 = numpy.array((1,2,3), numpy.float32)", - "numpy.cross(v1, v2)", - - 25000 -) - -run_test("L2-Norm of 3 component vector", - - "import glm; v = glm.vec3(1,2,3)", - "glm.l2Norm(v)", - - "import numpy; v = numpy.array((1,1,1), numpy.float32)", - "numpy.linalg.norm(v)", - - 100000 -) - -run_test("4x4 matrix creation", - - "import glm", - "glm.mat4(0)", - - "import numpy", - "numpy.zeros((4,4), numpy.float32)", - - 50000 -) -run_test("4x4 identity matrix creation", - - "import glm", - "glm.mat4()", - - "import numpy", - "numpy.identity(4, numpy.float32)", - - 100000 -) - -run_test("4x4 matrix transposition", - - "import glm; m = glm.mat4()", - "glm.transpose(m)", - - "import numpy; m = numpy.identity(4, numpy.float32)", - "numpy.transpose(m)", - - 50000 -) - -run_test("4x4 multiplicative inverse", - - "import glm; m = glm.mat4()", - "glm.inverse(m)", - - "import numpy; m = numpy.identity(4, numpy.float32)", - "numpy.linalg.inv(m)", - - 50000 -) - -run_test("3 component vector addition", - - "import glm; v1 = glm.vec3(1); v2 = glm.vec3(1,2,3)", - "v1 + v2", - - "import numpy; v1 = numpy.array((1,1,1), numpy.float32); v2 = numpy.array((1,2,3), numpy.float32)", - "v1 + v2", - - 100000 -) - -run_test("4x4 matrix multiplication", - - "import glm; m1 = glm.mat4(); m2 = glm.mat4(2)", - "m1 * m2", - - "import numpy; m1 = numpy.identity(4, numpy.float32); m2 = numpy.identity(4, numpy.float32) * 2", - "m1 * m2", - - 100000 -) - -run_test("4x4 matrix x vector multiplication", - - "import glm; m = glm.mat4(); v = glm.vec4()", - "m * v", - - "import numpy; m = numpy.identity(4, numpy.float32); v = numpy.zeros((4,), numpy.float32)", - "m * v", - - 100000 -) - -print_row("TOTAL", - "{:.02f}s".format(pyglm_total_time), - "{:.02f}s".format(numpy_total_time), - "{:.02f}x".format(numpy_total_time / pyglm_total_time)) -print_horizontal_rule() diff --git a/vs-project/PyGLM_vs_NumPy.py b/test/PyGLM_vs_NumPy.py similarity index 100% rename from vs-project/PyGLM_vs_NumPy.py rename to test/PyGLM_vs_NumPy.py diff --git a/vs-project/PyGLM test.pyproj b/vs-project/PyGLM test.pyproj index ccbc132d..f6293f98 100644 --- a/vs-project/PyGLM test.pyproj +++ b/vs-project/PyGLM test.pyproj @@ -6,8 +6,7 @@ PyGLM_run.py - - + ..\test . . PyGLM test @@ -29,9 +28,7 @@ - - diff --git a/vs-project/PyGLM_run.py b/vs-project/PyGLM_run.py index bc7266b0..dbd7dcde 100644 --- a/vs-project/PyGLM_run.py +++ b/vs-project/PyGLM_run.py @@ -1,5 +1,5 @@ -import os, shutil +import os os.environ["TEST_PICKLING"] = "True" @@ -14,7 +14,6 @@ if TEST: import PyGLM_test, time, traceback, sys - shutil.copy2("PyGLM_test.py", "../test/PyGLM_test.py") print("Testing PyGLM...") start_time = time.time() for member in dir(PyGLM_test): diff --git a/vs-project/PyGLM_test.py b/vs-project/PyGLM_test.py deleted file mode 100644 index 1d4b4039..00000000 --- a/vs-project/PyGLM_test.py +++ /dev/null @@ -1,3693 +0,0 @@ -import glm, sys, random, time, copy, re, math, ctypes - -from collections import OrderedDict - -glm.silence(0) - -## type checking definitions ## -PyGLM_DT_UNKNOWN = 0x0000000 -PyGLM_DT_FLOAT = 0x0000001 -PyGLM_DT_DOUBLE = 0x0000002 -PyGLM_DT_INT = 0x0000004 -PyGLM_DT_UINT = 0x0000008 -PyGLM_DT_INT8 = 0x0000010 -PyGLM_DT_UINT8 = 0x0000020 -PyGLM_DT_INT16 = 0x0000040 -PyGLM_DT_UINT16 = 0x0000080 -PyGLM_DT_INT64 = 0x0000100 -PyGLM_DT_UINT64 = 0x0000200 -PyGLM_DT_BOOL = 0x0000400 - -PyGLM_SHAPE_2x2 = 0x0000800 -PyGLM_SHAPE_2x3 = 0x0001000 -PyGLM_SHAPE_2x4 = 0x0002000 -PyGLM_SHAPE_3x2 = 0x0004000 -PyGLM_SHAPE_3x3 = 0x0008000 -PyGLM_SHAPE_3x4 = 0x0010000 -PyGLM_SHAPE_4x2 = 0x0020000 -PyGLM_SHAPE_4x3 = 0x0040000 -PyGLM_SHAPE_4x4 = 0x0080000 - -PyGLM_SHAPE_1 = 0x0100000 -PyGLM_SHAPE_2 = 0x0200000 -PyGLM_SHAPE_3 = 0x0400000 -PyGLM_SHAPE_4 = 0x0800000 - -PyGLM_T_VEC = 0x1000000 -PyGLM_T_MVEC = 0x2000000 -PyGLM_T_MAT = 0x4000000 -PyGLM_T_QUA = 0x8000000 - -PyGLM_T_NUMBER = 0x10000000 - -PyGLM_T_ANY_VEC = (PyGLM_T_VEC | PyGLM_T_MVEC) -PyGLM_T_ANY_ARR = (PyGLM_T_ANY_VEC | PyGLM_T_QUA) - -PyGLM_SHAPE_SQUARE = (PyGLM_SHAPE_2x2 | PyGLM_SHAPE_3x3 | PyGLM_SHAPE_4x4) - -PyGLM_SHAPE_2xM = (PyGLM_SHAPE_2x2 | PyGLM_SHAPE_2x3 | PyGLM_SHAPE_2x4) -PyGLM_SHAPE_3xM = (PyGLM_SHAPE_3x2 | PyGLM_SHAPE_3x3 | PyGLM_SHAPE_3x4) -PyGLM_SHAPE_4xM = (PyGLM_SHAPE_4x2 | PyGLM_SHAPE_4x3 | PyGLM_SHAPE_4x4) - -PyGLM_DT_ALL = ((1 << 11) - 1) -PyGLM_SHAPE_ALL = (((1 << 13) - 1) << 11) -PyGLM_T_ALL = (((1 << 5) - 1) << 24) - -PyGLM_ALL = (PyGLM_DT_ALL | PyGLM_SHAPE_ALL | PyGLM_T_ALL) -##/type checking definitions ## - -#def get_info(num): -# glob = globals() -# vars_ = [x for x in glob if x.startswith("PyGLM_") and not "ANY" in x and not "xM" in x and not "ALL" in x and not "SQUARE" in x] -# out = [] -# for var in vars_: -# if (glob[var] & num): -# out.append(var) - -# return ", ".join(out) - -#def get_info_of(obj): -# return get_info(glm._get_type_info(PyGLM_ALL, obj)) - -#gio = get_info_of - - - -datatypes = ("float", "double", "int", "glm::uint", "glm::i64", "glm::u64", "glm::i16", "glm::u16", "glm::i8", "glm::u8", "bool") -prefixes = ("f", "d", "i", "u", "i64", "u64", "i16", "u16", "i8", "u8", "b") - -suffixes = "fFiIqQsSuUB" - -vector_type_ids = tuple(range(len(datatypes))) - -matrix_type_ids = tuple(range(4)) - -quat_type_ids = tuple(range(2)) - -vector_type_dict = {} - -vector_length_dict = {} - -vector_types = [] - -matrix_type_dict = {} - -matrix_length_dict = {} - -matrix_types = [] - -quat_type_dict = {} - -quat_types = [] - -ctypes_types = [glm.c_float, glm.c_double, glm.c_int64, glm.c_int32, glm.c_int16, glm.c_int8, glm.c_uint64, glm.c_uint32, glm.c_uint16, glm.c_uint8, glm.c_bool] - -for type_id in vector_type_ids: - vector_type_dict[type_id] = [] - this_list = vector_type_dict[type_id] - - for L in range(1, 5): - tp = getattr(glm, "{T}vec{L}".format(T=prefixes[type_id], L=L)) - vll = vector_length_dict.get(L, []) - vll.append(tp) - vector_length_dict[L] = vll - this_list.append(tp) - - vector_types += this_list - - -for type_id in matrix_type_ids: - matrix_type_dict[type_id] = [] - this_list = matrix_type_dict[type_id] - - for C in range(2, 5): - for R in range(2, 5): - tp = getattr(glm, "{T}mat{C}x{R}".format(T=prefixes[type_id], C=C, R=R)) - mll = matrix_length_dict.get((C,R), []) - mll.append(tp) - matrix_length_dict[(C,R)] = mll - this_list.append(tp) - - matrix_types += this_list - -for type_id in quat_type_ids: - quat_type_dict[type_id] = [] - this_list = quat_type_dict[type_id] - - this_list.append(getattr(glm, "{T}quat".format(T=prefixes[type_id]))) - - quat_types += this_list - -obj_gen = lambda types: (T() for T in types) - -def list_replace(list_, x, y): - list_copy = list(list_) - for i in range(len(list_copy)): - list_copy[i] = list_copy[i].replace(x, y) - return list_copy - -randf = lambda: random.random()*100 -randfs = lambda: randf()-50 - -mvec_mats = { - "f2" : glm.fmat2x2(0), - "f3" : glm.fmat2x3(0), - "f4" : glm.fmat2x4(0), - "d2" : glm.dmat2x2(0), - "d3" : glm.dmat2x3(0), - "d4" : glm.dmat2x4(0), - "i2" : glm.imat2x2(0), - "i3" : glm.imat2x3(0), - "i4" : glm.imat2x4(0), - "u2" : glm.umat2x2(0), - "u3" : glm.umat2x3(0), - "u4" : glm.umat2x4(0), - } - -def get_args(arg_string, type_, rand_func=None): - if not rand_func: - if type_ in "IQSU": - rand_func = randf - else: - rand_func = randfs - args = [] - for arg in arg_string: - if arg == "N": - if type_ in "fF": - args.append(float(rand_func())) - if type_ in "iqsu": - args.append(int(rand_func())) - if type_ in "IQSU": - args.append(int(randf())) - if type_ == "B": - args.append(random.choice((True, False))) - - elif arg == "Ni": - args.append(int(rand_func())) - - elif arg == "NB": - args.append(random.choice((True, False))) - - elif "V" in arg: - if len(arg) == 3 and arg[2] in "fFiB": - T = prefixes[suffixes.index(arg[2])] - else: - T = prefixes[suffixes.index(type_)] - - L = int(arg[1]) - rf = rand_func - if T == "b": - rf = lambda: random.choice((True, False)) - args.append(getattr(glm, "{T}vec{L}".format(T=T, L=L))(*(rf() for x in range(L)))) - - elif "P" in arg: - if len(arg) == 3 and arg[2] in "fFi": - T = prefixes[suffixes.index(arg[2])] - else: - T = prefixes[suffixes.index(type_)] - - L = int(arg[1]) - - if not type_ in "fFiI" or L < 2: - continue - - args.append(mvec_mats["{T}{L}".format(T=T, L=L)][0]) - - elif arg == "Q": - if not type_ in "fF": - continue - args.append(getattr(glm, "{T}quat".format(T=prefixes[suffixes.index(type_)]))(rand_func(), rand_func(), rand_func(), rand_func())) - - elif "M" in arg: - if len(arg) == 4 and arg[3] in "fFiI": - T = prefixes[suffixes.index(arg[3])] - else: - T = prefixes[suffixes.index(type_)] - - if not type_ in "fFiI": - continue - - n = int(arg[1]) - m = int(arg[2]) - args.append(getattr(glm, "{T}mat{n}x{m}".format(T=prefixes[suffixes.index(type_)], n=n, m=m))(*[rand_func() for i in range(n*m)])) - - return args - -def gen_args(args_string): - if "#M" in args_string: - supports_mvec = True - args_string = args_string.replace("#M", "") - else: - supports_mvec = False - if "#u" in args_string: - rand_func = randf - args_string = args_string.replace("#u", "") - elif "#p" in args_string: - rand_func = lambda: randf() + 1 - args_string = args_string.replace("#p", "") - elif "#d" in args_string: - rand_func = random.random - args_string = args_string.replace("#d", "") - elif "#x" in args_string: - res = randf() - rand_func = lambda: res - args_string = args_string.replace("#x", "") - else: - rand_func = None - - if "__" in args_string: - arg_part, type_part = args_string.split("__") - parts = arg_part.split("_") - types = type_part - else: - parts = args_string.split("_") - types = suffixes - - mvec_types = ("f" if "f" in types else "") + ("F" if "F" in types else "") + ("i" if "i" in types else "") + ("I" if "I" in types else "") - - for part in parts: - arg_strings = [] - current_text = "" - for char in part: - if not char in "1234" + "fFiB": - if current_text != "": - arg_strings.append(current_text) - current_text = "" - current_text += char - if current_text: - arg_strings.append(current_text) - - if "N" in arg_strings and not ("V" in arg_strings or "M" in arg_strings): - yield get_args(arg_strings, "F" if "F" in types else "f" if "f" in types else "i" if "i" in types else "I" if "I" in types else types[0], rand_func) - elif "V" in arg_strings: - for T in types: - for L in range(1, 5): - yield get_args(list_replace(arg_strings, "V", "V{L}".format(L=L)), T, rand_func) - if supports_mvec: - for T in mvec_types: - for L in range(2, 5): - yield get_args(list_replace(arg_strings, "V", "P{L}".format(L=L)), T, rand_func) - elif "P" in arg_strings: - for T in mvec_types: - for L in range(2, 5): - yield get_args(list_replace(arg_strings, "P", "P{L}".format(L=L)), T, rand_func) - - elif "Vf" in arg_strings: - for L in range(1, 5): - yield get_args(list_replace(arg_strings, "Vf", "V{L}".format(L=L)), "f", rand_func) - if supports_mvec: - for L in range(2, 5): - yield get_args(list_replace(arg_strings, "Vf", "P{L}".format(L=L)), "f", rand_func) - - elif "VF" in arg_strings: - for L in range(1, 5): - yield get_args(list_replace(arg_strings, "VF", "V{L}".format(L=L)), "F", rand_func) - if supports_mvec: - for L in range(2, 5): - yield get_args(list_replace(arg_strings, "VF", "P{L}".format(L=L)), "F", rand_func) - - elif "Vi" in arg_strings: - for L in range(1, 5): - yield get_args(list_replace(arg_strings, "Vi", "V{L}".format(L=L)), "i", rand_func) - if supports_mvec: - for L in range(2, 5): - yield get_args(list_replace(arg_strings, "Vi", "P{L}".format(L=L)), "i", rand_func) - - elif "VB" in arg_strings: - for L in range(1, 5): - yield get_args(list_replace(arg_strings, "VB", "V{L}".format(L=L)), "B", lambda: random.choice((True, False))) - - elif "V1" in arg_strings or "V2" in arg_strings or "V3" in arg_strings or "V4" in arg_strings or "M22" in arg_strings or "M23" in arg_strings or "M24" in arg_strings or "M32" in arg_strings or "M33" in arg_strings or "M34" in arg_strings or "M42" in arg_strings or "M43" in arg_strings or "M44" in arg_strings: - for T in types: - yield get_args(arg_strings, T, rand_func) - if supports_mvec: - for T in mvec_types: - yield get_args(list_replace(arg_strings, "V", "P"), T, rand_func) - - elif "Q" in arg_strings: - for T in types: - if not T in "fF": - continue - yield get_args(arg_strings, T, rand_func) - - elif "M" in arg_strings: - for T in types: - if not T in "fFiI": - continue - for C in range(2,5): - for R in range(2,5): - yield get_args(list_replace(arg_strings, "M", "M{C}{R}".format(C=C,R=R)), T, rand_func) - - elif "Mf" in arg_strings: - for C in range(2,5): - for R in range(2,5): - yield get_args(list_replace(arg_strings, "Mf", "M{C}{R}".format(C=C,R=R)), "f", rand_func) - - elif "MF" in arg_strings: - for C in range(2,5): - for R in range(2,5): - yield get_args(list_replace(arg_strings, "MF", "M{C}{R}".format(C=C,R=R)), "F", rand_func) - - elif "-" in arg_strings: - yield () - -def gen_obj(args_string): - for args in gen_args(args_string): - yield args[0] - -def gen_type(args_string): - for obj in gen_obj(args_string): - yield type(obj) - -def get_len_of_type(type_): - return len(type_()) - -def optional_any(x): - if hasattr(x, "__len__"): - return glm.any(x) - return bool(x) - -def optional_all(x): - if hasattr(x, "__len__"): - return glm.all(x) - return bool(x) - - -possible_arg_combinations = ['-', 'M', 'M22', 'M22M22', 'M22M23', 'M22M24', 'M22M32', 'M22M33', 'M22M34', 'M22M42', 'M22M43', 'M22M44', 'M22V2V2', 'M23', 'M23M22', 'M23M23', 'M23M24', 'M23M32', 'M23M33', 'M23M34', 'M23M42', 'M23M43', 'M23M44', 'M23V3V3', 'M24', 'M24M22', 'M24M23', 'M24M24', 'M24M32', 'M24M33', 'M24M34', 'M24M42', 'M24M43', 'M24M44', 'M24V4V4', 'M32', 'M32M22', 'M32M23', 'M32M24', 'M32M32', 'M32M33', 'M32M34', 'M32M42', 'M32M43', 'M32M44', 'M32V2V2V2', 'M33', 'M33M22', 'M33M23', 'M33M24', 'M33M32', 'M33M33', 'M33M34', 'M33M42', 'M33M43', 'M33M44', 'M33N', 'M33V2', 'M33V3V3V3', 'M34', 'M34M22', 'M34M23', 'M34M24', 'M34M32', 'M34M33', 'M34M34', 'M34M42', 'M34M43', 'M34M44', 'M34V4V4V4', 'M42', 'M42M22', 'M42M23', 'M42M24', 'M42M32', 'M42M33', 'M42M34', 'M42M42', 'M42M43', 'M42M44', 'M42V2V2V2V2', 'M43', 'M43M22', 'M43M23', 'M43M24', 'M43M32', 'M43M33', 'M43M34', 'M43M42', 'M43M43', 'M43M44', 'M43V3V3V3V3', 'M44', 'M44M22', 'M44M23', 'M44M24', 'M44M32', 'M44M33', 'M44M34', 'M44M42', 'M44M43', 'M44M44', 'M44NV3', 'M44V3', 'M44V3QV3V3V4', 'M44V4V4V4V4', 'MFMFNi', 'MM', 'MMM', 'MfMfNi', 'N', 'NN', 'NNN', 'NNNB', 'NNNN', 'NNNNN', 'NNNNNN', 'NNNNNNNN', 'NNNNNNNNN', 'NNNNNNNNNNNN', 'NNNNNNNNNNNNNNNN', 'NNNi', 'NNV', 'NNi', 'NV', 'NV3', 'P', 'Q', 'QN', 'QNV3', 'QQ', 'QQN', 'QQQ', 'V', 'V1', 'V2', 'V2N', 'V2V2', 'V2V2V4', 'V2V3', 'V2V4', 'V3', 'V3M44M44V4', 'V3N', 'V3NV2', 'V3NV3', 'V3Ni', 'V3V2', 'V3V2N', 'V3V3', 'V3V3N', 'V3V3Ni', 'V3V3V3', 'V3V4', 'V4', 'V4N', 'V4NNV2', 'V4NV2N', 'V4NV3', 'V4V2', 'V4V2NN', 'V4V3', 'V4V3N', 'V4V4', 'VFVFNi', 'VN', 'VNN', 'VNi', 'VV', 'VVN', 'VVNN', 'VVV', 'VVVB', 'VVVF', 'VVVV', 'VVVVVVVVVVVV', 'VVVf', 'VVi', 'VfVfNi'] - -def gen_anti_args(args_string): - yield None, - yield None, None - yield None, None, None - yield None, None, None, None - yield None, None, None, None, None - yield None, None, None, None, None, None - yield object, - yield object, object - yield object, object, object - yield object, object, object, object - yield object, object, object, object, object - yield object, object, object, object, object, object - yield (), - yield (), () - yield (), (), () - yield (), (), (), () - yield (), (), (), (), () - yield (), (), (), (), (), () - yield [], - yield [], [] - yield [], [], [] - yield [], [], [], [] - yield [], [], [], [], [] - yield [], [], [], [], [], [] - yield {}, - yield {}, {} - yield {}, {}, {} - yield {}, {}, {}, {} - yield {}, {}, {}, {}, {} - yield {}, {}, {}, {}, {}, {} - - arg_combis = possible_arg_combinations #random.sample(possible_arg_combinations, 20) - - all_types = "fFiqsuIQSUB" - - args_string = re.sub("#.", "", args_string) - - args_string, types = args_string.split("__") if "__" in args_string else (args_string, None) - - args = args_string.split("_") - - anti_args_string = "#M" + "_".join(filter(lambda possible_arg_combi: possible_arg_combi not in args, arg_combis)) + "__" + all_types - - for arg in gen_args(anti_args_string): - yield arg - -#v1 = glm.vec1() -#v2 = glm.vec2() -#v3 = glm.vec3() -#v4 = glm.vec4() - -#vectors = [v1, v2, v3, v4] - -#vector_types = [glm.vec1, glm.vec2, glm.vec3, glm.vec4] - -#m22 = glm.mat2x2() -#m23 = glm.mat2x3() -#m24 = glm.mat2x4() -#m32 = glm.mat3x2() -#m33 = glm.mat3x3() -#m34 = glm.mat3x4() -#m42 = glm.mat4x2() -#m43 = glm.mat4x3() -#m44 = glm.mat4x4() - -#matrices = [m22, m23, m24, m32, m33, m34, m42, m43, m44] - -#matrix_types = [glm.mat2x2, glm.mat2x3, glm.mat2x4, glm.mat3x2, glm.mat3x3, glm.mat3x4, glm.mat4x2, glm.mat4x3, glm.mat4x4] - -#q = glm.quat() - -#all_types = vector_types + matrix_types + [glm.quat] - -#all_type_objects = vectors + matrices + [q] - -#get_obj_generator = lambda types: (x() for x in types) - -class FAssertionError(Exception): - pass - -def fassert(func, args): - try: - return func(*args) - except: - raise FAssertionError("{} raised {} with {}".format(func, sys.exc_info()[1], repr(args))) - -def fnassert(func, args): - try: - func(*args) - raise FAssertionError("{} raised nothing with {}".format(func, repr(args))) - except: - pass - -def fail(*args): - raise FAssertionError("Failed with " + str(args)) - -# Specific # -def test_specific(): - assert isinstance(glm.version, str) - assert isinstance(glm.license, str) -#/Specific # - -# Custom # -def test_custom(): - for vec_type in (glm.vec4, glm.dvec4): - v = vec_type(1, 2, 3, 4) - - q = glm.vec4_to_quat(v) - - assert v.x == q.x - assert v.y == q.y - assert v.z == q.z - assert v.w == q.w - - v = glm.quat_to_vec4(q) - - assert v.x == q.x - assert v.y == q.y - assert v.z == q.z - assert v.w == q.w - -#/Custom # - -# Initialization # -## vec1 -def test_vec1_types(): - for args in gen_args("#u-_N_V1"): # need to add support for _V1_V2_V3_V4 - for T in vector_length_dict[1]: - fassert(T, args) - - for args in gen_anti_args("#u-_N_V1"): - for T in vector_length_dict[1]: - fnassert(T, args) - -## vec2 -def test_vec2_types(): - for args in gen_args("#u-_N_NN_V2"): - for T in vector_length_dict[2]: - fassert(T, args) - - for args in gen_args("#uV2V3_V2V4"): - fassert(type(args[0]), args[1:]) - - for args in gen_anti_args("#u-_N_NN_V2"): - for T in vector_length_dict[2]: - fnassert(T, args) - -## vec3 -def test_vec3_types(): - for args in gen_args("#u-_N_NNN_V3"): - for T in vector_length_dict[3]: - fassert(T, args) - - for args in gen_args("#uV3V4_V3NV2_V3V2N"): - fassert(type(args[0]), args[1:]) - -## vec4 -def test_vec4_types(): - for args in gen_args("#u-_N_NNNN_V4"): - for T in vector_length_dict[4]: - fassert(T, args) - - for args in gen_args("#uV4V2NN_V4NV2N_V4NNV2_V4NV3_V4V3N"): - fassert(type(args[0]), args[1:]) - -## mat -def test_mat_types(): - for C in range(2, 5): - for R in range(2, 5): - for args in gen_args("#u-_N_" + "N"*(C*R) + "_" + "N"*(int(math.sqrt(C*R))) + "_M{C}{R}__fFiI".format(C=C, R=R)): # need support for _M - for T in matrix_length_dict[(C,R)]: - fassert(T, args) - - for args in gen_args("#uM{C}{R}".format(C=C, R=R) + "V{R}".format(R=R)*C + "_" + "_".join(["M{C}{R}M{c}{r}".format(C=C, R=R, c=c, r=r) for c in range(2, 5) for r in range(2,5)]) + "__fFiI"): - fassert(type(args[0]), args[1:]) - - for args in gen_args("Q__f"): - fassert(glm.mat3, args) - fassert(glm.mat4, args) - - for args in gen_args("Q__F"): - fassert(glm.dmat3, args) - fassert(glm.dmat4, args) - -## quat -def test_quat_types(): - for args in gen_args("#u-_V3_M33_M44_NV3_V3V3_NNNN_Q__f"): # need support for conversion constructors - fassert(glm.quat, args) - -## dquat -def test_dquat_types(): - for args in gen_args("#u-_V3_M33_M44_NV3_V3V3_NNNN_Q__F"): # need support for conversion constructors - fassert(glm.dquat, args) - -## array -def test_array_types(): - for args in gen_args("V_M_Q_VV_MM_QQ_VVV_MMM_QQQ"): - fassert(glm.array, args) - - assert glm.array([glm.vec4() for x in range(10)]) - assert glm.array(tuple([glm.vec4() for x in range(10)])) - assert glm.array({x : glm.vec4() for x in range(10)}.values()) - assert glm.array(memoryview(glm.array([glm.vec4() for x in range(10)]))) - - assert glm.array([glm.quat() for x in range(10)]) - assert glm.array(tuple([glm.quat() for x in range(10)])) - assert glm.array({x : glm.quat() for x in range(10)}.values()) - assert glm.array(memoryview(glm.array([glm.quat() for x in range(10)]))) - - assert glm.array([glm.mat4() for x in range(10)]) - assert glm.array(tuple([glm.mat4() for x in range(10)])) - assert glm.array({x : glm.mat4() for x in range(10)}.values()) - assert glm.array(memoryview(glm.array([glm.mat4() for x in range(10)]))) - - assert glm.array([glm.float32(x) for x in range(10)]) - assert glm.array(tuple([glm.float32(x) for x in range(10)])) - assert glm.array({x : glm.float32(x) for x in range(10)}.values()) - assert glm.array(memoryview(glm.array([glm.float32(x) for x in range(10)]))) - - assert glm.array(glm.float32, *range(10)) - assert glm.array.from_numbers(glm.float32, *range(10)) - assert glm.array([glm.float32, 1, 2, 3]) == glm.array((glm.float32, 1, 2, 3)) - assert glm.array(OrderedDict([(glm.float32, 1), (1, 2), (2, 3), (3, 4)])) - assert glm.array(memoryview(glm.array.from_numbers(glm.float32, *range(10)))) - - assert glm.array.zeros(1000, glm.uint8) == glm.array.zeros(1000, glm.u8vec1) == glm.array(glm.int8, 0).repeat(1000) - assert glm.array.zeros(1000, glm.quat) - assert glm.array.zeros(1000, glm.vec4) - assert glm.array.zeros(1000, glm.mat4) - - arr = glm.array(glm.mat4(), glm.mat4(2)) - - mv = memoryview(arr) - - assert glm.array.as_reference(mv) == arr - assert glm.array.as_reference(mv).reference == mv - assert glm.array.as_reference(arr).address == arr.address - - assert len(arr) == 2, arr - assert arr.typecode == "f", arr - assert arr.dtype == "float32", arr - assert arr.ctype == glm.float32, arr - assert arr.dt_size == 4, arr - assert arr.itemsize == arr.dt_size * 4 * 4, arr - assert arr.ptr, arr - assert arr.nbytes == arr.itemsize * len(arr), arr - assert arr.element_type == glm.mat4, arr - assert arr.readonly == False - assert arr.reference is None - - arr = glm.array.from_numbers(glm.int32, 5, 4, 3, 2, 1) - - assert arr.filter(lambda x: True) == arr - assert arr.filter(lambda x: False) == arr.repeat(0) - assert arr.filter(lambda x: x <= 3) == glm.array.from_numbers(glm.int32, 3, 2, 1) - assert arr.map(lambda x: x) == arr - assert arr.map(lambda x: glm.vec3(x)) == glm.array(glm.vec3(5), glm.vec3(4), glm.vec3(3), glm.vec3(2), glm.vec3(1)) - assert arr.map(lambda x: (x, x) if x == 1 else None) == glm.array(glm.int32, 1, 1) - assert arr.map(glm.add, glm.array([glm.vec2(x) for x in range(5)])) == glm.array([glm.vec2(5) for x in range(5)]) - assert glm.array(glm.int32, 0, 1, 1, 0, 0).map(glm.if_else, arr, glm.array(glm.int32, 1, 2, 3, 4, 5)) == glm.array(glm.int32, 1, 4, 3, 4, 5) - assert glm.array(glm.int32, *(x * 4 for x in range(-5,5))).map(lambda *args: args if sum(args) == 0 else None, - glm.array(glm.int32, *(x * 3 for x in range(-5,5))), - glm.array(glm.int32, *(x * 2 for x in range(-5,5))), - glm.array(glm.int32, *(x * 1 for x in range(-5,5))), - glm.array(glm.int32, *(x * -9.4 for x in range(-5,5)))) == glm.array(glm.int32, 0, 0, 0, 0, 0) - assert arr.map(lambda x: None) == arr.repeat(0) - arr.sort(glm.cmp) - assert arr == glm.array.from_numbers(glm.int32, 1, 2, 3, 4, 5) - - arr = glm.array(glm.vec3(5), glm.vec3(4), glm.vec3(3), glm.vec3(2), glm.vec3(1)) - - assert arr.filter(lambda x: True) == arr - assert arr.filter(lambda x: False) == arr.repeat(0) - assert arr.filter(lambda x: x.x <= 3) == glm.array(glm.vec3(3), glm.vec3(2), glm.vec3(1)) - assert arr.map(lambda x: x) == arr - assert arr.map(lambda x: x.xxxx) == glm.array(glm.vec4(5), glm.vec4(4), glm.vec4(3), glm.vec4(2), glm.vec4(1)) - assert arr.map(lambda x: (x, x) if x.x == 1 else None) == glm.array(glm.vec3(1), glm.vec3(1)) - assert arr.map(lambda x: None) == arr.repeat(0) - assert arr.map(lambda x: (x.x), ctype = glm.int32) == glm.array.from_numbers(glm.int32, 5, 4, 3, 2, 1) - arr.sort(lambda x, y: glm.cmp(x.x, y.x)) - assert arr == glm.array(glm.vec3(1), glm.vec3(2), glm.vec3(3), glm.vec3(4), glm.vec3(5)) - - -# repr # -def test_repr_eval(): - glm_locals = {a : getattr(glm, a) for a in dir(glm)} - for T in vector_types + matrix_types + quat_types: - fassert(lambda o: eval(repr(o), glm_locals), (T(),)) - - arr = glm.array(glm.vec4(*[-1.23457e+06]*4), glm.vec4(*[-7.65432e+06]*4)) - arr2 = glm.array(glm.quat(*[-1.23457e+06]*4), glm.quat(*[-7.65432e+06]*4)) - arr3 = glm.array(glm.mat4(*[-1.23457e+06]*16), glm.mat4(*[-7.65432e+06]*16)) - assert repr(arr), arr - assert repr(arr2), arr2 - assert repr(arr3), arr3 - assert str(arr), arr - assert str(arr2), arr2 - assert str(arr3), arr3 - - arr = glm.array(glm.vec4(*[1]*4), glm.vec4(*[2]*4)) - arr2 = glm.array(glm.quat(*[1]*4), glm.quat(*[2]*4)) - arr3 = glm.array(glm.mat4(*[1]*16), glm.mat4(*[2]*16)) - arr4 = glm.array(glm.int8, *range(10)) - assert eval(repr(arr), glm_locals) == arr, (arr, repr(arr), eval(repr(arr), glm_locals)) - assert eval(repr(arr2), glm_locals) == arr2, (arr2, repr(arr2), eval(repr(arr2), glm_locals)) - assert eval(repr(arr3), glm_locals) == arr3, (arr3, repr(arr3), eval(repr(arr3), glm_locals)) - assert eval(repr(arr4), glm_locals) == arr4, (arr4, repr(arr4), eval(repr(arr4), glm_locals)) -#/repr # - -# neg # -def test_neg(): - for obj in gen_obj("#MV_M_Q__fFiqsuB"): - fassert(obj.__neg__, ()) - assert (-glm.array(obj))[0] == -obj, obj -#/neg # - -# pos # -def test_pos(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSU"): - fassert(obj.__pos__, ()) - assert (+glm.array(obj))[0] == +obj, obj -#/pos # - -# abs # -def test_abs(): - for obj in gen_obj("#MV__fFiqsuIQSU"): - fassert(obj.__abs__, ()) - assert (abs(glm.array(obj)))[0] == abs(obj), obj -#/abs # - -# invert # -def test_invert(): - for obj in gen_obj("#MV__iqsuIQSU"): - fassert(obj.__invert__, ()) - assert (abs(glm.array(obj)))[0] == abs(obj), obj -#/invert # - -# add # -def test_add(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSUB"): - fassert(obj.__add__, (obj,)) - assert (glm.array(obj) + glm.array(obj))[0] == obj + obj, obj - assert (glm.array(obj) + obj)[0] == obj + obj, obj - assert (obj + glm.array(obj))[0] == obj + obj, obj - - arr = glm.array(glm.mat4()) - fassert(arr.concat, (arr,)) - fassert((arr.concat(arr)).concat, (arr,)) -#/add # - -# sub # -def test_sub(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSU"): - fassert(obj.__sub__, (obj,)) - assert (glm.array(obj) - glm.array(obj))[0] == obj - obj, obj - assert (glm.array(obj) - obj)[0] == obj - obj, obj - assert (obj - glm.array(obj))[0] == obj - obj, obj -#/sub # - -# mul # -def test_mul(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSUB"): - fassert(obj.__mul__, (1,)) - assert (glm.array(obj) * glm.array(glm.array(obj).ctype, 1))[0] == obj * 1, obj - assert (glm.array(obj) * 1)[0] == obj * 1, obj - assert (obj * glm.array(glm.array(obj).ctype, 1))[0] == obj * 1, obj - - arr = glm.array(glm.mat4()) - fassert(arr.repeat, (3,)) - fassert((arr.repeat(4)).repeat, (2,)) -#/mul # - -# div # -def test_div(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSU"): - fassert(obj.__truediv__, (1,)) - - for obj in gen_obj("#MV_Q__fFiqsuIQSU"): - fassert(obj.__truediv__, (1,)) - assert (glm.array(obj) / glm.array(glm.array(obj).ctype, 1))[0] == obj / 1, obj - assert (glm.array(obj) / 1)[0] == obj / 1, obj - assert (obj / glm.array(glm.array(obj).ctype, 1))[0] == obj / 1, obj - - for obj in gen_obj("V__iqsuIQSU"): - try: - obj.__truediv__(type(obj)(0)) - fail(obj) - except ZeroDivisionError: - pass - for obj in gen_obj("P__iI"): - try: - obj.__truediv__(obj) - fail(obj) - except ZeroDivisionError: - pass - - for obj in gen_obj("#MV_M_Q__iqsuIQSU"): - try: - obj.__truediv__(0) - fail(obj) - except ZeroDivisionError: - pass -#/div # - -# floordiv # -def test_int_floordiv(): - for obj in gen_obj("#MV__iqsuIQSU"): - fassert(obj.__floordiv__, (1,)) - fassert(obj.__floordiv__, (obj * 0 + 1,)) - - for obj in gen_obj("V__iqsuIQSU"): - fassert(obj.__floordiv__, (type(obj)(1),)) - - for obj in gen_obj("V__iqsuIQSU"): - try: - obj.__floordiv__(type(obj)(0)) - fail(obj) - except ZeroDivisionError: - pass - for obj in gen_obj("P__iI"): - try: - obj.__floordiv__(obj) - fail(obj) - except ZeroDivisionError: - pass - - for obj in gen_obj("#MV__iqsuIQSU"): - try: - obj.__floordiv__(0) - fail(obj) - except ZeroDivisionError: - pass -#/floordiv # - -# mod # -def test_mod(): - for obj in gen_obj("#MV__fF"): - fassert(obj.__mod__, (1,)) - - for obj in gen_obj("#MV__fF"): - assert (glm.array(obj) % glm.array(glm.array(obj).ctype, 1))[0] == obj % 1, obj - assert (glm.array(obj) % 1)[0] == obj % 1, obj - assert (obj % glm.array(glm.array(obj).ctype, 1))[0] == obj % 1, obj -#/mod # - -# floordiv # -def test_floordiv(): - for obj in gen_obj("#MV__fF"): - fassert(obj.__floordiv__, (1,)) -#/floordiv # - -# divmod # -def test_divmod(): - for obj in gen_obj("#MV__fF"): - fassert(obj.__divmod__, (1,)) -#/divmod # - -# lshift # -def test_lshift(): - for obj in gen_obj("#MV__iqsuIQSU"): - fassert(obj.__lshift__, (1,)) - fassert(obj.__lshift__, (obj,)) -#/lshift # - -# rshift # -def test_rshift(): - for obj in gen_obj("#MV__iqsuIQSU"): - fassert(obj.__rshift__, (1,)) - fassert(obj.__rshift__, (obj,)) -#/rshift # - -# and # -def test_and(): - for obj in gen_obj("#MV__iqsuIQSUB"): - fassert(obj.__and__, (1,)) - fassert(obj.__and__, (obj,)) -#/and # - -# or # -def test_or(): - for obj in gen_obj("#MV__iqsuIQSUB"): - fassert(obj.__or__, (1,)) - fassert(obj.__or__, (obj,)) -#/or # - -# xor # -def test_xor(): - for obj in gen_obj("#MV__iqsuIQSUB"): - fassert(obj.__xor__, (1,)) - fassert(obj.__xor__, (obj,)) -#/xor # - -# pow # -def test_pow(): - for obj in gen_obj("#p#MV__fF"): - fassert(obj.__pow__, (obj,)) - fassert(obj.__pow__, (obj, obj)) - - assert (glm.array(obj) ** glm.array(obj))[0] == obj ** obj, obj - assert (glm.array(obj) ** obj)[0] == obj ** obj, obj - assert (obj ** glm.array(obj))[0] == obj ** obj, obj -#/pow # - -# matmul # -def test_matmul(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSU"): - try: - obj @ obj - except TypeError: - pass -#/matmul # - -# iadd # -def test_iadd(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSUB"): - fassert(obj.__iadd__, (obj,)) - - arr = glm.array(glm.mat4()) - fassert(arr.iconcat, (arr,)) - fassert(arr.iconcat, (arr,)) -#/iadd # - -# isub # -def test_isub(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSU"): - fassert(obj.__isub__, (obj,)) -#/isub # - -# imul # -def test_imul(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSUB"): - fassert(obj.__imul__, (1,)) - - arr = glm.array(glm.mat4()) - fassert(arr.irepeat, (3,)) - fassert(arr.irepeat, (3,)) -#/imul # - -# idiv # -def test_idiv(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSU"): - fassert(obj.__itruediv__, (1,)) -#/idiv # - -# imod # -def test_imod(): - for obj in gen_obj("#MV__fF"): - fassert(obj.__imod__, (1,)) -#/imod # - -# ifloordiv # -def test_ifloordiv(): - for obj in gen_obj("#MV__fFiqsuIQSU"): - fassert(obj.__ifloordiv__, (1,)) -#/ifloordiv # - -# ipow # -def test_ipow(): - for obj in gen_obj("#MV__fF"): - fassert(obj.__ipow__, (obj,)) -#/ipow # - -# imatmul # -def test_imatmul(): - for obj in gen_obj("#MV_M_Q__fFiqsuIQSU"): - try: - obj @= obj - except TypeError: - pass -#/imatmul # - -# str # -def test_str(): - for obj in gen_obj("#MV_M_Q"): - assert str(obj), obj -#/str # - -# repr # -def test_repr(): - for obj in gen_obj("#MV_M_Q"): - assert repr(obj), obj -#/repr # - -# len # -def test_len(): - for obj in gen_obj("#MV_M_Q"): - assert len(obj), obj - - arr = glm.array(glm.mat4()) - arr2 = arr.concat(arr) - assert len(arr) == 1, arr - assert len(arr2) == 2, arr2 -#/len # - -# getitem # -def test_getitem(): - for obj in gen_obj("#MV_M_Q"): - for i in range(len(obj)): - assert obj[i] != None, obj - - arr = glm.array(glm.mat4(), glm.mat4(2)) - assert arr[0] == glm.mat4(), arr - assert arr[1] == glm.mat4(2) == arr[-1], arr - - arr = glm.array(*glm.mat4()) - assert arr[:] == arr, arr - assert arr[1:] == glm.array(glm.vec4(0,1,0,0),glm.vec4(0,0,1,0),glm.vec4(0,0,0,1)), arr - assert arr[::2] == glm.array(glm.vec4(1,0,0,0),glm.vec4(0,0,1,0)), arr - assert arr[1::2] == glm.array(glm.vec4(0,1,0,0),glm.vec4(0,0,0,1)), arr -#/getitem # - -# setitem # -def test_setitem(): - for obj in gen_obj("#MV_M_Q"): - for i in range(len(obj)): - fassert(obj.__setitem__,(i, obj[i])) - - arr = glm.array(glm.mat4(), glm.mat4(2)) - arr[0] = glm.mat4(3) - assert arr[0] == glm.mat4(3), arr - del arr[0] - assert arr == glm.array(glm.mat4(2)), arr - - arr = glm.array(*glm.mat4()) - del arr[::2] - assert arr == glm.array(glm.vec4(0,1,0,0),glm.vec4(0,0,0,1)), arr - arr[:] = glm.array(glm.vec4(), glm.vec4(2)) - assert arr == glm.array(glm.vec4(), glm.vec4(2)), arr -#/setitem # - -# contains # -def test_contains(): - for obj in gen_obj("#MV_M_Q"): - assert obj[0] in obj, obj - - arr = glm.array(glm.mat4(), glm.mat4(2)) - assert glm.mat4(2) in arr and not glm.mat4(3) in arr, arr -#/contains # - -# Richcompare # -## EQ -def test_EQ(): - for obj in gen_obj("V_M_Q"): - assert obj == type(obj)(obj), obj - - arr = glm.array(glm.mat4(), glm.mat4(2)) - arr2 = glm.array(glm.mat4(), glm.mat4(2)) - arr3 = glm.array(glm.mat4(), glm.mat4(2), glm.mat4(0)) - assert arr == arr2 and not arr == arr3, (arr, arr2, arr3) - -## NE -def test_NE(): - for obj in gen_obj("#uV_M__fFiqsuIQSU"): - assert obj != (obj + 1), obj - - for obj in gen_obj("V_M__B"): - assert obj != (not obj), obj - - for obj in gen_obj("Q"): - assert obj != (1,0,0,0) - - arr = glm.array(glm.mat4(), glm.mat4(2)) - arr2 = glm.array(glm.mat4(), glm.mat4(2)) - arr3 = glm.array(glm.mat4(), glm.mat4(2), glm.mat4(0)) - assert not arr != arr2 and arr != arr3, (arr, arr2, arr3) - -## LT -def test_LT(): - for obj in gen_obj("#uV__fFiqsuIQSU"): - assert all(obj < (obj + 1)) and not any(obj < obj), obj - -## LE -def test_LE(): - for obj in gen_obj("#uV__fFiqsuIQSU"): - assert all(obj <= obj) and all(obj <= (obj + 1)) and not any((obj + 1) <= obj), obj - -## GT -def test_GT(): - for obj in gen_obj("#uV__fFiqsuIQSU"): - assert all((obj + 1) > obj) and not any(obj > obj), obj - -## GE -def test_GE(): - for obj in gen_obj("#uV__fFiqsuIQSU"): - assert all(obj >= obj) and all((obj + 1) >= obj) and not any(obj >= (obj + 1)), obj -#/Richcompare # - -# iter # -def test_iter(): - for obj in gen_obj("V_M_Q"): - fassert(iter, (obj,)) - - arr = glm.array(glm.mat4(), glm.mat4(2)) - assert list(arr) == arr.to_list(), arr -#/iter # - -# hash # -def test_hash(): - for obj in gen_obj("V_M_Q"): - fassert(hash, (obj,)) - - arr = glm.array(glm.mat4(), glm.mat4(2)) - assert hash(arr), arr -#/hash # - -# buffer protocol # -def check_buffer_protocol(type_, shape, format): - obj = type_() - memview = memoryview(obj) - assert shape == memview.shape - assert format == memview.format - -def test_buffer_protocol(): - for t, s, f in ( - (glm.vec1, (1,), "f"), - (glm.vec2, (2,), "f"), - (glm.vec3, (3,), "f"), - (glm.vec4, (4,), "f"), - - (glm.dvec1, (1,), "d"), - (glm.dvec2, (2,), "d"), - (glm.dvec3, (3,), "d"), - (glm.dvec4, (4,), "d"), - - (glm.ivec1, (1,), "i"), - (glm.ivec2, (2,), "i"), - (glm.ivec3, (3,), "i"), - (glm.ivec4, (4,), "i"), - - (glm.uvec1, (1,), "I"), - (glm.uvec2, (2,), "I"), - (glm.uvec3, (3,), "I"), - (glm.uvec4, (4,), "I"), - - (glm.i8vec1, (1,), "b"), - (glm.i8vec2, (2,), "b"), - (glm.i8vec3, (3,), "b"), - (glm.i8vec4, (4,), "b"), - - (glm.u8vec1, (1,), "B"), - (glm.u8vec2, (2,), "B"), - (glm.u8vec3, (3,), "B"), - (glm.u8vec4, (4,), "B"), - - (glm.i16vec1, (1,), "h"), - (glm.i16vec2, (2,), "h"), - (glm.i16vec3, (3,), "h"), - (glm.i16vec4, (4,), "h"), - - (glm.u16vec1, (1,), "H"), - (glm.u16vec2, (2,), "H"), - (glm.u16vec3, (3,), "H"), - (glm.u16vec4, (4,), "H"), - - (glm.i64vec1, (1,), "q"), - (glm.i64vec2, (2,), "q"), - (glm.i64vec3, (3,), "q"), - (glm.i64vec4, (4,), "q"), - - (glm.u64vec1, (1,), "Q"), - (glm.u64vec2, (2,), "Q"), - (glm.u64vec3, (3,), "Q"), - (glm.u64vec4, (4,), "Q"), - - (glm.bvec1, (1,), "?"), - (glm.bvec2, (2,), "?"), - (glm.bvec3, (3,), "?"), - (glm.bvec4, (4,), "?"), - - (glm.mat2x2, (2, 2), "f"), - (glm.mat2x3, (3, 2), "f"), - (glm.mat2x4, (4, 2), "f"), - (glm.mat3x2, (2, 3), "f"), - (glm.mat3x3, (3, 3), "f"), - (glm.mat3x4, (4, 3), "f"), - (glm.mat4x2, (2, 4), "f"), - (glm.mat4x3, (3, 4), "f"), - (glm.mat4x4, (4, 4), "f"), - - - (glm.dmat2x2, (2, 2), "d"), - (glm.dmat2x3, (3, 2), "d"), - (glm.dmat2x4, (4, 2), "d"), - (glm.dmat3x2, (2, 3), "d"), - (glm.dmat3x3, (3, 3), "d"), - (glm.dmat3x4, (4, 3), "d"), - (glm.dmat4x2, (2, 4), "d"), - (glm.dmat4x3, (3, 4), "d"), - (glm.dmat4x4, (4, 4), "d"), - - - (glm.imat2x2, (2, 2), "i"), - (glm.imat2x3, (3, 2), "i"), - (glm.imat2x4, (4, 2), "i"), - (glm.imat3x2, (2, 3), "i"), - (glm.imat3x3, (3, 3), "i"), - (glm.imat3x4, (4, 3), "i"), - (glm.imat4x2, (2, 4), "i"), - (glm.imat4x3, (3, 4), "i"), - (glm.imat4x4, (4, 4), "i"), - - - (glm.umat2x2, (2, 2), "I"), - (glm.umat2x3, (3, 2), "I"), - (glm.umat2x4, (4, 2), "I"), - (glm.umat3x2, (2, 3), "I"), - (glm.umat3x3, (3, 3), "I"), - (glm.umat3x4, (4, 3), "I"), - (glm.umat4x2, (2, 4), "I"), - (glm.umat4x3, (3, 4), "I"), - (glm.umat4x4, (4, 4), "I"), - - (glm.quat, (4,), "f"), - - (glm.dquat, (4,), "d"), - ): - check_buffer_protocol(t,s,f) - - arr = glm.array(glm.mat4(), glm.mat4(2)) - mv = memoryview(arr) - assert glm.array(mv) == arr, arr - - for T in (ctypes.c_float, - ctypes.c_double, - ctypes.c_char, - ctypes.c_byte, - ctypes.c_ubyte, - ctypes.c_short, - ctypes.c_ushort, - ctypes.c_int, - ctypes.c_uint, - ctypes.c_long, - ctypes.c_ulong, - ctypes.c_longlong, - ctypes.c_ulonglong, - ctypes.c_size_t, - ctypes.c_ssize_t, - ctypes.c_void_p): - assert glm.vec1((T*1)()) == glm.vec1() -#/buffer protocol # - -# lists and tuples # -def test_lists_and_tuples(): - for tp, arg in ( - (glm.vec1, (1,)), - (glm.vec2, (1, 2,)), - (glm.vec3, (1, 2, 3,)), - (glm.vec4, (1, 2, 3, 4)), - (glm.vec1, [1]), - (glm.vec2, [1, 2]), - (glm.vec3, [1, 2, 3]), - (glm.vec4, [1, 2, 3, 4]), - (glm.mat2x2, ((1, 2), (3, 4))), - (glm.mat2x3, ((1, 2, 3), (4, 5, 6))), - (glm.mat2x4, ((1, 2, 3, 4), (5, 6, 7, 8))), - (glm.mat3x2, ((1, 2), (3, 4), (5, 6))), - (glm.mat3x3, ((1, 2, 3), (4, 5, 6), (7, 8, 9))), - (glm.mat3x4, ((1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12))), - (glm.mat4x2, ((1, 2), (3, 4), (5, 6), (7, 8))), - (glm.mat4x3, ((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12))), - (glm.mat4x4, ((1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12), (13, 14, 15, 16))), - (glm.quat, (1, 2, 3, 4)), - ): - fassert(tp, [arg]); -#/lists and tuples # - -# copy module # -def test_copy(): - for args in gen_args("V_M_Q"): - fassert(copy.copy, args) - fassert(copy.deepcopy, args) - - arr = glm.array(glm.mat4(), glm.mat4(2)) - assert copy.copy(arr) == arr, arr - assert copy.deepcopy(arr) == arr, arr -#/copy module # - -# to_list # -def test_to_list(): - for args in gen_args("V_Q"): - for arg in args: - assert arg.to_list() == [x for x in arg] - - for args in gen_args("M"): - for arg in args: - assert arg.to_list() == [[y for y in x] for x in arg] - - arr = glm.array(glm.mat4(), glm.mat4(2)) - assert arr.to_list() == [glm.mat4(), glm.mat4(2)] -#/to_list # - -# to_tuple # -def test_to_tuple(): - for args in gen_args("V_Q"): - for arg in args: - assert arg.to_tuple() == tuple([x for x in arg]) - - for args in gen_args("M"): - for arg in args: - assert arg.to_tuple() == tuple([tuple([y for y in x]) for x in arg]) - - arr = glm.array(glm.mat4(), glm.mat4(2)) - assert arr.to_tuple() == (glm.mat4(), glm.mat4(2)) -#/to_tuple # - -# to/from_bytes # -def test_to_from_bytes(): - for obj in gen_obj("V_M_Q"): - assert type(obj).from_bytes(obj.to_bytes()) == obj, repr(obj) - for obj in gen_obj("#MV"): - assert obj.to_bytes() == bytes(obj), repr(obj) - - for args in gen_args("VVV_MMM_QQQ"): - arr = glm.array(args) - assert arr.from_bytes(arr.to_bytes(), arr.element_type) == arr -#/to/from_bytes # - -# reinterpret_cast # -def test_reinterpret_cast(): - arr = glm.array.zeros(8*3*3*4*4, glm.uint8) - - for type_ in (vector_types + matrix_types + quat_types + ctypes_types): - assert arr.reinterpret_cast(type_).element_type == type_ -#/reinterpret_cast # - -# pickling # -import os -if (eval(os.environ.get("TEST_PICKLING", "True"))): - from pickle import dumps, loads - - def test_pickling(): - for obj in gen_obj("V_Q"): - assert loads(dumps(obj)) == obj, obj - - for obj in gen_obj("M"): - assert loads(dumps(obj)) == obj, obj - assert loads(dumps(obj[0])) == obj[0], obj - - arr = glm.array(glm.mat4(), glm.mat4(2)) - assert loads(dumps(arr)) == arr -#/pickling # - -# other # -def test_other(): - test_values = [-1, 0, 2, 3] - assert all([(+a) == glm.pos(a) for a in test_values]) - assert all([(-a) == glm.neg(a) for a in test_values]) - assert all([(~a) == glm.inv(a) for a in test_values]) - - test_values = [(1, 2), (3, 4), (-1, 1), (0, 2)] - assert all([(a + b) == glm.add(a,b) for a, b in test_values]) - assert all([(a - b) == glm.sub(a,b) for a, b in test_values]) - assert all([(a * b) == glm.mul(a,b) for a, b in test_values]) - assert all([(a / b) == glm.div(a,b) for a, b in test_values]) - assert all([(a // b) == glm.floordiv(a,b) for a, b in test_values]) - assert all([(a % b) == glm.mod(a,b) for a, b in test_values]) - assert all([(a << b) == glm.lshift(a,b) for a, b in test_values]) - assert all([(a >> b) == glm.rshift(a,b) for a, b in test_values]) - assert all([(a & b) == glm.and_(a,b) for a, b in test_values]) - assert all([(a ^ b) == glm.xor(a,b) for a, b in test_values]) - assert all([(a | b) == glm.or_(a,b) for a, b in test_values]) - assert all([(-1 if a < b else 1 if a > b else 0) == glm.cmp(a,b) for a, b in test_values]) - - test_values = [(1, 2, 3), (3, 4, 5), (-1, 1, 0), (0, 2, 3)] - assert all([(x if b else y) == glm.if_else(b, x, y) for b, x, y in test_values]) -#/other # - -## DETAIL ## - -# func_packing # -def test_func_packing(): - fassert(glm.packDouble2x32, (glm.uvec2(randf()),)) - fassert(glm.packUnorm2x16, (glm.vec2(randfs()),)) - fassert(glm.packSnorm2x16, (glm.vec2(randfs()),)) - fassert(glm.packSnorm4x8, (glm.vec4(randfs()),)) - fassert(glm.packUnorm4x8, (glm.vec4(randfs()),)) - fassert(glm.packHalf2x16, (glm.vec2(randfs()),)) - fassert(glm.unpackDouble2x32, (randfs(),)) - fassert(glm.unpackUnorm2x16, (int(randf()),)) - fassert(glm.unpackSnorm2x16, (int(randf()),)) - fassert(glm.unpackUnorm4x8, (int(randf()),)) - fassert(glm.unpackSnorm4x8, (int(randf()),)) - fassert(glm.unpackHalf2x16, (int(randf()),)) -#/func_packing # - -# func_integer # -def test_func_integer(): - for args in gen_args("#uVVV__I"): - fassert(glm.uaddCarry, args) - - for args in gen_args("#uVVV__I"): - fassert(glm.usubBorrow, args) - - for args in gen_args("#uVVVV__I"): - fassert(glm.umulExtended, args) - - for args in gen_args("#uVVVV__i"): - fassert(glm.imulExtended, args) - - for args in gen_args("#uNNN_VNN__iqsuIQSU"): - fassert(glm.bitfieldExtract, args) - - for args in gen_args("#uNNNN_VVNN__iqIQ"): - fassert(glm.bitfieldInsert, args) - - for args in gen_args("#uV_N__iqIQ"): - fassert(glm.bitfieldReverse, args) - - for args in gen_args("#uV_N__iqsuIQSU"): - fassert(glm.bitCount, args) - fassert(glm.findLSB, args) - fassert(glm.findMSB, args) -#/func_integer # - -# func_vector_relational # -def test_func_vector_relational(): - for args in gen_args("#uVV_QQ_NNNi_VfVfNi_VFVFNi_MfMfNi_MFMFNi"): # need to add support for _MM - fassert(glm.equal, args) - fassert(glm.notEqual, args) - - for args in gen_args("#uVV_QQ"): - fassert(glm.lessThan, args) - fassert(glm.lessThanEqual, args) - fassert(glm.greaterThan, args) - fassert(glm.greaterThanEqual, args) - - for args in gen_args("#uV__B"): - fassert(glm.any, args) - fassert(glm.all, args) - fassert(glm.not_, args) -#/func_vector_relational # - -# func_exponential # -def test_func_exponential(): - for args in gen_args("VV_QN_NN__fF"): - fassert(glm.pow, args) - - for args in gen_args("N_V_Q__fF"): - fassert(glm.exp, args) - fassert(glm.log, args) - fassert(glm.sqrt, args) - - for args in gen_args("N_V__fF"): - fassert(glm.exp2, args) - fassert(glm.log2, args) - fassert(glm.inversesqrt, args) -#/func_exponential # - - -# func_common # -def test_func_common(): - for args in gen_args("N_V__fF"): - fassert(glm.abs, args) - fassert(glm.floor, args) - fassert(glm.trunc, args) - fassert(glm.round, args) - fassert(glm.roundEven, args) - fassert(glm.ceil, args) - fassert(glm.fract, args) - - for args in gen_args("N_V__fFiqsu"): - fassert(glm.sign, args) - - for args in gen_args("NN_VV_VN__fF"): - fassert(glm.mod, args) - - for args in gen_args("NN_VV_VN_NNN_VVV_NNNN_VVVV__fFiqsuIQSU"): - fassert(glm.min, args) - fassert(glm.max, args) - - for args in gen_args("NN_VV_NNN_VVV_NNNN_VVVV_NNNNNNNNNNNN_VVVVVVVVVVVV__fFiqsuIQSU"): - fassert(glm.min, (args,)) - fassert(glm.max, (args,)) - - for args in gen_args("NN_VV_VN_NNN_VVV_NNNN_VVVV__fF"): - fassert(glm.fmin, args) - fassert(glm.fmax, args) - - for args in gen_args("NNN_VVV_VNN__fF"): - fassert(glm.clamp, args) - - for args in list(gen_args("NNNB_NNN_QQN__fF")) + list(gen_args("VVN_VVVf_VVVF_VVVB")): # need to add support for _MMN_MMMf_MMMF - fassert(glm.mix, args) - - for args in gen_args("NN_NV_VV"): - fassert(glm.step, args) - - for args in gen_args("NNN_NNV_VVV__fF"): - fassert(glm.smoothstep, args) - - for args in gen_args("N_V_Q__fF"): - fassert(glm.isnan, args) - fassert(glm.isinf, args) - - fassert(glm.fma, ((randfs(), randfs(), randfs()))) - - for args in gen_args("N_VVi__fF"): - fassert(glm.frexp, args) - - for args in gen_args("VVi__fF"): - fassert(glm.ldexp, args) - - for args in gen_args("N_V__f"): - fassert(lambda x: glm.intBitsToFloat(glm.floatBitsToInt(x)), args) - fassert(lambda x: glm.uintBitsToFloat(glm.floatBitsToUint(x)), args) - - for args in gen_args("N_VV__fF"): - fassert(glm.modf, args) -#/func_common # - -# func_geometric # -def test_func_geometric(): - for args in gen_args("N_V_Q__fF"): - fassert(glm.length, args) - - for args in gen_args("NN_VV__fF"): - fassert(glm.distance, args) - - for args in gen_args("NN_VV_QQ__fF"): - fassert(glm.dot, args) - - for args in gen_args("V3V3_QQ__fF"): - fassert(glm.cross, args) - - for args in gen_args("V_Q__fF"): - fassert(glm.normalize, args) - - for args in gen_args("NNN_VVV__fF"): - fassert(glm.faceforward, args) - - for args in gen_args("NN_VV__fF"): - fassert(glm.reflect, args) - - for args in gen_args("NNN_VVN__fF"): - fassert(glm.refract, args) -#/func_geometric # - -# func_matrix # -def test_func_matrix(): - for args in gen_args("MM__fF"): - fassert(glm.matrixCompMult, args) - - for args in gen_args("V2V2_V2V3_V2V4_V3V2_V3V3_V3V4_V4V2_V4V3_V4V4__fF"): - fassert(glm.outerProduct, args) - - for args in gen_args("M__fF"): - fassert(glm.transpose, args) - - for args in gen_args("M22_M33_M44__fF"): - fassert(glm.determinant, args) - - for args in gen_args("M22_M33_M44_Q__fF"): - fassert(glm.inverse, args) -#/func_matrix # - -# func_trigonometric # -def test_func_trigonometric(): - for args in gen_args("N_V__fF"): - fassert(glm.radians, args) - fassert(glm.degrees, args) - fassert(glm.sin, args) - fassert(glm.cos, args) - fassert(glm.tan, args) - fassert(glm.asin, args) - fassert(glm.acos, args) - fassert(glm.sinh, args) - fassert(glm.cosh, args) - fassert(glm.tanh, args) - fassert(glm.asinh, args) - fassert(glm.acosh, args) - fassert(glm.atanh, args) - - for args in gen_args("NN_VV_N_V__fF"): - fassert(glm.atan, args) -#/func_trigonometric # -##/DETAIL ## - -## EXTENSIONS ## -# color_space # -def test_color_space(): - for args in gen_args("V_VN__fF"): - fassert(glm.convertLinearToSRGB, args) - fassert(glm.convertSRGBToLinear, args) -#/color_space # - -# constants # -def test_constants(): - fassert(glm.epsilon, (())) - fassert(glm.zero, (())) - fassert(glm.one, (())) - fassert(glm.pi, (())) - fassert(glm.two_pi, (())) - fassert(glm.root_pi, (())) - fassert(glm.half_pi, (())) - fassert(glm.three_over_two_pi, (())) - fassert(glm.quarter_pi, (())) - fassert(glm.one_over_pi, (())) - fassert(glm.one_over_two_pi, (())) - fassert(glm.two_over_pi, (())) - fassert(glm.four_over_pi, (())) - fassert(glm.two_over_root_pi, (())) - fassert(glm.one_over_root_two, (())) - fassert(glm.root_half_pi, (())) - fassert(glm.root_two_pi, (())) - fassert(glm.root_ln_four, (())) - fassert(glm.e, (())) - fassert(glm.euler, (())) - fassert(glm.root_two, (())) - fassert(glm.root_three, (())) - fassert(glm.root_five, (())) - fassert(glm.ln_two, (())) - fassert(glm.ln_ten, (())) - fassert(glm.ln_ln_two, (())) - fassert(glm.third, (())) - fassert(glm.two_thirds, (())) - fassert(glm.golden_ratio, (())) -#/constants # - -# epsilon # -def test_epsilon(): - for args in gen_args("NNN_VVN_QQN_VVV__fF"): - fassert(glm.epsilonEqual, args) - fassert(glm.epsilonNotEqual, args) -#/epsilon # - -# integer # -def test_integer(): - for args in gen_args("#uN_V__fF"): - fassert(glm.iround, args) - fassert(glm.uround, args) -#/integer # - -# matrix_inverse # -def test_matrix_inverse(): - for args in gen_args("M33_M44__fF"): - fassert(glm.affineInverse, args) - - for args in gen_args("M22_M33_M44__fF"): - fassert(glm.inverseTranspose, args) -#/matrix_inverse # - -# matrix_transform # -def test_matrix_transform(): - for type_ in matrix_types: - fassert(glm.identity, (type_,)) - - for args in gen_args("M44V3__fF"): - fassert(glm.translate, args) - fassert(glm.scale, args) - fassert(glm.scale_slow, args) - - for args in gen_args("M44NV3_QNV3__fF"): - fassert(glm.rotate, args) - - for args in gen_args("M44NV3__fF"): - fassert(glm.rotate_slow, args) - - for args in gen_args("NNNN_NNNNNN"): - fassert(glm.ortho, args) - - for args in gen_args("NNNNNN"): - fassert(glm.orthoLH_ZO, args) - fassert(glm.orthoLH_NO, args) - fassert(glm.orthoRH_ZO, args) - fassert(glm.orthoRH_NO, args) - fassert(glm.orthoZO, args) - fassert(glm.orthoNO, args) - fassert(glm.orthoLH, args) - fassert(glm.orthoRH, args) - fassert(glm.frustum, args) - fassert(glm.frustumLH_ZO, args) - fassert(glm.frustumLH_NO, args) - fassert(glm.frustumRH_ZO, args) - fassert(glm.frustumRH_NO, args) - fassert(glm.frustumZO, args) - fassert(glm.frustumNO, args) - fassert(glm.frustumLH, args) - fassert(glm.frustumRH, args) - - for args in gen_args("NNNN"): - fassert(glm.perspective, args) - fassert(glm.perspectiveLH_ZO, args) - fassert(glm.perspectiveLH_NO, args) - fassert(glm.perspectiveRH_ZO, args) - fassert(glm.perspectiveRH_NO, args) - fassert(glm.perspectiveZO, args) - fassert(glm.perspectiveNO, args) - fassert(glm.perspectiveLH, args) - fassert(glm.perspectiveRH, args) - - for args in gen_args("#uNNNNN"): - fassert(glm.perspectiveFov, args) - fassert(glm.perspectiveFovLH_ZO, args) - fassert(glm.perspectiveFovLH_NO, args) - fassert(glm.perspectiveFovRH_ZO, args) - fassert(glm.perspectiveFovRH_NO, args) - fassert(glm.perspectiveFovZO, args) - fassert(glm.perspectiveFovNO, args) - fassert(glm.perspectiveFovLH, args) - fassert(glm.perspectiveFovRH, args) - - for args in gen_args("NNN"): - fassert(glm.infinitePerspective, args) - fassert(glm.infinitePerspectiveRH, args) - fassert(glm.infinitePerspectiveLH, args) - - for args in gen_args("NNN_NNNN"): - fassert(glm.tweakedInfinitePerspective, args) - - for args in gen_args("V3M44M44V4__fF"): - fassert(glm.project, args) - fassert(glm.projectNO, args) - fassert(glm.projectZO, args) - fassert(glm.unProject, args) - fassert(glm.unProjectNO, args) - fassert(glm.unProjectZO, args) - - for args in gen_args("#pV2V2V4__fF"): - fassert(glm.pickMatrix, args) - - for args in gen_args("V3V3V3__fF"): - fassert(glm.lookAt, args) - fassert(glm.lookAtRH, args) - fassert(glm.lookAtLH, args) -#/matrix_transform # - -# quaternion # -def test_quaternion(): - for args in gen_args("V3V3__fF"): - fassert(glm.quatLookAt, args) - fassert(glm.quatLookAtLH, args) - fassert(glm.quatLookAtRH, args) - - for args in gen_args("#dQQN__fF"): - fassert(glm.lerp, args) - - for args in gen_args("QQN__fF"): - fassert(glm.slerp, args) - - for args in gen_args("Q"): - fassert(glm.conjugate, args) - fassert(glm.eulerAngles, args) - fassert(glm.roll, args) - fassert(glm.pitch, args) - fassert(glm.yaw, args) - fassert(glm.mat3_cast, args) - fassert(glm.mat4_cast, args) - fassert(glm.angle, args) - fassert(glm.axis, args) - - for args in gen_args("M33_M44__fF"): - fassert(glm.quat_cast, args) - - for args in gen_args("NV3__fF"): - fassert(glm.angleAxis, args) -#/quaternion # - -# matrix_access # -def test_matrix_access(): - for T_id in matrix_type_ids: - T = prefixes[T_id] - for C in range(2, 5): - for R in range(2, 5): - m = getattr(glm, "{T}mat{C}x{R}".format(T=T,C=C,R=R))() - row_i = random.randrange(R) - row_v = getattr(glm, "{T}vec{C}".format(T=T, C=C))() - column_i = random.randrange(C) - column_v = getattr(glm, "{T}vec{R}".format(T=T, R=R))() - fassert(glm.row, (m, row_i)) - fassert(glm.row, (m, row_i, row_v)) - fassert(glm.column, (m, column_i)) - fassert(glm.column, (m, column_i, column_v)) -#/matrix_access # - -# noise # -def test_noise(): - for args in gen_args("V2_V3_V4_V2V2_V3V3_V4V4__fF"): - fassert(glm.perlin, args) - - for args in gen_args("V2_V3_V4__fF"): - fassert(glm.simplex, args) -#/noise # - -# packing # -def test_packing(): - fassert(glm.packInt2x8, (glm.i8vec2(),)) - fassert(glm.unpackInt2x8, (0,)) - fassert(glm.packInt4x8, (glm.i8vec4(),)) - fassert(glm.unpackInt4x8, (0,)) - fassert(glm.packInt2x16, (glm.i16vec2(),)) - fassert(glm.unpackInt2x16, (0,)) - fassert(glm.packInt4x16, (glm.i16vec4(),)) - fassert(glm.unpackInt4x16, (0,)) - fassert(glm.packInt2x32, (glm.i32vec2(),)) - fassert(glm.unpackInt2x32, (0,)) - fassert(glm.packUint2x8, (glm.u8vec2(),)) - fassert(glm.unpackUint2x8, (0,)) - fassert(glm.packUint4x8, (glm.u8vec4(),)) - fassert(glm.unpackUint4x8, (0,)) - fassert(glm.packUint2x16, (glm.u16vec2(),)) - fassert(glm.unpackUint2x16, (0,)) - fassert(glm.packUint4x16, (glm.u16vec4(),)) - fassert(glm.unpackUint4x16, (0,)) - fassert(glm.packUint2x32, (glm.u32vec2(),)) - fassert(glm.unpackUint2x32, (0,)) - fassert(glm.packHalf1x16, (0.,)) - fassert(glm.unpackHalf1x16, (0,)) - fassert(glm.packHalf4x16, (glm.vec4(),)) - fassert(glm.unpackHalf4x16, (0,)) - fassert(glm.packUnorm1x8, (0.,)) - fassert(glm.unpackUnorm1x8, (0,)) - fassert(glm.packUnorm2x8, (glm.vec2(),)) - fassert(glm.unpackUnorm2x8, (0,)) - fassert(glm.packUnorm1x16, (0.,)) - fassert(glm.unpackUnorm1x16, (0,)) - fassert(glm.packUnorm4x16, (glm.vec4(),)) - fassert(glm.unpackUnorm4x16, (0,)) - fassert(glm.packUnorm3x10_1x2, (glm.vec4(),)) - fassert(glm.unpackUnorm3x10_1x2, (0,)) - fassert(glm.packUnorm2x4, (glm.vec2(),)) - fassert(glm.unpackUnorm2x4, (0,)) - fassert(glm.packUnorm4x4, (glm.vec4(),)) - fassert(glm.unpackUnorm4x4, (0,)) - fassert(glm.packUnorm1x5_1x6_1x5, (glm.vec3(),)) - fassert(glm.unpackUnorm1x5_1x6_1x5, (0,)) - fassert(glm.packUnorm3x5_1x1, (glm.vec4(),)) - fassert(glm.unpackUnorm3x5_1x1, (0,)) - fassert(glm.packUnorm2x3_1x2, (glm.vec3(),)) - fassert(glm.unpackUnorm2x3_1x2, (0,)) - fassert(glm.packSnorm1x8, (0.,)) - fassert(glm.unpackSnorm1x8, (0,)) - fassert(glm.packSnorm2x8, (glm.vec2(),)) - fassert(glm.unpackSnorm2x8, (0,)) - fassert(glm.packSnorm1x16, (0.,)) - fassert(glm.unpackSnorm1x16, (0,)) - fassert(glm.packSnorm4x16, (glm.vec4(),)) - fassert(glm.unpackSnorm4x16, (0,)) - fassert(glm.packSnorm3x10_1x2, (glm.vec4(),)) - fassert(glm.unpackSnorm3x10_1x2, (0,)) - fassert(glm.packI3x10_1x2, (glm.ivec4(),)) - fassert(glm.unpackI3x10_1x2, (0,)) - fassert(glm.packU3x10_1x2, (glm.uvec4(),)) - fassert(glm.unpackU3x10_1x2, (0,)) - fassert(glm.packF2x11_1x10, (glm.vec3(),)) - fassert(glm.unpackF2x11_1x10, (0,)) - fassert(glm.packF3x9_E1x5, (glm.vec3(),)) - fassert(glm.unpackF3x9_E1x5, (0,)) - - for args in gen_args("V3__fF"): - fassert(glm.packRGBM, args) - - for args in gen_args("V4__fF"): - fassert(glm.unpackRGBM, args) - - for args in gen_args("V__f"): - fassert(glm.packHalf, args) - - for args in gen_args("V__S"): - fassert(glm.unpackHalf, args) - - for args in gen_args("V__fF"): - for dt in (glm.int8, glm.int16, glm.int32, glm.int64, glm.uint8, glm.uint16, glm.uint32, glm.uint64): - fassert(glm.packSnorm, (dt, args[0])) - - for args in gen_args("V__iqsuIQSU"): - for dt in (glm.float32, glm.float64): - fassert(glm.unpackSnorm, (dt, args[0])) - - for args in gen_args("V__fF"): - for dt in (glm.uint8, glm.uint16, glm.uint32, glm.uint64): - fassert(glm.packUnorm, (dt, args[0])) - - for args in gen_args("V__IQSU"): - for dt in (glm.float32, glm.float64): - fassert(glm.unpackUnorm, (dt, args[0])) -#/packing # - -# random # -def test_random(): - for args in gen_args("#xNN_VV__fFiqsuIQSU"): - comp = args[0] > args[1] - if type(comp) != bool: comp = any(comp) - if len(args) == 2 and comp: - args = (args[1], args[0]) - fassert(glm.linearRand, args) - fassert(glm.gaussRand, args) - - for args in gen_args("#pN"): - fassert(glm.circularRand, args) - fassert(glm.sphericalRand, args) - fassert(glm.diskRand, args) - fassert(glm.ballRand, args) - - fassert(glm.setSeed, (0,)) -#/random # - -# round # -def test_round(): - for args in gen_args("N_V__iqsu"): - # need to add support for isPowerOfTwo - #fassert(glm.isPowerOfTwo, args) - fassert(glm.ceilPowerOfTwo, args) - fassert(glm.floorPowerOfTwo, args) - fassert(glm.roundPowerOfTwo, args) - - for args in gen_args("#pNN_VV__iqsu"): - # need to add support for isMultiple - fassert(glm.ceilMultiple, args) - fassert(glm.floorMultiple, args) - fassert(glm.roundMultiple, args) -#/round # - -# reciprocal # -def test_reciprocal(): - for args in gen_args("N_V__fF"): - fassert(glm.sec, args) - fassert(glm.csc, args) - fassert(glm.cot, args) - fassert(glm.asec, args) - fassert(glm.acsc, args) - fassert(glm.acot, args) - fassert(glm.sech, args) - fassert(glm.csch, args) - fassert(glm.coth, args) - fassert(glm.asech, args) - fassert(glm.acsch, args) - fassert(glm.acoth, args) -#/reciprocal # - -# type_ptr # -def test_type_ptr(): - for args in gen_args("V2_V3_V4_M_Q"): - fassert(glm.value_ptr, args) - - for args in list(gen_args("V_M_Q")) + [(x,) for x in (list(vector_types) + list(matrix_types) + list(quat_types))]: - fassert(glm.sizeof, args) - - for L in range(2, 5): - for T in prefixes: - vec = getattr(glm, "{T}vec{L}".format(T=T,L=L))() - ptr = glm.value_ptr(vec) - fassert(getattr(glm, "make_vec{L}".format(L=L)), (ptr,)) - - for C in range(2, 5): - for R in range(2, 5): - for T_id in matrix_type_ids: - T = prefixes[T_id] - mat = getattr(glm, "{T}mat{C}x{R}".format(T=T,C=C,R=R))() - ptr = glm.value_ptr(mat) - fassert(getattr(glm, "make_mat{C}x{R}".format(C=C,R=R)), (ptr,)) - - for T_id in quat_type_ids: - T = prefixes[T_id] - quat = getattr(glm, "{T}quat".format(T=T))() - ptr = glm.value_ptr(quat) - fassert(glm.make_quat, (ptr,)) -#/type_ptr # - -# ulp # -def test_ulp(): - for args in gen_args("#uN_V_NNi_VNi_VVi__fF"): - fassert(glm.next_float, args) - fassert(glm.prev_float, args) - - for args in gen_args("NN_VV__fF"): - fassert(glm.float_distance, args) -#/ulp # -##/EXTENSIONS ## - -## UNSTABLE EXTENSIONS ## -# polar_coordinates # -def test_polar_coordinated(): - for args in gen_args("V3__fF"): - fassert(glm.polar, args) - - for args in gen_args("V2__fF"): - fassert(glm.euclidean, args) -#/polar_coordinates # - -# norm # -def test_norm(): - for args in gen_args("VV__fF"): - fassert(glm.distance2, args) - - for args in gen_args("V_N__fF"): - fassert(glm.length2, args) - - for args in gen_args("V3V3_V3__fF"): - fassert(glm.l1Norm, args) - - for args in gen_args("V3V3_V3__fF"): - fassert(glm.l2Norm, args) - - for args in gen_args("V3V3_V3__fF"): - fassert(glm.lMaxNorm, args) - - for args in gen_args("#uV3V3Ni_V3Ni__fF"): - fassert(glm.lxNorm, args) -#/norm # - -# matrix_decompose # -def test_matrix_decompose(): - for args in gen_args("M44V3QV3V3V4__fF"): - fassert(glm.decompose, args) -#/matrix_decompose # - -# matrix_transform_2d # -def test_matrix_transform_2d(): - for args in gen_args("M33N__fF"): - fassert(glm.rotate, args) - fassert(glm.shearX, args) - fassert(glm.shearY, args) - for args in gen_args("M33V2__fF"): - fassert(glm.scale, args) - fassert(glm.translate, args) -#/matrix_transform_2d # - -# rotate_vector # -def test_rotate_vector(): - for args in gen_args("V3V3__fF"): - fassert(glm.orientation, args) - for args in gen_args("V2N_V3NV3_V4NV3__fF"): - fassert(glm.rotate, args) - for args in gen_args("V3N_V4N__fF"): - fassert(glm.rotateX, args) - fassert(glm.rotateY, args) - fassert(glm.rotateZ, args) - for args in gen_args("V3V3N__fF"): - fassert(glm.slerp, args) -#/rotate_vector # - -# compatibility # -def test_compatibility(): - for args in gen_args("NNN_V2V2N_V3V3N_V4V4N_V2V2V2_V3V3V3_V4V4V4__fF"): - fassert(glm.lerp, args) - for args in gen_args("N_V__fF"): - fassert(glm.isfinite, args) - for args in gen_args("N_V2_V3_V4__fF"): - fassert(glm.saturate, args) - for args in gen_args("NN_VV_N_V__fF"): - fassert(glm.atan2, args) -#/compatibility # -##/UNSTABLE EXTENSIONS ## - - - -### SPECIFIC TESTS ### - -def test_spec_init(): - ## vectors ## - # vec1 - for vecT in vector_length_dict[1]: - assert vecT() == vecT(0) and vecT(1) == vecT(1) and vecT(1).x and not vecT(0).x, vecT - assert vecT(vecT(5)) == vecT(5) and vecT(vecT(4).xx) == vecT(4) and vecT(vecT(3).xxx) == vecT(3) and vecT(vecT(2).xxxx) == vecT(2), vecT - - assert vecT((8,)) == vecT(8) - - for vecB in vector_length_dict[1]: - assert vecT(vecB(1)) == vecT(1), (vecT, vecB) - - assert vecT(x = 5) == vecT(5), vecT - - # vec2 - for vecT in vector_length_dict[2]: - assert vecT() == vecT(0) and vecT(1) == vecT(1) and vecT(1).x and not vecT(0).x and vecT(1).y and not vecT(0).y, vecT - assert vecT(vecT(5)) == vecT(5) and vecT(vecT(3).xxx) == vecT(3) and vecT(vecT(2).xxxx) == vecT(2), vecT - - assert vecT(1, 2) == vecT(vecT(1).x, vecT(2).y) - - assert vecT(1, 2).yx == vecT(2, 1) - - assert vecT((8, 7)) == vecT(8, 7) - - for vecB in vector_length_dict[2]: - assert vecT(vecB(1)) == vecT(1), (vecT, vecB) - - assert vecT(y = 8, x = 5) == vecT(5, 8), vecT - - # vec3 - for vecT in vector_length_dict[3]: - assert vecT() == vecT(0) and vecT(1) == vecT(1) and vecT(1).x and not vecT(0).x and vecT(1).y and not vecT(0).y and vecT(1).z and not vecT(0).z, vecT - assert vecT(vecT(5)) == vecT(5) and vecT(vecT(2).xxxx) == vecT(2), vecT - - assert vecT(1, 2, 3) == vecT(vecT(1).x, vecT(2).y, vecT(3).z) - assert vecT(1, vecT(1, 2, 3).yz) == vecT(1, 2, 3) and vecT(vecT(1, 2, 3).xy, 3) == vecT(1, 2, 3) - - assert vecT(1, 2, 3).zyx == vecT(3, 2, 1) - - assert vecT((8, 7, 6)) == vecT(8, 7, 6) - - for vecB in vector_length_dict[3]: - assert vecT(vecB(1)) == vecT(1), (vecT, vecB) - - assert vecT(z = 3, y = 8, x = 5) == vecT(5, 8, 3), vecT - - # vec4 - for vecT in vector_length_dict[4]: - assert vecT() == vecT(0) and vecT(1) == vecT(1) and vecT(1).x and not vecT(0).x and vecT(1).y and not vecT(0).y and vecT(1).z and not vecT(0).z and vecT(1).w and not vecT(0).w, vecT - assert vecT(vecT(5)) == vecT(5), vecT - - assert vecT(1, 2, 3, 4) == vecT(vecT(1).x, vecT(2).y, vecT(3).z, vecT(4).w) - assert vecT(1, 2, 3, 4) == vecT(1, vecT(1, 2, 3, 4).yzw) == vecT(vecT(1, 2, 3, 4).xyz, 4) == vecT(vecT(1, 2, 3, 4).xy, vecT(1, 2, 3, 4).zw) == vecT(1, vecT(1, 2, 3, 4).yz, 4) - - assert vecT(1, 2, 3, 4).wzyx == vecT(4, 3, 2, 1) - - assert vecT((8, 7, 6, 5)) == vecT(8, 7, 6, 5) - - for vecB in vector_length_dict[4]: - assert vecT(vecB(1)) == vecT(1), (vecT, vecB) - - assert vecT(w = 4, z = 3, y = 8, x = 5) == vecT(5, 8, 3, 4), vecT - ##/vectors ## - - ## matrices ## - # mat2x2 - for matT in matrix_length_dict[(2, 2)]: - assert matT() == matT(1) == matT(1, 0, 0, 1) - assert matT(0) == matT(0, 0, 0, 0) and matT(2) == matT(2, 0, 0, 2) - - assert matT(1, 2, 3, 4) == matT(matT(1, 2, 3, 4)[0], matT(1, 2, 3, 4)[1]) - - assert matT(matT(1, 2, 3, 4)) == matT(1, 2, 3, 4) - - for matB in matrix_length_dict[(2, 2)]: - assert matT(matB()) == matT(), (matT, matB) - - # mat2x3 - for matT in matrix_length_dict[(2, 3)]: - assert matT() == matT(1) == matT(1, 0, 0, 0, 1, 0) - assert matT(0) == matT(0, 0, 0, 0, 0, 0) and matT(2) == matT(2, 0, 0, 0, 2, 0) - - assert matT(1, 2, 3, 4, 5, 6) == matT(matT(1, 2, 3, 4, 5, 6)[0], matT(1, 2, 3, 4, 5, 6)[1]) - - assert matT(matT(1, 2, 3, 4, 5, 6)) == matT(1, 2, 3, 4, 5, 6) - - for matB in matrix_length_dict[(2, 3)]: - assert matT(matB()) == matT(), (matT, matB) - - # mat2x4 - for matT in matrix_length_dict[(2, 4)]: - assert matT() == matT(1) == matT(1, 0, 0, 0, 0, 1, 0, 0) - assert matT(0) == matT(0, 0, 0, 0, 0, 0, 0, 0) and matT(2) == matT(2, 0, 0, 0, 0, 2, 0, 0) - - assert matT(1, 2, 3, 4, 5, 6, 7, 8) == matT(matT(1, 2, 3, 4, 5, 6, 7, 8)[0], matT(1, 2, 3, 4, 5, 6, 7, 8)[1]) - - assert matT(matT(1, 2, 3, 4, 5, 6, 7, 8)) == matT(1, 2, 3, 4, 5, 6, 7, 8) - - for matB in matrix_length_dict[(2, 4)]: - assert matT(matB()) == matT(), (matT, matB) - - # mat3x2 - for matT in matrix_length_dict[(3, 2)]: - assert matT() == matT(1) == matT(1, 0, 0, 1, 0, 0) - assert matT(0) == matT(0, 0, 0, 0, 0, 0) and matT(2) == matT(2, 0, 0, 2, 0, 0) - - assert matT(1, 2, 3, 4, 5, 6) == matT(matT(1, 2, 3, 4, 5, 6)[0], matT(1, 2, 3, 4, 5, 6)[1], matT(1, 2, 3, 4, 5, 6)[2]) - - assert matT(matT(1, 2, 3, 4, 5, 6)) == matT(1, 2, 3, 4, 5, 6) - - for matB in matrix_length_dict[(3, 2)]: - assert matT(matB()) == matT(), (matT, matB) - - # mat3x3 - for matT in matrix_length_dict[(3, 3)]: - assert matT() == matT(1) == matT(1, 0, 0, 0, 1, 0, 0, 0, 1) - assert matT(0) == matT(0, 0, 0, 0, 0, 0, 0, 0, 0) and matT(2) == matT(2, 0, 0, 0, 2, 0, 0, 0, 2) - - assert matT(1, 2, 3, 4, 5, 6, 7, 8, 9) == matT(matT(1, 2, 3, 4, 5, 6, 7, 8, 9)[0], matT(1, 2, 3, 4, 5, 6, 7, 8, 9)[1], matT(1, 2, 3, 4, 5, 6, 7, 8, 9)[2]) - - assert matT(matT(1, 2, 3, 4, 5, 6, 7, 8, 9)) == matT(1, 2, 3, 4, 5, 6, 7, 8, 9) - - for matB in matrix_length_dict[(3, 3)]: - assert matT(matB()) == matT(), (matT, matB) - - # mat3x4 - for matT in matrix_length_dict[(3, 4)]: - assert matT() == matT(1) == matT(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0) - assert matT(0) == matT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) and matT(2) == matT(2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0) - - assert matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) == matT(matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)[0], matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)[1], matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)[2]) - - assert matT(matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)) == matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) - - for matB in matrix_length_dict[(3, 4)]: - assert matT(matB()) == matT(), (matT, matB) - - # mat4x2 - for matT in matrix_length_dict[(4, 2)]: - assert matT() == matT(1) == matT(1, 0, 0, 1, 0, 0, 0, 0) - assert matT(0) == matT(0, 0, 0, 0, 0, 0, 0, 0) and matT(2) == matT(2, 0, 0, 2, 0, 0, 0, 0) - - assert matT(1, 2, 3, 4, 5, 6, 7, 8) == matT(matT(1, 2, 3, 4, 5, 6, 7, 8)[0], matT(1, 2, 3, 4, 5, 6, 7, 8)[1], matT(1, 2, 3, 4, 5, 6, 7, 8)[2], matT(1, 2, 3, 4, 5, 6, 7, 8)[3]) - - assert matT(matT(1, 2, 3, 4, 5, 6, 7, 8)) == matT(1, 2, 3, 4, 5, 6, 7, 8) - - for matB in matrix_length_dict[(4, 2)]: - assert matT(matB()) == matT(), (matT, matB) - - # mat4x3 - for matT in matrix_length_dict[(4, 3)]: - assert matT() == matT(1) == matT(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0) - assert matT(0) == matT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) and matT(2) == matT(2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0) - - assert matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) == matT(matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)[0], matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)[1], matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)[2], matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)[3]) - - assert matT(matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)) == matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) - - for matB in matrix_length_dict[(4, 3)]: - assert matT(matB()) == matT(), (matT, matB) - - # mat4x4 - for matT in matrix_length_dict[(4, 4)]: - assert matT() == matT(1) == matT(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1) - assert matT(0) == matT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) and matT(2) == matT(2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2) - - assert matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) == matT(matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)[0], matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)[1], matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)[2], matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)[3]) - - assert matT(matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)) == matT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) - - for matB in matrix_length_dict[(4, 4)]: - assert matT(matB()) == matT(), (matT, matB) - ##/matrices ## - - ## quats ## - for quaT in quat_types: - assert quaT() == quaT(1, 0, 0, 0) - - assert quaT(1, 2, 3, 4).w == 1 and quaT(1, 2, 3, 4).x == 2 and quaT(1, 2, 3, 4).y == 3 and quaT(1, 2, 3, 4).z == 4 - - assert quaT(1, 2, 3, 4) == quaT(quaT(1, 2, 3, 4)) - - for quaB in quat_types: - assert quaT(quaB(1, 2, 3, 4)) == quaT(1, 2, 3, 4) - - assert quaT(1, 2, 3, 4) == quaT(1, (2, 3, 4)) - - assert all(glm.epsilonEqual(glm.vec3(1, 0, 0), glm.vec3(0, 1, 0) * glm.quat(glm.vec3(1, 0, 0), glm.vec3(0, 1, 0)), 0.00001)) - assert all(glm.epsilonEqual(glm.dvec3(1, 0, 0), glm.dvec3(0, 1, 0) * glm.dquat(glm.dvec3(1, 0, 0), glm.dvec3(0, 1, 0)), 0.00001)) - - eulerAngles = glm.radians(glm.vec3(10, 20, 30)) - - q = glm.quat(eulerAngles) - - assert glm.epsilonEqual(glm.pitch(q), glm.radians(10), 0.00001) - assert glm.epsilonEqual(glm.yaw(q), glm.radians(20), 0.00001) - assert glm.epsilonEqual(glm.roll(q), glm.radians(30), 0.00001) - - eulerAngles = glm.radians(glm.dvec3(10, 20, 30)) - - q = glm.dquat(eulerAngles) - - assert glm.epsilonEqual(glm.pitch(q), glm.radians(10), 0.00001) - assert glm.epsilonEqual(glm.yaw(q), glm.radians(20), 0.00001) - assert glm.epsilonEqual(glm.roll(q), glm.radians(30), 0.00001) - ##/quats ## - - ## arrays ## - for obj in gen_obj("#MV_M_Q"): - assert glm.array(obj).repeat(2) == glm.array(obj, obj) == glm.array(glm.array(obj, obj)) == glm.array.as_reference(glm.array(obj, obj)) and glm.array(obj).repeat(4) == glm.array(obj, obj, obj, obj) == glm.array([obj, obj, obj, obj]) == glm.array(obj, obj).repeat(3)[:4] - - assert glm.array.zeros(5, type(obj)) - - for T in matrix_types + vector_types: - assert glm.array.zeros(5, T) == glm.array([T(0)] * 5) - - for obj in gen_obj("V_M_Q"): - assert glm.array(obj).element_type == type(obj) - - for cT in ctypes_types: - assert glm.array(cT(2), cT(3)) == glm.array(cT, 2, 3) == glm.array.from_numbers(cT, 2, 3) - - assert glm.array(cT).ctype == cT - ##/arrays ## - -def test_spec_add(): - for vecT in vector_length_dict[1]: - if (vecT == glm.bvec1): - continue - - assert vecT(1) + vecT(1) == vecT(1 + 1) == (glm.array(vecT(1)) + glm.array(vecT(1)))[0] == (glm.array(vecT(1)) + vecT(1))[0] == (vecT(1) + glm.array(vecT(1)))[0] - assert vecT(2) + vecT(3) == vecT(3) + vecT(2) == (glm.array(vecT(2)) + glm.array(vecT(3)))[0] == (glm.array(vecT(3)) + glm.array(vecT(2)))[0] - assert vecT(1) + 2 == vecT(1 + 2) == 2 + vecT(1) == (glm.array(vecT(1)) + 2)[0] == (2 + glm.array(vecT(1)))[0] - assert vecT(0) + vecT(0) == vecT(0) == (glm.array(vecT(0)) + glm.array(vecT(0)))[0] - - for vecT in vector_length_dict[2]: - if (vecT == glm.bvec2): - continue - - assert vecT(1, 2) + vecT(1, 2) == vecT(1 + 1, 2 + 2) == (glm.array(vecT(1, 2)) + glm.array(vecT(1, 2)))[0] - assert vecT(2) + vecT(3) == vecT(3) + vecT(2) == (glm.array(vecT(2)) + glm.array(vecT(3)))[0] == (glm.array(vecT(3)) + glm.array(vecT(2)))[0] - assert vecT(1) + 2 == vecT(1 + 2) == (glm.array(vecT(1)) + 2)[0] == (2 + glm.array(vecT(1)))[0] - assert vecT(0) + vecT(0) == vecT(0) == (glm.array(vecT(0)) + glm.array(vecT(0)))[0] - - for vecT in vector_length_dict[3]: - if (vecT == glm.bvec3): - continue - - assert vecT(1, 2, 3) + vecT(1, 2, 3) == vecT(1 + 1, 2 + 2, 3 + 3) == (glm.array(vecT(1, 2, 3)) + glm.array(vecT(1, 2, 3)))[0] - assert vecT(2) + vecT(3) == vecT(3) + vecT(2) == (glm.array(vecT(2)) + glm.array(vecT(3)))[0] == (glm.array(vecT(3)) + glm.array(vecT(2)))[0] - assert vecT(1) + 2 == vecT(1 + 2) == (glm.array(vecT(1)) + 2)[0] == (2 + glm.array(vecT(1)))[0] - assert vecT(0) + vecT(0) == vecT(0) == (glm.array(vecT(0)) + glm.array(vecT(0)))[0] - - for vecT in vector_length_dict[4]: - if (vecT == glm.bvec4): - continue - - assert vecT(1, 2, 3, 4) + vecT(1, 2, 3, 4) == vecT(1 + 1, 2 + 2, 3 + 3, 4 + 4) == (glm.array(vecT(1, 2, 3, 4)) + glm.array(vecT(1, 2, 3, 4)))[0] - assert vecT(2) + vecT(3) == vecT(3) + vecT(2) == (glm.array(vecT(2)) + glm.array(vecT(3)))[0] == (glm.array(vecT(3)) + glm.array(vecT(2)))[0] - assert vecT(1) + 2 == vecT(1 + 2) == (glm.array(vecT(1)) + 2)[0] == (2 + glm.array(vecT(1)))[0] - assert vecT(0) + vecT(0) == vecT(0) == (glm.array(vecT(0)) + glm.array(vecT(0)))[0] - - for c in range(2, 5): - for r in range(2, 5): - for matT in matrix_length_dict[(c, r)]: - assert matT(*range(c*r)) + matT(*range(c*r)) == matT(*map(lambda x: x + x, range(c*r))) == (glm.array(matT(*range(c*r))) + glm.array(matT(*range(c*r))))[0] - assert matT(2) + matT(3) == matT(3) + matT(2) == (glm.array(matT(2)) + glm.array(matT(3)))[0] == (glm.array(matT(3)) + glm.array(matT(2)))[0] - assert matT(1) + 2 == matT(*[(1 + 2) if C==R else 2 for C in range(c) for R in range(r)]) == (glm.array(matT(1)) + 2)[0] == (2 + glm.array(matT(1)))[0] - assert matT(0) + matT(0) == matT(0) == (glm.array(matT(0)) + glm.array(matT(0)))[0] - - for quaT in quat_types: - assert quaT(1, 2, 3, 4) + quaT(1, 2, 3, 4) == quaT(1 + 1, 2 + 2, 3 + 3, 4 + 4) == (glm.array(quaT(1, 2, 3, 4)) + glm.array(quaT(1, 2, 3, 4)))[0] - assert quaT() + quaT() == quaT(1 + 1, 0, 0, 0) == (glm.array(quaT()) + glm.array(quaT()))[0] - - for cT in ctypes_types: - assert glm.array(cT, 1, 2, 3) + glm.array(cT, 1, 2, 3) == glm.array(cT, 1 + 1, 2 + 2, 3 + 3) - assert glm.array(cT, 1, 2, 3) + 2 == glm.array(cT, 1 + 2, 2 + 2, 3 + 2) == 2 + glm.array(cT, 1, 2, 3) - -def test_spec_sub(): - for vecT in vector_length_dict[1]: - if (vecT == glm.bvec1): - continue - - assert vecT(1) - vecT(1) == vecT(1 - 1) == (glm.array(vecT(1)) - glm.array(vecT(1)))[0] == (glm.array(vecT(1)) - vecT(1))[0] == (vecT(1) - glm.array(vecT(1)))[0] - assert vecT(2) - vecT(3) != vecT(3) - vecT(2) and (glm.array(vecT(2)) - glm.array(vecT(3)))[0] != (glm.array(vecT(3)) - glm.array(vecT(2)))[0] - assert vecT(1) - 2 == vecT(1 - 2) == 1 - vecT(2) == (glm.array(vecT(1)) - 2)[0] == (1 - glm.array(vecT(2)))[0] - assert vecT(0) - vecT(0) == vecT(0) == (glm.array(vecT(0)) - glm.array(vecT(0)))[0] - - for vecT in vector_length_dict[2]: - if (vecT == glm.bvec2): - continue - - assert vecT(1, 2) - vecT(1, 2) == vecT(1 - 1, 2 - 2) == (glm.array(vecT(1, 2)) - glm.array(vecT(1, 2)))[0] - assert vecT(2) - vecT(3) != vecT(3) - vecT(2) and (glm.array(vecT(2)) - glm.array(vecT(3)))[0] != (glm.array(vecT(3)) - glm.array(vecT(2)))[0] - assert vecT(1) - 2 == vecT(1 - 2) == (glm.array(vecT(1)) - 2)[0] == (1 - glm.array(vecT(2)))[0] - assert vecT(0) - vecT(0) == vecT(0) == (glm.array(vecT(0)) - glm.array(vecT(0)))[0] - - for vecT in vector_length_dict[3]: - if (vecT == glm.bvec3): - continue - - assert vecT(1, 2, 3) - vecT(1, 2, 3) == vecT(1 - 1, 2 - 2, 3 - 3) == (glm.array(vecT(1, 2, 3)) - glm.array(vecT(1, 2, 3)))[0] - assert vecT(2) - vecT(3) != vecT(3) - vecT(2) and (glm.array(vecT(2)) - glm.array(vecT(3)))[0] != (glm.array(vecT(3)) - glm.array(vecT(2)))[0] - assert vecT(1) - 2 == vecT(1 - 2) == (glm.array(vecT(1)) - 2)[0] == (1 - glm.array(vecT(2)))[0] - assert vecT(0) - vecT(0) == vecT(0) == (glm.array(vecT(0)) - glm.array(vecT(0)))[0] - - for vecT in vector_length_dict[4]: - if (vecT == glm.bvec4): - continue - - assert vecT(1, 2, 3, 4) - vecT(1, 2, 3, 4) == vecT(1 - 1, 2 - 2, 3 - 3, 4 - 4) == (glm.array(vecT(1, 2, 3, 4)) - glm.array(vecT(1, 2, 3, 4)))[0] - assert vecT(2) - vecT(3) != vecT(3) - vecT(2) and (glm.array(vecT(2)) - glm.array(vecT(3)))[0] != (glm.array(vecT(3)) - glm.array(vecT(2)))[0] - assert vecT(1) - 2 == vecT(1 - 2) == (glm.array(vecT(1)) - 2)[0] == (1 - glm.array(vecT(2)))[0] - assert vecT(0) - vecT(0) == vecT(0) == (glm.array(vecT(0)) - glm.array(vecT(0)))[0] - - for c in range(2, 5): - for r in range(2, 5): - for matT in matrix_length_dict[(c, r)]: - assert matT(*range(c*r)) - matT(*range(c*r)) == matT(*map(lambda x: x - x, range(c*r))) == (glm.array(matT(*range(c*r))) - glm.array(matT(*range(c*r))))[0] - assert matT(2) - matT(3) != matT(3) - matT(2) and (glm.array(matT(2)) - glm.array(matT(3)))[0] != (glm.array(matT(3)) - glm.array(matT(2)))[0] - assert matT(1) - 2 == matT(*[(1 - 2) if C==R else -2 for C in range(c) for R in range(r)]) == (glm.array(matT(1)) - 2)[0] - if (c==r): - assert 2 - matT(1) == (2 - glm.array(matT(1)))[0] - assert matT(0) - matT(0) == matT(0) == (glm.array(matT(0)) - glm.array(matT(0)))[0] - - for quaT in quat_types: - assert quaT(1, 2, 3, 4) - quaT(1, 2, 3, 4) == quaT(1 - 1, 2 - 2, 3 - 3, 4 - 4) == (glm.array(quaT(1, 2, 3, 4)) - glm.array(quaT(1, 2, 3, 4)))[0] - assert quaT() - quaT() == quaT(1 - 1, 0, 0, 0) == (glm.array(quaT()) - glm.array(quaT()))[0] - - for cT in ctypes_types: - if (cT == glm.c_bool): - continue - assert glm.array(cT, 1, 2, 3) - glm.array(cT, 1, 2, 3) == glm.array(cT, 1 - 1, 2 - 2, 3 - 3) - assert glm.array(cT, 1, 2, 3) - 2 == glm.array(cT, 1 - 2, 2 - 2, 3 - 2) - assert 2 - glm.array(cT, 1, 2, 3) == glm.array(cT, 2 - 1, 2 - 2, 2 - 3) - -def test_spec_mul(): - for vecT in vector_length_dict[1]: - if (vecT == glm.bvec1): - continue - - assert vecT(1) * vecT(1) == vecT(1 * 1) == (glm.array(vecT(1)) * glm.array(vecT(1)))[0] == (glm.array(vecT(1)) * vecT(1))[0] == (vecT(1) * glm.array(vecT(1)))[0] - assert vecT(2) * vecT(3) == vecT(3) * vecT(2) == (glm.array(vecT(2)) * glm.array(vecT(3)))[0] == (glm.array(vecT(3)) * glm.array(vecT(2)))[0] - assert vecT(1) * 2 == vecT(1 * 2) == 2 * vecT(1) == (glm.array(vecT(1)) * 2)[0] == (2 * glm.array(vecT(1)))[0] - assert vecT(0) * vecT(0) == vecT(0) == (glm.array(vecT(0)) * glm.array(vecT(0)))[0] - - for vecT in vector_length_dict[2]: - if (vecT == glm.bvec2): - continue - - assert vecT(1, 2) * vecT(1, 2) == vecT(1 * 1, 2 * 2) == (glm.array(vecT(1, 2)) * glm.array(vecT(1, 2)))[0] - assert vecT(2) * vecT(3) == vecT(3) * vecT(2) == (glm.array(vecT(2)) * glm.array(vecT(3)))[0] == (glm.array(vecT(3)) * glm.array(vecT(2)))[0] - assert vecT(1) * 2 == vecT(1 * 2) == (glm.array(vecT(1)) * 2)[0] == (2 * glm.array(vecT(1)))[0] - assert vecT(0) * vecT(0) == vecT(0) == (glm.array(vecT(0)) * glm.array(vecT(0)))[0] - - for vecT in vector_length_dict[3]: - if (vecT == glm.bvec3): - continue - - assert vecT(1, 2, 3) * vecT(1, 2, 3) == vecT(1 * 1, 2 * 2, 3 * 3) == (glm.array(vecT(1, 2, 3)) * glm.array(vecT(1, 2, 3)))[0] - assert vecT(2) * vecT(3) == vecT(3) * vecT(2) == (glm.array(vecT(2)) * glm.array(vecT(3)))[0] == (glm.array(vecT(3)) * glm.array(vecT(2)))[0] - assert vecT(1) * 2 == vecT(1 * 2) == (glm.array(vecT(1)) * 2)[0] == (2 * glm.array(vecT(1)))[0] - assert vecT(0) * vecT(0) == vecT(0) == (glm.array(vecT(0)) * glm.array(vecT(0)))[0] - - for vecT in vector_length_dict[4]: - if (vecT == glm.bvec4): - continue - - assert vecT(1, 2, 3, 4) * vecT(1, 2, 3, 4) == vecT(1 * 1, 2 * 2, 3 * 3, 4 * 4) == (glm.array(vecT(1, 2, 3, 4)) * glm.array(vecT(1, 2, 3, 4)))[0] - assert vecT(2) * vecT(3) == vecT(3) * vecT(2) == (glm.array(vecT(2)) * glm.array(vecT(3)))[0] == (glm.array(vecT(3)) * glm.array(vecT(2)))[0] - assert vecT(1) * 2 == vecT(1 * 2) == (glm.array(vecT(1)) * 2)[0] == (2 * glm.array(vecT(1)))[0] - assert vecT(0) * vecT(0) == vecT(0) == (glm.array(vecT(0)) * glm.array(vecT(0)))[0] - - for c in range(2, 5): - for r in range(2, 5): - for matT in matrix_length_dict[(c, r)]: - assert matT(*range(c*r)) * glm.transpose(matT(*range(c*r))) == (glm.array(matT(*range(c*r))) * glm.array(glm.transpose(matT(*range(c*r)))))[0] - assert matT(*range(c*r)) * glm.transpose(matT(*range(c*r))) != glm.transpose(matT(*range(c*r))) * matT(*range(c*r)) and (glm.array(matT(*range(c*r))) * glm.array(glm.transpose(matT(*range(c*r)))))[0] != (glm.array(glm.transpose(matT(*range(c*r)))) * glm.array(matT(*range(c*r))))[0] - assert matT(1) * 2 == matT(*[(1 * 2) if C==R else 0 for C in range(c) for R in range(r)]) == (glm.array(matT(1)) * 2)[0] == (2 * glm.array(matT(1)))[0] - - for quaT in quat_types: - assert quaT(1, 2, 3, 4) * quaT(1, 2, 3, 4) == (glm.array(quaT(1, 2, 3, 4)) * glm.array(quaT(1, 2, 3, 4)))[0] - assert quaT() * quaT() == quaT(1 * 1, 0, 0, 0) == (glm.array(quaT()) * glm.array(quaT()))[0] - - for cT in ctypes_types: - assert glm.array(cT, 1, 2, 3) * glm.array(cT, 1, 2, 3) == glm.array(cT, 1 * 1, 2 * 2, 3 * 3) - assert glm.array(cT, 1, 2, 3) * 2 == glm.array(cT, 1 * 2, 2 * 2, 3 * 2) == 2 * glm.array(cT, 1, 2, 3) - -def test_spec_div(): - for vecT in vector_length_dict[1]: - if (vecT == glm.bvec1): - continue - - assert vecT(1) / vecT(1) == vecT(1 / 1) == (glm.array(vecT(1)) / glm.array(vecT(1)))[0] == (glm.array(vecT(1)) / vecT(1))[0] == (vecT(1) / glm.array(vecT(1)))[0] - assert vecT(2) / vecT(3) != vecT(3) / vecT(2) and (glm.array(vecT(2)) / glm.array(vecT(3)))[0] != (glm.array(vecT(3)) / glm.array(vecT(2)))[0] - assert vecT(1) / 2 == vecT(1 / 2) == 1 / vecT(2) == (glm.array(vecT(1)) / 2)[0] == (1 / glm.array(vecT(2)))[0] - assert vecT(0) / vecT(1) == vecT(0) == (glm.array(vecT(0)) / glm.array(vecT(1)))[0] - - for vecT in vector_length_dict[2]: - if (vecT == glm.bvec2): - continue - - assert vecT(1, 2) / vecT(1, 2) == vecT(1 / 1, 2 / 2) == (glm.array(vecT(1, 2)) / glm.array(vecT(1, 2)))[0] - assert vecT(2) / vecT(3) != vecT(3) / vecT(2) and (glm.array(vecT(2)) / glm.array(vecT(3)))[0] != (glm.array(vecT(3)) / glm.array(vecT(2)))[0] - assert vecT(1) / 2 == vecT(1 / 2) == (glm.array(vecT(1)) / 2)[0] == (1 / glm.array(vecT(2)))[0] - assert vecT(0) / vecT(1) == vecT(0) == (glm.array(vecT(0)) / glm.array(vecT(1)))[0] - - for vecT in vector_length_dict[3]: - if (vecT == glm.bvec3): - continue - - assert vecT(1, 2, 3) / vecT(1, 2, 3) == vecT(1 / 1, 2 / 2, 3 / 3) == (glm.array(vecT(1, 2, 3)) / glm.array(vecT(1, 2, 3)))[0] - assert vecT(2) / vecT(3) != vecT(3) / vecT(2) and (glm.array(vecT(2)) / glm.array(vecT(3)))[0] != (glm.array(vecT(3)) / glm.array(vecT(2)))[0] - assert vecT(1) / 2 == vecT(1 / 2) == (glm.array(vecT(1)) / 2)[0] == (1 / glm.array(vecT(2)))[0] - assert vecT(0) / vecT(1) == vecT(0) == (glm.array(vecT(0)) / glm.array(vecT(1)))[0] - - for vecT in vector_length_dict[4]: - if (vecT == glm.bvec4): - continue - - assert vecT(1, 2, 3, 4) / vecT(1, 2, 3, 4) == vecT(1 / 1, 2 / 2, 3 / 3, 4 / 4) == (glm.array(vecT(1, 2, 3, 4)) / glm.array(vecT(1, 2, 3, 4)))[0] - assert vecT(2) / vecT(3) != vecT(3) / vecT(2) and (glm.array(vecT(2)) / glm.array(vecT(3)))[0] != (glm.array(vecT(3)) / glm.array(vecT(2)))[0] - assert vecT(1) / 2 == vecT(1 / 2) == (glm.array(vecT(1)) / 2)[0] == (1 / glm.array(vecT(2)))[0] - assert vecT(0) / vecT(1) == vecT(0) == (glm.array(vecT(0)) / glm.array(vecT(1)))[0] - - for c in range(2, 5): - for r in range(2, 5): - for matT in matrix_length_dict[(c, r)]: - assert matT(*range(c*r)) / 2 == matT(*map(lambda x: x / 2, range(c*r))) - - for cT in ctypes_types: - if (cT == glm.c_bool): - continue - assert glm.array(cT, 1, 2, 3) / glm.array(cT, 1, 2, 3) == glm.array(cT, 1 / 1, 2 / 2, 3 / 3) - assert glm.array(cT, 1, 2, 3) / 2 == glm.array(cT, 1 / 2, 2 / 2, 3 / 2) - assert 2 / glm.array(cT, 1, 2, 3) == glm.array(cT, 2 / 1, 2 / 2, 2 / 3) - -def test_spec_mod(): - for vecT in vector_length_dict[1]: - if (vecT == glm.bvec1): - continue - - assert vecT(1) % vecT(1) == vecT(1 % 1) == (glm.array(vecT(1)) % glm.array(vecT(1)))[0] == (glm.array(vecT(1)) % vecT(1))[0] == (vecT(1) % glm.array(vecT(1)))[0] - assert vecT(2) % vecT(3) != vecT(3) % vecT(2) and (glm.array(vecT(2)) % glm.array(vecT(3)))[0] != (glm.array(vecT(3)) % glm.array(vecT(2)))[0] - assert vecT(1) % 2 == vecT(1 % 2) == 1 % vecT(2) == (glm.array(vecT(1)) % 2)[0] == (1 % glm.array(vecT(2)))[0] - assert vecT(0) % vecT(1) == vecT(0) == (glm.array(vecT(0)) % glm.array(vecT(1)))[0] - - for vecT in vector_length_dict[2]: - if (vecT == glm.bvec2): - continue - - assert vecT(1, 2) % vecT(1, 2) == vecT(1 % 1, 2 % 2) == (glm.array(vecT(1, 2)) % glm.array(vecT(1, 2)))[0] - assert vecT(2) % vecT(3) != vecT(3) % vecT(2) and (glm.array(vecT(2)) % glm.array(vecT(3)))[0] != (glm.array(vecT(3)) % glm.array(vecT(2)))[0] - assert vecT(1) % 2 == vecT(1 % 2) == (glm.array(vecT(1)) % 2)[0] == (1 % glm.array(vecT(2)))[0] - assert vecT(0) % vecT(1) == vecT(0) == (glm.array(vecT(0)) % glm.array(vecT(1)))[0] - - for vecT in vector_length_dict[3]: - if (vecT == glm.bvec3): - continue - - assert vecT(1, 2, 3) % vecT(1, 2, 3) == vecT(1 % 1, 2 % 2, 3 % 3) == (glm.array(vecT(1, 2, 3)) % glm.array(vecT(1, 2, 3)))[0] - assert vecT(2) % vecT(3) != vecT(3) % vecT(2) and (glm.array(vecT(2)) % glm.array(vecT(3)))[0] != (glm.array(vecT(3)) % glm.array(vecT(2)))[0] - assert vecT(1) % 2 == vecT(1 % 2) == (glm.array(vecT(1)) % 2)[0] == (1 % glm.array(vecT(2)))[0] - assert vecT(0) % vecT(1) == vecT(0) == (glm.array(vecT(0)) % glm.array(vecT(1)))[0] - - for vecT in vector_length_dict[4]: - if (vecT == glm.bvec4): - continue - - assert vecT(1, 2, 3, 4) % vecT(1, 2, 3, 4) == vecT(1 % 1, 2 % 2, 3 % 3, 4 % 4) == (glm.array(vecT(1, 2, 3, 4)) % glm.array(vecT(1, 2, 3, 4)))[0] - assert vecT(2) % vecT(3) != vecT(3) % vecT(2) and (glm.array(vecT(2)) % glm.array(vecT(3)))[0] != (glm.array(vecT(3)) % glm.array(vecT(2)))[0] - assert vecT(1) % 2 == vecT(1 % 2) == (glm.array(vecT(1)) % 2)[0] == (1 % glm.array(vecT(2)))[0] - assert vecT(0) % vecT(1) == vecT(0) == (glm.array(vecT(0)) % glm.array(vecT(1)))[0] - - for cT in ctypes_types: - if (cT == glm.c_bool): - continue - assert glm.array(cT, 1, 2, 3) % glm.array(cT, 1, 2, 3) == glm.array(cT, 1 % 1, 2 % 2, 3 % 3) - assert glm.array(cT, 1, 2, 3) % 2 == glm.array(cT, 1 % 2, 2 % 2, 3 % 2) - assert 2 % glm.array(cT, 1, 2, 3) == glm.array(cT, 2 % 1, 2 % 2, 2 % 3) - -def test_spec_pow(): - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert vecT(2) ** vecT(3) == vecT(2 ** 3) == (glm.array(vecT(2)) ** glm.array(vecT(3)))[0] == (glm.array(vecT(2)) ** 3)[0] == (glm.array(vecT(2)) ** vecT(3))[0] == (vecT(2) ** glm.array(vecT(3)))[0] == (2 ** glm.array(vecT(3)))[0] - - for cT in [glm.c_float, glm.c_double]: - assert glm.array(cT, 1, 2, 3) ** glm.array(cT, 1, 2, 3) == glm.array(cT, 1 ** 1, 2 ** 2, 3 ** 3) - assert glm.array(cT, 1, 2, 3) ** 2 == glm.array(cT, 1 ** 2, 2 ** 2, 3 ** 2) - assert 2 ** glm.array(cT, 1, 2, 3) == glm.array(cT, 2 ** 1, 2 ** 2, 2 ** 3) - -def test_spec_neg(): - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")] + vector_type_dict[datatypes.index("int")] + vector_type_dict[datatypes.index("glm::i64")] + vector_type_dict[datatypes.index("glm::i16")] + vector_type_dict[datatypes.index("glm::i8")]: - assert -vecT(5) == vecT(0) - vecT(5) == (-glm.array(vecT(5)))[0] - - for matT in matrix_type_dict[datatypes.index("float")] + matrix_type_dict[datatypes.index("double")] + matrix_type_dict[datatypes.index("int")]: - assert -matT(5) == matT(0) - matT(5) == (-glm.array(matT(5)))[0] - - for quaT in quat_types: - assert -quaT(1, 2, 3, 4) == quaT(0, 0, 0, 0) - quaT(1, 2, 3, 4) == (-glm.array(quaT(1, 2, 3, 4)))[0] - - for cT in [glm.c_float, glm.c_double, glm.c_int64, glm.c_int32, glm.c_int16, glm.c_int8]: - assert -glm.array(cT, 1, 2, 3) == glm.array.zeros(3, cT) - glm.array(cT, 1, 2, 3) - -def test_spec_abs(): - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")] + vector_type_dict[datatypes.index("int")] + vector_type_dict[datatypes.index("glm::i64")] + vector_type_dict[datatypes.index("glm::i16")] + vector_type_dict[datatypes.index("glm::i8")]: - assert abs(vecT(-5)) == vecT(5) == (abs(glm.array(vecT(-5))))[0] - - for matT in matrix_type_dict[datatypes.index("float")] + matrix_type_dict[datatypes.index("double")] + matrix_type_dict[datatypes.index("int")]: - assert matT(5) == (abs(glm.array(matT(-5))))[0] - - for quaT in quat_types: - assert quaT(1, 2, 3, 4) == (abs(glm.array(quaT(1, -2, 3, -4))))[0] - - for cT in [glm.c_float, glm.c_double, glm.c_int64, glm.c_int32, glm.c_int16, glm.c_int8]: - assert abs(glm.array(cT, 1, -2, -3)) == glm.array(cT, 1, 2, 3) - -def test_spec_array_methods(): - assert glm.array(glm.vec3(1, 2, 3)).concat(glm.array(glm.vec3(1, 2, 3))) == glm.array(glm.vec3(1, 2, 3)).repeat(2) == glm.array(glm.vec3(1, 2, 3)).map(lambda x: (x,x)) == glm.array(glm.vec3(1, 2, 3), glm.vec3(1, 2, 3)) - - assert glm.array(glm.vec3(1, 2, 3)).map(lambda x: x * 2) == glm.array(glm.vec3(1, 2, 3)) * 2 - assert glm.array(glm.vec3(1, 2, 3)).filter(lambda x: True) == glm.array(glm.vec3(1, 2, 3)).map(lambda x: x) == glm.array(glm.vec3(1, 2, 3)) - assert glm.array(glm.vec3(1, 2, 3)).map(lambda x: None) == glm.array(glm.vec3(1, 2, 3)).filter(lambda x: False) == glm.array(glm.vec3(1, 2, 3)).repeat(0) - - arr = glm.array(glm.c_float, 5, 3, 4, 2, 1) - arr.sort(glm.cmp) - - assert arr == glm.array(glm.c_float, 1, 2, 3, 4, 5) - - assert glm.array(glm.vec3(1, 2, 3)).split_components() == (glm.array(glm.float32, 1), glm.array(glm.float32, 2), glm.array(glm.float32, 3)) - assert glm.array(glm.vec4(1, 2, 3, 4), glm.vec4(6, 7, 8, 9)).split_components() == (glm.array(glm.float32, 1, 6), glm.array(glm.float32, 2, 7), glm.array(glm.float32, 3, 8), glm.array(glm.float32, 4, 9)) - assert glm.array(glm.mat2(1, 2, 3, 4)).split_components() == (glm.array(glm.vec2(1, 2)), glm.array(glm.vec2(3, 4))) - - assert glm.array(glm.vec4(1, 2, 3, 4), glm.vec4(6, 7, 8, 9)).reduce(glm.add) == glm.vec4(7, 9, 11, 13) - assert glm.array(glm.c_float, 5, 3, 4, 2, 1).reduce(glm.add) == 15 - assert glm.array(glm.c_float, 5, 3, 4, 2, 1).reduce(glm.add, 20) == 35 - -def test_spec_common_abs(): - for i in range(-10, 10): - assert glm.abs(i) == abs(i) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert all([x == abs(i) for x in glm.abs(vecT(i))]) - -def test_spec_common_ceil(): - for i in range(-10, 10): - x = i / 10 - - assert glm.ceil(x) == math.ceil(x) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert all([a == math.ceil(x) for a in glm.ceil(vecT(x))]) - -def test_spec_common_clamp(): - assert glm.clamp(0, 1, 2) == 1 - assert glm.clamp(1, 1, 2) == 1 - assert glm.clamp(2, 1, 2) == 2 - assert glm.clamp(3, 1, 2) == 2 - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.clamp(vecT(0), 1, 2) == vecT(1) - assert glm.clamp(vecT(1), 1, 2) == vecT(1) - assert glm.clamp(vecT(2), 1, 2) == vecT(2) - assert glm.clamp(vecT(3), 1, 2) == vecT(2) - - assert glm.clamp(vecT(0), vecT(1), vecT(2)) == vecT(1) - assert glm.clamp(vecT(1), vecT(1), vecT(2)) == vecT(1) - assert glm.clamp(vecT(2), vecT(1), vecT(2)) == vecT(2) - assert glm.clamp(vecT(3), vecT(1), vecT(2)) == vecT(2) - -def test_spec_common_floor(): - for i in range(-10, 10): - x = i / 10 - - assert glm.floor(x) == math.floor(x) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert all([a == math.floor(x) for a in glm.floor(vecT(x))]) - -def test_spec_common_fma(): - assert glm.fma(1, 2, 3) == 1 * 2 + 3 - assert glm.fma(4, 5, 6) == 4 * 5 + 6 - -def test_spec_common_fmax(): - for a in range(-2, 2): - for b in range(-2, 2): - assert glm.fmax(a, b) == max([a, b]) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.fmax(vecT(a), b) == vecT(max([a,b])) == glm.fmax(vecT(a), vecT(b)) - - for a in range(-2, 2): - for b in range(-2, 2): - for c in range(-2, 2): - for d in range(-2, 2): - assert glm.fmax(a, b, c, d) == max([a,b,c,d]) - assert glm.fmax(a, b, c) == max([a,b,c]) - -def test_spec_common_fmin(): - for a in range(-2, 2): - for b in range(-2, 2): - assert glm.fmin(a, b) == min([a, b]) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.fmin(vecT(a), b) == vecT(min([a,b])) == glm.fmin(vecT(a), vecT(b)) - - for a in range(-2, 2): - for b in range(-2, 2): - for c in range(-2, 2): - for d in range(-2, 2): - assert glm.fmin(a, b, c, d) == min([a,b,c,d]) - assert glm.fmin(a, b, c) == min([a,b,c]) - -def test_spec_common_fract(): - for i in range(-10, 10): - x = i / 10 - - assert glm.fract(x) == x - glm.floor(x) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.fract(vecT(x)) == vecT(x) - glm.floor(vecT(x)) - -def test_spec_common_max(): - for a in range(-2, 2): - for b in range(-2, 2): - assert glm.max(a, b) == max([a, b]) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.max(vecT(a), b) == vecT(max([a,b])) == glm.max(vecT(a), vecT(b)) - - for a in range(-2, 2): - for b in range(-2, 2): - for c in range(-2, 2): - for d in range(-2, 2): - assert glm.max(a, b, c, d) == max([a,b,c,d]) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.max(vecT(a), vecT(b), vecT(c), vecT(d)) == vecT(max([a, b, c, d])) - - assert glm.max(a, b, c) == max([a,b,c]) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.max(vecT(a), vecT(b), vecT(c)) == vecT(max([a, b, c])) - -def test_spec_common_min(): - for a in range(-2, 2): - for b in range(-2, 2): - assert glm.min(a, b) == min([a, b]) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.min(vecT(a), b) == vecT(min([a,b])) == glm.min(vecT(a), vecT(b)) - - for a in range(-2, 2): - for b in range(-2, 2): - for c in range(-2, 2): - for d in range(-2, 2): - assert glm.min(a, b, c, d) == min([a,b,c,d]) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.min(vecT(a), vecT(b), vecT(c), vecT(d)) == vecT(min([a, b, c, d])) - - assert glm.min(a, b, c) == min([a,b,c]) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.min(vecT(a), vecT(b), vecT(c)) == vecT(min([a, b, c])) - -def test_spec_common_mix(): - for a in range(-2, 2): - for b in range(-2, 2): - assert glm.mix(a, b, 0.) == a - assert glm.mix(a, b, 1.) == b - assert glm.mix(a, b, 0.5) == (a + b) / 2 - - assert glm.mix(a, b, True) == b - assert glm.mix(a, b, False) == a - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert glm.mix(vecT(a), vecT(b), [0.] * len(vecT(a))) == vecT(a) - assert glm.mix(vecT(a), vecT(b), [1.] * len(vecT(a))) == vecT(b) - assert glm.mix(vecT(a), vecT(b), [0.5] * len(vecT(a))) == vecT((a + b) / 2) - - assert glm.mix(vecT(a), vecT(b), [True] * len(vecT(a))) == vecT(b) - assert glm.mix(vecT(a), vecT(b), [False] * len(vecT(a))) == vecT(a) - -def test_spec_common_round(): - for i in range(-10, 10): - x = i / 10 - - if abs(x) == 0.5: - x += .05 - - assert glm.round(x) == round(x, 0), x - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert all([a == round(x, 0) for a in glm.round(vecT(x))]) - -def test_spec_common_frexp(): - for i in range(-10, 10): - x = i / 10 - - assert glm.frexp(x) == math.frexp(x) - - #for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - # assert all([(a, b) == math.frexp(x) for a, b in glm.frexp(vecT(x))]) - -def test_spec_exponential_exp(): - for i in range(5): - assert round(glm.exp(i), 5) == round(math.exp(i), 5) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert all([round(a, 5) == round(math.exp(i), 5) for a in glm.exp(vecT(i))]) - -def test_spec_exponential_exp2(): - for i in range(5): - assert round(glm.exp2(i), 5) == round(2 ** i, 5) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert all([round(a, 5) == round(2 ** i, 5) for a in glm.exp2(vecT(i))]) - -def test_spec_exponential_sqrt(): - for i in range(1,6): - assert round(glm.sqrt(i), 5) == round(math.sqrt(i), 5) - assert round(glm.inversesqrt(i), 5) == round(1 / math.sqrt(i), 5) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert all([round(a, 5) == round(math.sqrt(i), 5) for a in glm.sqrt(vecT(i))]) - assert all([round(a, 5) == round(1 / math.sqrt(i), 5) for a in glm.inversesqrt(vecT(i))]) - -def test_spec_exponential_log(): - for i in range(1,6): - assert round(glm.log(i), 5) == round(math.log(i), 5) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert all([round(a, 5) == round(math.log(i), 5) for a in glm.log(vecT(i))]) - -def test_spec_exponential_log2(): - for i in range(1,6): - assert round(glm.log2(i), 5) == round(math.log2(i), 5) - - for vecT in vector_type_dict[datatypes.index("float")] + vector_type_dict[datatypes.index("double")]: - assert all([round(a, 5) == round(math.log2(i), 5) for a in glm.log2(vecT(i))]) - -###/SPECIFIC TESTS ### - -### GLM TESTS ### -## core_func_common ## -def test_floor(): - A = 1.1 - B = glm.floor(A) - assert glm.equal(B, 1., 0.0001) - - for T in gen_type("V__fF"): - A = T(1.1) - B = glm.floor(A) - assert glm.all(glm.equal(B, T(1), 0.0001)) - -def test_modf(): - X = 1.5 - A, I = glm.modf(X) - assert glm.equal(I, 1.0, 0.0001) - assert glm.equal(A, 0.5, 0.0001) - - for T in gen_type("V4__fF"): - X = T(1.1, 1.2, 1.5, 1.7) - I = T() - A = glm.modf(X, I) - assert glm.ivec4(I) == glm.ivec4(1) - assert glm.all(glm.equal(A, T(0.1, 0.2, 0.5, 0.7), 0.00001)) - -def test_mod(): - A = 1.5 - B = 1.0 - C = glm.mod(A, B) - assert glm.equal(C, 0.5, 0.00001) - - A = -0.2 - B = 1.0 - C = glm.mod(A, B) - assert glm.equal(C, 0.8, 0.00001) - - A = 3.0 - B = 2.0 - C = glm.mod(A, B) - assert glm.equal(C, 1.0, 0.00001) - - for T in gen_type("V__fF"): - A = T(3.0) - B = 2.0 - C = glm.mod(A, B) - assert glm.all(glm.equal(C, T(1.0), 0.00001)) - - A = T(3.0) - B = T(2.0) - C = glm.mod(A, B) - assert glm.all(glm.equal(C, T(1.0), 0.00001)) - -def test_floatBitsToInt(): - A = 1.0 - B = glm.floatBitsToInt(A) - C = glm.intBitsToFloat(B) - assert A == C - - values = [1, 2, 3, 4] - - for T in gen_type("V2_V3_V4__f"): - A = T(values) - B = glm.floatBitsToInt(A) - C = glm.intBitsToFloat(B) - assert A == C - -def test_floatBitsToUint(): - A = 1.0 - B = glm.floatBitsToUint(A) - C = glm.uintBitsToFloat(B) - assert A == C - - values = [1, 2, 3, 4] - - for T in gen_type("V2_V3_V4__f"): - A = T(values) - B = glm.floatBitsToUint(A) - C = glm.uintBitsToFloat(B) - assert A == C - -def test_min(): # improved these a little - - for T in gen_type("V__fF"): - A0 = glm.min(T(1), T(2)) - A1 = glm.min(T(1), 2) - A2 = glm.min(T(2), 1) - A3 = T(glm.min(1, 2)) - assert A0 == A1 == A2 == A3 == T(1) - -def test_max(): # improved these a little - for T in gen_type("V__fF"): - A0 = glm.max(T(1), T(2)) - A1 = glm.max(T(1), 2) - A2 = glm.max(T(2), 1) - A3 = T(glm.max(1, 2)) - assert A0 == A1 == A2 == A3 == T(2) - -def test_clamp(): # filled this one - assert glm.clamp( -1, 0, 1) == 0 - assert glm.clamp( 2, 0, 1) == 1 - assert glm.clamp(0.5, 0, 1) == 0.5 - - for T in gen_type("V__fF"): - assert glm.clamp(T( -1), 0, 1) == T(0) - assert glm.clamp(T( 2), 0, 1) == T(1) - assert glm.clamp(T(0.5), 0, 1) == T(0.5) - - assert glm.clamp(T( -1), T(0), T(1)) == T(0) - assert glm.clamp(T( 2), T(0), T(1)) == T(1) - assert glm.clamp(T(0.5), T(0), T(1)) == T(0.5) - -def test_mix(): - cases = [ - # bool - ( 0, 1, False, 0), - ( 0, 1, True, 1), - (-1, 1, False, -1), - (-1, 1, True, 1), - - # float - ( 0, 1, 0, 0), - ( 0, 1, 1, 1), - (-1, 1, 0, -1), - (-1, 1, 1, 1), - ] + [ - # vec bool - (T(x), T(y), z, T(w)) for x,y,z,w in - (( 0, 1, False, 0), - ( 0, 1, True, 1), - (-1, 1, False, -1), - (-1, 1, True, 1)) for T in gen_type("V2_V3_V4__fF") - ] + [ - # vec bvec - (T(x), T(y), (getattr(glm, "bvec{L}".format(L=get_len_of_type(T))))(z), T(w)) for x,y,z,w in - (( 0, 1, False, 0), - ( 0, 1, True, 1), - (-1, 1, False, -1), - (-1, 1, True, 1)) for T in gen_type("V2_V3_V4__fF") - ] - for x, y, a, expected in cases: - result = glm.mix(x, y, a) - assert result == expected, (x, y, a, expected, result) - -def test_step(): - cases = [ - # scalar - (2, 1, 0), - (2, 3, 1), - (2, 2, 1), - ] + [ - # vec scalar - (edge, T(x), T(result)) for edge, x, result in - ((1, ( 1, 2, 3, 4), 1), - (0, ( 1, 2, 3, 4), 1), - (0, (-1, -2, -3, -4), 0)) for T in gen_type("V2_V3_V4__fF") - ] + [ - # vec vec - (T(edge), T(x), T(result)) for edge, x, result in - ((1, ( 1, 2, 3, 4), 1), - (0, ( 1, 2, 3, 4), 1), - (0, (-1, -2, -3, -4), 0)) for T in gen_type("V2_V3_V4__fF") - ] - for edge, x, expected in cases: - result = glm.step(edge, x) - assert result == expected - -def test_round(): - cases = [ - (T(x), T(result)) for x, result in - (( 0, 0), - ( 0.5, 1), - ( 1, 1), - ( 0.1, 0), - ( 0.9, 1), - ( 1.5, 2), - ( 1.9, 2), - (- 0, 0), - (-0.5, -1), - (- 1, -1), - (-0.1, 0), - (-0.9, -1), - (-1.5, -2), - (-1.9, -2)) for T in gen_type("N_V__fF") - ] - for x, expected in cases: - result = glm.round(x) - assert result == expected - -def test_roundEven(): - cases = [ - (T(x), T(result)) for x, result in - (( 0, 0), - ( 0.5, 0), - ( 1.5, 2), - ( 2.5, 2), - ( 3.5, 4), - ( 4.5, 4), - ( 5.4, 5), - (- 0, -0), - (-0.5, -0), - (-1.5, -2), - (-2.5, -2), - (-3.5, -4), - (-4.5, -4), - (-5.4, -5)) for T in gen_type("N_V__fF") - ] - for x, expected in cases: - result = glm.roundEven(x) - assert result == expected - -def test_isnan(): - for T in gen_type("N_V2_V3_V4__fF"): - assert optional_all(glm.isnan(T(float("NaN")))) - assert not optional_any(glm.isnan(T(1))) - -def test_isinf(): - for T in gen_type("N_V2_V3_V4__fF"): - assert optional_all(glm.isinf(T(float("infinity")))) - assert optional_all(glm.isinf(T(float("-infinity")))) - assert not optional_any(glm.isinf(T(1))) - -def test_sign(): - cases = [ - (T(x), T(result)) for x, result in - (( 0, 0), - ( 1, 1), - ( 2.5, 1), - ( 3.5, 1), - (- 1, -1), - (-2.5, -1), - (-3.5, -1)) for T in gen_type("N_V__fFiqsu") - ] - for x, expected in cases: - result = glm.sign(x) - assert result == expected, (x, expected, result) - -def test_frexp(): - sig, exp = glm.frexp(1024) - assert glm.equal(sig, 0.5, 0.00001) - assert exp == 11 - - x = glm.vec1(1024) - exp = glm.ivec1() - sig = glm.frexp(x, exp) - assert glm.all(glm.equal(sig, glm.vec1(0.5), 0.00001)) - assert exp == glm.ivec1(11) - - x = glm.vec2(1024, 0.24) - exp = glm.ivec2() - sig = glm.frexp(x, exp) - assert glm.all(glm.equal(sig, glm.vec2(0.5, 0.96), 0.00001)) - assert exp == glm.ivec2(11, -2) - - x = glm.vec3(1024, 0.24, 0) - exp = glm.ivec3() - sig = glm.frexp(x, exp) - assert glm.all(glm.equal(sig, glm.vec3(0.5, 0.96, 0.0), 0.00001)) - assert exp == glm.ivec3(11, -2, 0) - - x = glm.vec4(1024, 0.24, 0, -1.33) - exp = glm.ivec4() - sig = glm.frexp(x, exp) - assert glm.all(glm.equal(sig, glm.vec4(0.5, 0.96, 0.0, -0.665), 0.00001)) - assert exp == glm.ivec4(11, -2, 0, 1) - -def test_ldexp(): - assert glm.equal(glm.ldexp(0.5, 11), 1024, 0.00001) - - sig = glm.vec1(0.5) - exp = glm.ivec1(11) - x = glm.ldexp(sig, exp) - assert glm.all(glm.equal(x, glm.vec1(1024), 0.00001)) - - sig = glm.vec2(0.5, 0.96) - exp = glm.ivec2(11, -2) - x = glm.ldexp(sig, exp) - assert glm.all(glm.equal(x, glm.vec2(1024, 0.24), 0.00001)) - - sig = glm.vec3(0.5, 0.96, 0) - exp = glm.ivec3(11, -2, 0) - x = glm.ldexp(sig, exp) - assert glm.all(glm.equal(x, glm.vec3(1024, 0.24, 0), 0.00001)) - - sig = glm.vec4(0.5, 0.96, 0.0, -0.665) - exp = glm.ivec4(11, -2, 0, 1) - x = glm.ldexp(sig, exp) - assert glm.all(glm.equal(x, glm.vec4(1024, 0.24, 0, -1.33), 0.00001)) -##/core_func_common ## - -## core_func_exponential ## -def test_pow(): - for T in gen_type("N_V__fF"): - assert optional_all(glm.equal(glm.pow(T(2), T(2)), T(4), 0.00001)) - -def test_sqrt(): - for T in gen_type("N_V__fF"): - assert optional_all(glm.equal(glm.sqrt(T(4)), T(2), 0.00001)) - -def test_log(): - for T in gen_type("N_V__fF"): - assert optional_all(glm.equal(glm.log(T(glm.e())), T(1), 0.01)) - -def test_exp2(): - for T in gen_type("N_V__fF"): - assert optional_all(glm.equal(glm.exp2(T(4)), T(16), 0.00001)) - -def test_log2(): - for T in gen_type("N_V__fF"): - assert optional_all(glm.equal(glm.log2(T(16)), T(4), 0.01)) - -def test_inversesqrt(): - for T in gen_type("N_V__fF"): - assert optional_all(glm.equal(glm.inversesqrt(T(16)) * glm.sqrt(T(16)), T(1), 0.001)) -##/core_func_exponential ## - -## core_func_geometric ## -def test_length(): - assert 1 == glm.length(glm.vec1(1)) == glm.length(glm.vec2(1, 0)) == glm.length(glm.vec3(1, 0, 0)) == glm.length(glm.vec4(1, 0, 0, 0)) - -def test_distance(): - assert 0 == glm.distance(glm.vec1(1), glm.vec1(1)) == \ - glm.distance(glm.vec2(1, 0), glm.vec2(1, 0)) == \ - glm.distance(glm.vec3(1, 0, 0), glm.vec3(1, 0, 0)) == \ - glm.distance(glm.vec4(1, 0, 0, 0), glm.vec4(1, 0, 0, 0)) - -def test_dot(): - assert glm.dot(glm.vec1(1), glm.vec1(1)) == 1 - assert glm.dot(glm.vec2(1), glm.vec2(1)) == 2 - assert glm.dot(glm.vec3(1), glm.vec3(1)) == 3 - assert glm.dot(glm.vec4(1), glm.vec4(1)) == 4 - -def test_cross(): - Cross1 = glm.cross(glm.vec3(1, 0, 0), glm.vec3(0, 1, 0)) - Cross2 = glm.cross(glm.vec3(0, 1, 0), glm.vec3(1, 0, 0)) - - glm.all(glm.lessThan(glm.abs(Cross1 - glm.vec3(0, 0, 1)), glm.vec3(0.0001))) - glm.all(glm.lessThan(glm.abs(Cross2 - glm.vec3(0, 0,-1)), glm.vec3(0.0001))) - -def test_normalize(): - Normalize1 = glm.normalize(glm.vec3(1, 0, 0)) - Normalize2 = glm.normalize(glm.vec3(2, 0, 0)) - - Normalize3 = glm.normalize(glm.vec3(-0.6, 0.7, -0.5)) - - glm.all(glm.lessThan(glm.abs(Normalize1 - glm.vec3(1, 0, 0)), glm.vec3(0.0001))) - glm.all(glm.lessThan(glm.abs(Normalize2 - glm.vec3(1, 0, 0)), glm.vec3(0.0001))) - glm.all(glm.lessThan(glm.abs(Normalize3 - glm.normalize((-1.2,1.4,-1))), glm.vec3(0.0001))) - -def test_faceforward(): - N = glm.vec3(0.0, 0.0, 1.0) - I = glm.vec3(1.0, 0.0, 1.0) - Nref = glm.vec3(0.0, 0.0, 1.0) - F = glm.faceforward(N, I, Nref) - - assert glm.equal(F, (0,0,-1), 0.0001) - -def test_reflect(): - A = glm.vec2(1.0,-1.0) - B = glm.vec2(0.0, 1.0) - C = glm.reflect(A, B) - - assert glm.all(glm.equal(C, glm.vec2(1.0, 1.0), 0.0001)) - -def test_refract(): - A = glm.vec2(0.0,-1.0) - B = glm.vec2(0.0, 1.0) - C = glm.refract(A, B, 0.5) - - assert glm.all(glm.equal(C, glm.vec2(0.0, -1.0), 0.0001)) -##/core_func_geometric ## - -## core_func_integer ## -def test_bitfieldInsert(): - cases = [ - (T(base), T(insert), offset, bits, T(expected)) for base, insert, offset, bits, expected in - ((0x00000000, 0xffffffff, 0, 32, 0xffffffff), - (0x00000000, 0xffffffff, 0, 31, 0x7fffffff), - (0x00000000, 0xffffffff, 0, 0, 0x00000000), - (0xff000000, 0x000000ff, 8, 8, 0xff00ff00), - (0xffff0000, 0xffff0000, 16, 16, 0x00000000), - (0x0000ffff, 0x0000ffff, 16, 16, 0xffffffff)) for T in gen_type("V__iI") - ] + [ - (T(base), T(insert), offset, bits, T(expected).value) for base, insert, offset, bits, expected in - ((0x00000000, 0xffffffff, 0, 32, 0xffffffff), - (0x00000000, 0xffffffff, 0, 31, 0x7fffffff), - (0x00000000, 0xffffffff, 0, 0, 0x00000000), - (0xff000000, 0x000000ff, 8, 8, 0xff00ff00), - (0xffff0000, 0xffff0000, 16, 16, 0x00000000), - (0x0000ffff, 0x0000ffff, 16, 16, 0xffffffff)) for T in [glm.int32, glm.uint32] - ] - - for base, insert, offset, bits, expected in cases: - result = glm.bitfieldInsert(base, insert, offset, bits) - assert result == expected, (result, expected) - -def test_bitfieldExtract(): - cases = [ - (T(value), offset, bits, T(expected)) for value, offset, bits, expected in - ((0xffffffff, 0,32, 0xffffffff), - (0xffffffff, 8, 0, 0x00000000), - (0x00000000, 0,32, 0x00000000), - (0x0f0f0f0f, 0,32, 0x0f0f0f0f), - (0x00000000, 8, 0, 0x00000000), - (0x80000000,31, 1, 0x00000001), - (0x7fffffff,31, 1, 0x00000000), - (0x00000300, 8, 8, 0x00000003), - (0x0000ff00, 8, 8, 0x000000ff), - (0xfffffff0, 0, 5, 0x00000010), - (0x000000ff, 1, 3, 0x00000007), - (0x000000ff, 0, 3, 0x00000007), - (0x00000000, 0, 2, 0x00000000), - (0xffffffff, 0, 8, 0x000000ff), - (0xffff0000,16,16, 0x0000ffff)) for T in gen_type("V__iI") - ] + [ - (T(value), offset, bits, T(expected).value) for value, offset, bits, expected in - ((0xffffffff, 0,32, 0xffffffff), - (0xffffffff, 8, 0, 0x00000000), - (0x00000000, 0,32, 0x00000000), - (0x0f0f0f0f, 0,32, 0x0f0f0f0f), - (0x00000000, 8, 0, 0x00000000), - (0x80000000,31, 1, 0x00000001), - (0x7fffffff,31, 1, 0x00000000), - (0x00000300, 8, 8, 0x00000003), - (0x0000ff00, 8, 8, 0x000000ff), - (0xfffffff0, 0, 5, 0x00000010), - (0x000000ff, 1, 3, 0x00000007), - (0x000000ff, 0, 3, 0x00000007), - (0x00000000, 0, 2, 0x00000000), - (0xffffffff, 0, 8, 0x000000ff), - (0xffff0000,16,16, 0x0000ffff)) for T in [glm.int32, glm.uint32] - ] - - for value, offset, bits, expected in cases: - result = glm.bitfieldExtract(value, offset, bits) - assert result == expected, (result, expected, (value, offset, bits)) - -def test_bitfieldReverse(): - cases = [ - (T(value), T(expected)) for value, expected in - ((0x00000001, 0x80000000), - (0x0000000f, 0xf0000000), - (0x000000ff, 0xff000000), - (0xf0000000, 0x0000000f), - (0xff000000, 0x000000ff), - (0xffffffff, 0xffffffff), - (0x00000000, 0x00000000)) for T in gen_type("V__I") - ] + [ - (T(value), T(expected)) for value, expected in - ((0x00000000000000ff, 0xff00000000000000), - (0x000000000000000f, 0xf000000000000000), - (0xf000000000000000, 0x000000000000000f), - (0xffffffffffffffff, 0xffffffffffffffff), - (0x0000000000000000, 0x0000000000000000)) for T in gen_type("V__Q") - ] + [ - (T(value), T(expected).value) for value, expected in - ((0x00000001, 0x80000000), - (0x0000000f, 0xf0000000), - (0x000000ff, 0xff000000), - (0xf0000000, 0x0000000f), - (0xff000000, 0x000000ff), - (0xffffffff, 0xffffffff), - (0x00000000, 0x00000000)) for T in [glm.uint32] - ] + [ - (T(value), T(expected).value) for value, expected in - ((0x00000000000000ff, 0xff00000000000000), - (0x000000000000000f, 0xf000000000000000), - (0xf000000000000000, 0x000000000000000f), - (0xffffffffffffffff, 0xffffffffffffffff), - (0x0000000000000000, 0x0000000000000000)) for T in [glm.uint64] - ] - - for value, expected in cases: - result = glm.bitfieldReverse(value) - assert result == expected, (result, expected, value) - -def test_findMSB(): - cases = [ - (T(value), getattr(glm, f"ivec{get_len_of_type(T)}")(expected)) for value, expected in - ((0x00000000, -1), - (0x00000001, 0), - (0x00000002, 1), - (0x00000003, 1), - (0x00000004, 2), - (0x00000005, 2), - (0x00000007, 2), - (0x00000008, 3), - (0x00000010, 4), - (0x00000020, 5), - (0x00000040, 6), - (0x00000080, 7), - (0x00000100, 8), - (0x00000200, 9), - (0x00000400, 10), - (0x00000800, 11), - (0x00001000, 12), - (0x00002000, 13), - (0x00004000, 14), - (0x00008000, 15), - (0x00010000, 16), - (0x00020000, 17), - (0x00040000, 18), - (0x00080000, 19), - (0x00100000, 20), - (0x00200000, 21), - (0x00400000, 22), - (0x00800000, 23), - (0x01000000, 24), - (0x02000000, 25), - (0x04000000, 26), - (0x08000000, 27), - (0x10000000, 28), - (0x20000000, 29), - (0x40000000, 30)) for T in gen_type("V__iIqQ") - ] + [ - (0x00000000, -1), - (0x00000001, 0), - (0x00000002, 1), - (0x00000003, 1), - (0x00000004, 2), - (0x00000005, 2), - (0x00000007, 2), - (0x00000008, 3), - (0x00000010, 4), - (0x00000020, 5), - (0x00000040, 6), - (0x00000080, 7), - (0x00000100, 8), - (0x00000200, 9), - (0x00000400, 10), - (0x00000800, 11), - (0x00001000, 12), - (0x00002000, 13), - (0x00004000, 14), - (0x00008000, 15), - (0x00010000, 16), - (0x00020000, 17), - (0x00040000, 18), - (0x00080000, 19), - (0x00100000, 20), - (0x00200000, 21), - (0x00400000, 22), - (0x00800000, 23), - (0x01000000, 24), - (0x02000000, 25), - (0x04000000, 26), - (0x08000000, 27), - (0x10000000, 28), - (0x20000000, 29), - (0x40000000, 30) - ] - - for value, expected in cases: - result = glm.findMSB(value) - assert result == expected, (result, expected, value) - -def test_findLSB(): - cases = [ - (T(value), getattr(glm, f"ivec{get_len_of_type(T)}")(expected)) for value, expected in - ((0x00000001, 0), - (0x00000003, 0), - (0x00000002, 1), - (0x00010000, 16), - (0x7FFF0000, 16), - (0x7F000000, 24), - (0x7F00FF00, 8), - (0x00000000, -1)) for T in gen_type("V__iIqQ") - ] + [ - (0x00000001, 0), - (0x00000003, 0), - (0x00000002, 1), - (0x00010000, 16), - (0x7FFF0000, 16), - (0x7F000000, 24), - (0x7F00FF00, 8), - (0x00000000, -1) - ] - - for value, expected in cases: - result = glm.findLSB(value) - assert result == expected, (result, expected, value) - -def test_uaddCarry(): - cases = [ - (glm.uint32(x).value, glm.uint32(y).value, glm.uint32(expected_result).value, glm.uint32(expected_carry).value) for x, y, expected_result, expected_carry in - ((-1, 0, -1, 0), - (-1, 1, 0, 1)) - ] - - for x, y, expected_result, expected_carry in cases: - result, carry = glm.uaddCarry(x, y) - assert result == expected_result, (result, expected_result, (x,y)) - assert carry == expected_carry, (carry, expected_carry, (x,y)) - - for T in [getattr(glm, f"uvec{l}") for l in range(1,5)]: - carry = T(0) - result = glm.uaddCarry(T(x), T(y), carry) - assert result == T(expected_result), (result, expected_result, (x,y)) - assert carry == T(expected_carry), (carry, expected_carry, (x,y)) - -def test_usubBorrow(): - cases = [ - (glm.uint32(x).value, glm.uint32(y).value, glm.uint32(expected_result).value, glm.uint32(expected_borrow).value) for x, y, expected_result, expected_borrow in - ((16, 17, 1, 1),) - ] - - for x, y, expected_result, expected_borrow in cases: - result, borrow = glm.usubBorrow(x, y) - assert result == expected_result, (result, expected_result, (x,y)) - assert borrow == expected_borrow, (borrow, expected_borrow, (x,y)) - - for T in [getattr(glm, f"uvec{l}") for l in range(1,5)]: - borrow = T(0) - result = glm.usubBorrow(T(x), T(y), borrow) - assert result == T(expected_result), (result, expected_result, (x,y)) - assert borrow == T(expected_borrow), (carry, expected_borrow, (x,y)) - -def test_umulExtended(): - cases = [ - (2, 3, 0, 6) - ] - - for x, y, expected_msb, expected_lsb in cases: - msb, lsb = glm.umulExtended(x, y) - assert msb == expected_msb, (msb, expected_msb, (x,y)) - assert lsb == expected_lsb, (lsb, expected_lsb, (x,y)) - - for T in [getattr(glm, f"uvec{l}") for l in range(1,5)]: - msb = T(0) - lsb = T(0) - result = glm.umulExtended(T(x), T(y), msb, lsb) - assert msb == T(expected_msb), (msb, expected_msb, (x,y)) - assert lsb == T(expected_lsb), (lsb, expected_lsb, (x,y)) - -def test_imulExtended(): - cases = [ - (2, 3, 0, 6) - ] - - for x, y, expected_msb, expected_lsb in cases: - msb, lsb = glm.imulExtended(x, y) - assert msb == expected_msb, (msb, expected_msb, (x,y)) - assert lsb == expected_lsb, (lsb, expected_lsb, (x,y)) - - for T in [getattr(glm, f"ivec{l}") for l in range(1,5)]: - msb = T(0) - lsb = T(0) - result = glm.imulExtended(T(x), T(y), msb, lsb) - assert msb == T(expected_msb), (msb, expected_msb, (x,y)) - assert lsb == T(expected_lsb), (lsb, expected_lsb, (x,y)) - -def test_bitCount(): - cases = [ - (T(value), getattr(glm, f"ivec{get_len_of_type(T)}")(expected)) for value, expected in - ((0x00000001, 1), - (0x00000003, 2), - (0x00000002, 1), - (0x000000ff, 8), - (0x00000000, 0)) for T in gen_type("V__sSuU") - ] + [ - (T(value), getattr(glm, f"ivec{get_len_of_type(T)}")(expected)) for value, expected in - ((0x00000001, 1), - (0x00000003, 2), - (0x00000002, 1), - (0x7fffffff, 31), - (0x00000000, 0)) for T in gen_type("V__iIqQ") - ] + [ - (0x00000001, 1), - (0x00000003, 2), - (0x00000002, 1), - (0x7fffffff, 31), - (0x00000000, 0) - ] - - for value, expected in cases: - result = glm.bitCount(value) - assert result == expected, (result, expected, value) -##/core_func_integer ## - -## core_func_matrix ## -def test_matrixCompMult(): - for T in gen_type("M__fF"): - m = T(((0, 1, 2, 3), (4, 5, 6, 7), (8, 9, 10, 11), (12, 13, 14, 15))) - n = glm.matrixCompMult(m, m) - assert n == T(((0, 1, 4, 9), (16, 25, 36, 49), (64, 81, 100, 121), (144, 169, 196, 225))) - -def test_outerProduct(): - for c in (range(2), range(3), range(4)): - for r in (range(4,6), range(4,7), range(4,8)): - result = glm.outerProduct(tuple(c), tuple(r)) - l = [e for l in result for e in l] - for i in range(len(l)): - assert l[i] == (c[i % len(c)]) * (r[i // len(c)]), (l, c, r, i) - -def test_determinant(): - for T in gen_type("M22_M33_M44__fF"): - L = get_len_of_type(T) - args = list(range(1, L + 1)) - prod = 1 - for arg in args: - prod *= arg - - assert glm.determinant(T(*args)) == prod, T(*args) - -def test_inverse(): - for T in gen_type("M22_M33_M44__fF"): - m = T(((0, 1, 2, 3), (4, 5, 6, 7), (8, 9, 10, 11), (12, 13, 14, 15))) - i = glm.inverse(m) - p = m * i - assert glm.equal(m, i, 0.00001) -##/core_func_matrix ## - -## core_func_packing ## -def test_packUnorm2x16(): - cases = [ - glm.vec2(1.0, 0.0), - glm.vec2(0.5, 0.7), - glm.vec2(0.1, 0.2) - ] - - for case in cases: - packed = glm.packUnorm2x16(case) - unpacked = glm.unpackUnorm2x16(packed) - assert glm.equal(case, unpacked, 1 / 65535) - -def test_packSnorm2x16(): - cases = [ - glm.vec2( 1.0, 0.0), - glm.vec2(-0.5,-0.7), - glm.vec2(-0.1, 0.1) - ] - - for case in cases: - packed = glm.packSnorm2x16(case) - unpacked = glm.unpackSnorm2x16(packed) - assert glm.equal(case, unpacked, 1 / 32767) - -def test_packUnorm4x8(): - cases = [ - glm.vec4(1.0, 0.7, 0.3, 0.0), - glm.vec4(0.5, 0.1, 0.2, 0.3) - ] - - for case in cases: - packed = glm.packUnorm4x8(case) - unpacked = glm.unpackUnorm4x8(packed) - assert glm.equal(case, unpacked, 1 / 255) - -def test_packSnorm4x8(): - cases = [ - glm.vec4( 1.0, 0.0,-0.5,-1.0), - glm.vec4(-0.7,-0.1, 0.1, 0.7) - ] - - for case in cases: - packed = glm.packSnorm4x8(case) - unpacked = glm.unpackSnorm4x8(packed) - assert glm.equal(case, unpacked, 1 / 127) - -def test_packHalf2x16(): - cases = [ - glm.vec2( 1.0, 2.0), - glm.vec2(-1.0,-2.0), - glm.vec2(-1.1, 1.1) - ] - - for case in cases: - packed = glm.packHalf2x16(case) - unpacked = glm.unpackHalf2x16(packed) - assert glm.equal(case, unpacked, 1 / 127) - -def test_packDouble2x32(): - cases = [ - glm.uvec2( 1, 2), - glm.uvec2(-1,-2), - glm.uvec2(-1000, 1100) - ] - - for case in cases: - packed = glm.packDouble2x32(case) - unpacked = glm.unpackDouble2x32(packed) - assert case == unpacked, (case, unpacked) -##/core_func_packing ## - -## core_func_trigonometric ## -def test_sin(): - for T in gen_type("V_N__fF"): - v = glm.radians(glm.degrees(random.random())) - assert glm.equal(glm.asin(glm.sin(T(v))), T(v), 0.0001), v - assert glm.equal(glm.sin(T(v)), T(math.sin(v)), 0.0001), v - -def test_cos(): - for T in gen_type("V_N__fF"): - v = glm.radians(glm.degrees(random.random())) - assert glm.equal(glm.acos(glm.cos(T(v))), T(v), 0.0001), v - assert glm.equal(glm.cos(T(v)), T(math.cos(v)), 0.0001), v - -def test_tan(): - for T in gen_type("V_N__fF"): - v = glm.radians(glm.degrees(random.random())) - assert glm.equal(glm.atan(glm.tan(T(v))), T(v), 0.0001), v - assert glm.equal(glm.tan(T(v)), T(math.tan(v)), 0.0001), v - -def test_sinh(): - for T in gen_type("V_N__fF"): - v = glm.radians(glm.degrees(random.random())) - assert glm.equal(glm.asinh(glm.sinh(T(v))), T(v), 0.0001), v - assert glm.equal(glm.sinh(T(v)), T(math.sinh(v)), 0.0001), v - -def test_cosh(): - for T in gen_type("V_N__fF"): - v = glm.radians(glm.degrees(random.random())) - assert glm.equal(glm.acosh(glm.cosh(T(v))), T(v), 0.0001), v - assert glm.equal(glm.cosh(T(v)), T(math.cosh(v)), 0.0001), v - -def test_tanh(): - for T in gen_type("V_N__fF"): - v = glm.radians(glm.degrees(random.random())) - assert glm.equal(glm.atanh(glm.tanh(T(v))), T(v), 0.0001), v - assert glm.equal(glm.tanh(T(v)), T(math.tanh(v)), 0.0001), v -##/core_func_trigonometric ## - -## core_func_vector_relational ## -def test_not(): - for T in gen_type("V__B"): - b = T(False) - assert glm.all(glm.not_(b)) - -def test_less(): - for T in gen_type("V"): - v = T(0) - vp1 = v + 1 - - assert glm.all(glm.lessThan(v, vp1)) - assert glm.all(glm.lessThanEqual(v, vp1)) - assert glm.all(glm.lessThanEqual(v, v)) - - assert not glm.any(glm.lessThan(vp1, v)) - assert not glm.any(glm.lessThanEqual(vp1, v)) - -def test_greater(): - for T in gen_type("V"): - v = T(0) - vp1 = v + 1 - - assert glm.all(glm.greaterThan(vp1, v)) - assert glm.all(glm.greaterThanEqual(vp1, v)) - assert glm.all(glm.greaterThanEqual(v, v)) - - assert not glm.any(glm.greaterThan(v, vp1)) - assert not glm.any(glm.greaterThanEqual(v, vp1)) - -def test_equal(): - for T in gen_type("V"): - assert glm.all(glm.equal(T(0), T(0))) - assert not glm.any(glm.notEqual(T(0), T(0))) -##/core_func_vector_relational ## - -## core_type_mat2x2 ## -def test_mat2x2(): - l = glm.mat2x2(1) - m = glm.mat2x2(1) - u = glm.vec2(1) - v = glm.vec2(1) - x = 1 - a = m * u - b = v * m - n = x / m - o = m / x - p = x * m - q = m * x - assert not glm.any(glm.notEqual(m, q, 0.00001)) - assert glm.all(glm.equal(m, l, 0.00001)); -##/core_type_mat2x2 ## -###/GLM TESTS ### - -def test_array_matmul(): - hitbox = glm.array( - glm.vec2(0., 1.), - glm.vec2(1., 1.), - glm.vec2(1., 0.), - glm.vec2(0., 0.), - ) - rotation = glm.radians(90) - scale_x = 1. - scale_y = 2. - - cos_rotation = glm.cos(rotation) - sin_rotation = glm.sin(rotation) - - rotation_scale_matrix = glm.mat2x2( - scale_x * cos_rotation, -scale_y * sin_rotation, - scale_x * sin_rotation, scale_y * cos_rotation - ) - hitbox_rotated = hitbox * rotation_scale_matrix - - # I expect to see the points rotated 90 degrees, approximately: - # array(vec2(-2, 0), vec2(-2, 1), vec2(0, 1), vec2(0, 0)) - assert glm.equal(hitbox_rotated[0].x, -2, 0.00001) - assert glm.equal(hitbox_rotated[0].y, 0, 0.00001) - assert glm.equal(hitbox_rotated[1].x, -2, 0.00001) - assert glm.equal(hitbox_rotated[1].y, 1, 0.00001) - assert glm.equal(hitbox_rotated[2].x, 0, 0.00001) - assert glm.equal(hitbox_rotated[2].y, 1, 0.00001) - assert glm.equal(hitbox_rotated[3].x, 0, 0.00001) - assert glm.equal(hitbox_rotated[3].y, 0, 0.00001) - -### TEST TEST ### - -def test_everything_tested(): - f = open(__file__, "r") - content = f.read() - f.close() - - excluded = ["make_mat.+", "make_vec.+"] - - builtin_function_or_method = type(glm.silence) - - for raw in dir(glm): - func = getattr(glm, raw) - if (raw.startswith("__") and raw.endswith("__") or not isinstance(func, builtin_function_or_method)): - continue - if not raw in content and not any((re.fullmatch(ex, raw) for ex in excluded)): - print("{} has no test.".format(raw)) \ No newline at end of file diff --git a/vs-project/generate_function_reference.py b/vs-project/generate_function_reference.py index 5dd36e5c..4374c6e7 100644 --- a/vs-project/generate_function_reference.py +++ b/vs-project/generate_function_reference.py @@ -3,7 +3,9 @@ builtin_function_or_method = type(glm.silence) -TARGET_FOLDER = "../wiki/function-reference" +HERE = os.path.dirname(__file__) + +TARGET_FOLDER = os.path.abspath(os.path.join(HERE, "../wiki/function-reference")) functions = []