diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml deleted file mode 100644 index 0f413cf4..00000000 --- a/.github/workflows/codeql-analysis.yml +++ /dev/null @@ -1,68 +0,0 @@ -# For most projects, this workflow file will not need changing; you simply need -# to commit it to your repository. -# -# You may wish to alter this file to override the set of languages analyzed, -# or to provide custom queries or build logic. -# -# ******** NOTE ******** -# We have attempted to detect the languages in your repository. Please check -# the `language` matrix defined below to confirm you have the correct set of -# supported CodeQL languages. -# -name: "CodeQL" - -on: pull_request - -jobs: - analyze: - name: Analyze - runs-on: ubuntu-latest - permissions: - actions: read - contents: read - security-events: write - - strategy: - fail-fast: false - matrix: - language: [ 'cpp' ] - # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ] - # Learn more: - # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed - - steps: - - name: Checkout repository - uses: actions/checkout@v2 - with: - submodules: recursive - - - name: Set up Python 3.9 - uses: actions/setup-python@v2 - with: - python-version: 3.9 - - # Initializes the CodeQL tools for scanning. - - name: Initialize CodeQL - uses: github/codeql-action/init@v1 - with: - languages: ${{ matrix.language }} - # If you wish to specify custom queries, you can do so here or in a config file. - # By default, queries listed here will override any specified in a config file. - # Prefix the list here with "+" to use these queries and those in the config file. - # queries: ./path/to/local/query, your-org/your-repo/queries@main - - - # Autobuild attempts to build any compiled languages (C/C++, C#, or Java). - # If this step fails, then you should remove it and run the build manually (see below) - - # ℹ️ Command-line programs to run using the OS shell. - # 📚 https://git.io/JvXDl - - # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines - # and modify them (or add more) to build your code if your project - # uses a compiled language - - - run: python setup.py build - - - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@v1 diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml new file mode 100644 index 00000000..32d12ab2 --- /dev/null +++ b/.github/workflows/codeql.yml @@ -0,0 +1,95 @@ +# For most projects, this workflow file will not need changing; you simply need +# to commit it to your repository. +# +# You may wish to alter this file to override the set of languages analyzed, +# or to provide custom queries or build logic. +# +# ******** NOTE ******** +# We have attempted to detect the languages in your repository. Please check +# the `language` matrix defined below to confirm you have the correct set of +# supported CodeQL languages. +# +name: "CodeQL Advanced" + +on: + pull_request: + push: + branches: + - master + +jobs: + analyze: + name: Analyze + # Runner size impacts CodeQL analysis time. To learn more, please see: + # - https://gh.io/recommended-hardware-resources-for-running-codeql + # - https://gh.io/supported-runners-and-hardware-resources + # - https://gh.io/using-larger-runners (GitHub.com only) + # Consider using larger runners or machines with greater resources for possible analysis time improvements. + runs-on: 'ubuntu-latest' + permissions: + # required for all workflows + security-events: write + + # required to fetch internal or private CodeQL packs + packages: read + + # only required for workflows in private repositories + actions: read + contents: read + + strategy: + fail-fast: false + matrix: + include: + - language: c-cpp + build-mode: manual + # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift' + # Use `c-cpp` to analyze code written in C, C++ or both + # Use 'java-kotlin' to analyze code written in Java, Kotlin or both + # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both + # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis, + # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning. + # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how + # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages + steps: + - name: Checkout repository + uses: actions/checkout@v5 + with: + submodules: recursive + + - name: Set up Python 3.14 + uses: actions/setup-python@v6 + with: + python-version: 3.14 + + - name: Install pip, build and pytest + run: | + python -m pip install pip --upgrade + pip install pytest build + + # Initializes the CodeQL tools for scanning. + - name: Initialize CodeQL + uses: github/codeql-action/init@v3 + with: + languages: ${{ matrix.language }} + build-mode: ${{ matrix.build-mode }} + # If you wish to specify custom queries, you can do so here or in a config file. + # By default, queries listed here will override any specified in a config file. + # Prefix the list here with "+" to use these queries and those in the config file. + + # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs + # queries: security-extended,security-and-quality + + # If the analyze step fails for one of the languages you are analyzing with + # "We were unable to automatically build your code", modify the matrix above + # to set the build mode to "manual" for that language. Then modify this step + # to build your code. + # ℹ️ Command-line programs to run using the OS shell. + # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun + - name: Build PyGLM + run: python -m build + + - name: Perform CodeQL Analysis + uses: github/codeql-action/analyze@v3 + with: + category: "/language:${{matrix.language}}" diff --git a/.github/workflows/deploy-test-pypi.yml b/.github/workflows/deploy-test-pypi.yml new file mode 100644 index 00000000..e098edc8 --- /dev/null +++ b/.github/workflows/deploy-test-pypi.yml @@ -0,0 +1,267 @@ +name: Build and upload to Test-PyPI + +on: workflow_dispatch + +env: + CIBW_BUILD: cp3* + CIBW_SKIP: cp38-* + CIBW_TEST_REQUIRES: pytest + CIBW_TEST_COMMAND: pytest {project}/test/PyGLM_test.py -v + +jobs: + build_wheels_windows: + name: Build wheels on Windows (${{ matrix.arch }}) + runs-on: windows-latest + strategy: + matrix: + arch: [AMD64, ARM64] + + env: + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-win-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_mac: + name: Build wheels on MacOS (${{ matrix.arch }}) + runs-on: macos-latest + strategy: + matrix: + arch: [x86_64, arm64] + + env: + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-mac-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_manylinux: + name: Build wheels on ${{ matrix.distro }} for ${{ matrix.arch }} + runs-on: ubuntu-latest + strategy: + matrix: + distro: [manylinux2014, manylinux_2_34] + arch: [x86_64] + + env: + CIBW_MANYLINUX_X86_64_IMAGE: ${{ matrix.distro }} + CIBW_MANYLINUX_I686_IMAGE: ${{ matrix.distro }} + CIBW_MANYLINUX_S390X_IMAGE: ${{ matrix.distro }} + CIBW_BUILD: cp3*-manylinux* + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up QEMU + if: ${{ matrix.arch != 'x86_64' }} + uses: docker/setup-qemu-action@v3 + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-${{ matrix.distro }}-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_manylinux_arm: + name: Build wheels on ${{ matrix.distro }} for ${{ matrix.arch }} + runs-on: ubuntu-24.04-arm + strategy: + matrix: + distro: [manylinux2014, manylinux_2_34] + arch: [aarch64] + #include: + # - distro: manylinux_2_31 + # arch: armv7l + + + env: + CIBW_MANYLINUX_AARCH64_IMAGE: ${{ matrix.distro }} + CIBW_MANYLINUX_ARMV7L_IMAGE: ${{ matrix.distro }} + CIBW_BUILD: cp3*-manylinux* + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-${{ matrix.distro }}-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_musllinux: + name: Build wheels on musllinux_1_2 for ${{ matrix.arch }} + runs-on: ubuntu-latest + strategy: + matrix: + arch: [x86_64] + + env: + CIBW_MUSLLINUX_X86_64_IMAGE: musllinux_1_2 + CIBW_MUSLLINUX_I686_IMAGE: musllinux_1_2 + CIBW_MUSLLINUX_S390X_IMAGE: musllinux_1_2 + CIBW_BUILD: cp3*-musllinux* + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up QEMU + if: ${{ matrix.arch != 'x86_64' }} + uses: docker/setup-qemu-action@v3 + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-musllinux-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_musllinux_arm: + name: Build wheels on musllinux_1_2 for ${{ matrix.arch }} + runs-on: ubuntu-24.04-arm + strategy: + matrix: + arch: [aarch64] + + env: + CIBW_MUSLLINUX_AARCH64_IMAGE: musllinux_1_2 + CIBW_BUILD: cp3*-musllinux* + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-musllinux-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_sdist: + name: Build source distribution + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install build + run: pip install build + + - name: Build sdist + run: python -m build --sdist + + - uses: actions/upload-artifact@v5 + with: + name: artifact-source + path: dist/*.tar.gz + + upload_pypi: + needs: [build_wheels_windows, build_wheels_mac, build_wheels_manylinux, build_wheels_manylinux_arm, build_wheels_musllinux, build_wheels_musllinux_arm, build_sdist] + runs-on: ubuntu-latest + + #if: github.event_name == 'release' && github.event.action == 'published' + + steps: + - uses: actions/download-artifact@v6 + with: + pattern: artifact-* + merge-multiple: true + path: dist + + - uses: pypa/gh-action-pypi-publish@v1.13.0 + with: + user: __token__ + # password: ${{ secrets.pypi_password }} + password: ${{ secrets.testpypi_password }} + repository-url: https://test.pypi.org/legacy/ diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index 7368b421..804fca54 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -1,182 +1,270 @@ -name: Build and upload to PyPI - -on: - release: - types: [published] - -env: - CIBW_BUILD: cp3* - CIBW_TEST_REQUIRES: pytest - CIBW_TEST_COMMAND: pytest {project}/test/PyGLM_test.py -v - -jobs: - build_wheels_windows: - name: Build wheels on Windows (${{ matrix.arch }}) - runs-on: windows-latest - strategy: - matrix: - arch: [AMD64, x86] - - env: - CIBW_ARCHS: ${{matrix.arch}} - - steps: - - uses: actions/checkout@v2 - with: - submodules: recursive - - - uses: actions/setup-python@v2 - name: Install Python - with: - python-version: '3.10' - - - name: Build wheels - uses: pypa/cibuildwheel@v2.2.2 - - - uses: actions/upload-artifact@v2 - with: - path: ./wheelhouse/*.whl - - build_wheels_mac: - name: Build wheels on MacOS (${{ matrix.arch }}) - runs-on: macos-latest - strategy: - matrix: - arch: [x86_64, arm64] - - env: - CIBW_ARCHS: ${{matrix.arch}} - - steps: - - uses: actions/checkout@v2 - with: - submodules: recursive - - - uses: actions/setup-python@v2 - name: Install Python - with: - python-version: '3.10' - - - name: Build wheels - uses: pypa/cibuildwheel@v2.2.2 - - - uses: actions/upload-artifact@v2 - with: - path: ./wheelhouse/*.whl - - build_wheels_manylinux: - name: Build wheels on ${{ matrix.distro }} for ${{ matrix.arch }} - runs-on: ubuntu-latest - strategy: - matrix: - distro: [manylinux2010, manylinux_2_24] - arch: [x86_64, i686] - include: - - distro: manylinux_2_24 - arch: aarch64 - - distro: manylinux_2_24 - arch: s390x - - env: - CIBW_MANYLINUX_X86_64_IMAGE: ${{ matrix.distro }} - CIBW_MANYLINUX_I686_IMAGE: ${{ matrix.distro }} - CIBW_MANYLINUX_AARCH64_IMAGE: ${{ matrix.distro }} - CIBW_MANYLINUX_S390X_IMAGE: ${{ matrix.distro }} - CIBW_BUILD: cp3*-manylinux* - CIBW_ARCHS: ${{matrix.arch}} - - steps: - - uses: actions/checkout@v2 - with: - submodules: recursive - - - name: Set up QEMU - if: ${{ matrix.arch != 'x86_64' && matrix.arch != 'i686' }} - uses: docker/setup-qemu-action@v1 - - - uses: actions/setup-python@v2 - name: Install Python - with: - python-version: '3.10' - - - name: Build wheels - uses: pypa/cibuildwheel@v2.2.2 - - - uses: actions/upload-artifact@v2 - with: - path: ./wheelhouse/*.whl - - build_wheels_musllinux: - name: Build wheels on musllinux_1_1 for ${{ matrix.arch }} - runs-on: ubuntu-latest - strategy: - matrix: - arch: [x86_64, i686, aarch64, s390x] - - env: - CIBW_MUSLLINUX_X86_64_IMAGE: musllinux_1_1 - CIBW_MUSLLINUX_I686_IMAGE: musllinux_1_1 - CIBW_MUSLLINUX_AARCH64_IMAGE: musllinux_1_1 - CIBW_MUSLLINUX_S390X_IMAGE: musllinux_1_1 - CIBW_BUILD: cp3*-musllinux* - CIBW_ARCHS: ${{matrix.arch}} - - steps: - - uses: actions/checkout@v2 - with: - submodules: recursive - - - name: Set up QEMU - if: ${{ matrix.arch != 'x86_64' && matrix.arch != 'i686' }} - uses: docker/setup-qemu-action@v1 - - - uses: actions/setup-python@v2 - name: Install Python - with: - python-version: '3.10' - - - name: Build wheels - uses: pypa/cibuildwheel@v2.2.2 - - - uses: actions/upload-artifact@v2 - with: - path: ./wheelhouse/*.whl - - build_sdist: - name: Build source distribution - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - with: - submodules: recursive - - - uses: actions/setup-python@v2 - name: Install Python - with: - python-version: '3.10' - - - name: Build sdist - run: python setup.py sdist - - - uses: actions/upload-artifact@v2 - with: - path: dist/*.tar.gz - - upload_pypi: - needs: [build_wheels_windows, build_wheels_mac, build_wheels_manylinux, build_wheels_musllinux, build_sdist] - runs-on: ubuntu-latest - - #if: github.event_name == 'release' && github.event.action == 'published' - - steps: - - uses: actions/download-artifact@v2 - with: - name: artifact - path: dist - - - uses: pypa/gh-action-pypi-publish@v1.4.2 - with: - user: __token__ - password: ${{ secrets.pypi_password }} - # password: ${{ secrets.testpypi_password }} - # repository_url: https://test.pypi.org/legacy/ +name: Build and upload to PyPI + +on: + workflow_dispatch: + release: + types: [published] + +env: + CIBW_BUILD: cp3* + CIBW_SKIP: cp38-* + CIBW_TEST_REQUIRES: pytest + CIBW_TEST_COMMAND: pytest {project}/test/PyGLM_test.py -v + +jobs: + build_wheels_windows: + name: Build wheels on Windows (${{ matrix.arch }}) + runs-on: windows-latest + strategy: + matrix: + arch: [AMD64, ARM64] + + env: + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-win-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_mac: + name: Build wheels on MacOS (${{ matrix.arch }}) + runs-on: macos-latest + strategy: + matrix: + arch: [x86_64, arm64] + + env: + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-mac-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_manylinux: + name: Build wheels on ${{ matrix.distro }} for ${{ matrix.arch }} + runs-on: ubuntu-latest + strategy: + matrix: + distro: [manylinux2014, manylinux_2_34] + arch: [x86_64] + + env: + CIBW_MANYLINUX_X86_64_IMAGE: ${{ matrix.distro }} + CIBW_MANYLINUX_I686_IMAGE: ${{ matrix.distro }} + CIBW_MANYLINUX_S390X_IMAGE: ${{ matrix.distro }} + CIBW_BUILD: cp3*-manylinux* + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up QEMU + if: ${{ matrix.arch != 'x86_64' }} + uses: docker/setup-qemu-action@v3 + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-${{ matrix.distro }}-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_manylinux_arm: + name: Build wheels on ${{ matrix.distro }} for ${{ matrix.arch }} + runs-on: ubuntu-24.04-arm + strategy: + matrix: + distro: [manylinux2014, manylinux_2_34] + arch: [aarch64] + #include: + # - distro: manylinux_2_31 + # arch: armv7l + + + env: + CIBW_MANYLINUX_AARCH64_IMAGE: ${{ matrix.distro }} + CIBW_MANYLINUX_ARMV7L_IMAGE: ${{ matrix.distro }} + CIBW_BUILD: cp3*-manylinux* + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-${{ matrix.distro }}-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_musllinux: + name: Build wheels on musllinux_1_2 for ${{ matrix.arch }} + runs-on: ubuntu-latest + strategy: + matrix: + arch: [x86_64] + + env: + CIBW_MUSLLINUX_X86_64_IMAGE: musllinux_1_2 + CIBW_MUSLLINUX_I686_IMAGE: musllinux_1_2 + CIBW_MUSLLINUX_S390X_IMAGE: musllinux_1_2 + CIBW_BUILD: cp3*-musllinux* + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up QEMU + if: ${{ matrix.arch != 'x86_64' }} + uses: docker/setup-qemu-action@v3 + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-musllinux-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_wheels_musllinux_arm: + name: Build wheels on musllinux_1_2 for ${{ matrix.arch }} + runs-on: ubuntu-24.04-arm + strategy: + matrix: + arch: [aarch64] + + env: + CIBW_MUSLLINUX_AARCH64_IMAGE: musllinux_1_2 + CIBW_BUILD: cp3*-musllinux* + CIBW_ARCHS: ${{matrix.arch}} + + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==3.3.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + + - uses: actions/upload-artifact@v5 + with: + name: artifact-musllinux-${{matrix.arch}} + path: ./wheelhouse/*.whl + + build_sdist: + name: Build source distribution + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + name: Install Python + with: + python-version: '3.14' + + - name: Install build + run: pip install build + + - name: Build sdist + run: python -m build --sdist + + - uses: actions/upload-artifact@v5 + with: + name: artifact-source + path: dist/*.tar.gz + + upload_pypi: + needs: [build_wheels_windows, build_wheels_mac, build_wheels_manylinux, build_wheels_manylinux_arm, build_wheels_musllinux, build_wheels_musllinux_arm, build_sdist] + runs-on: ubuntu-latest + + #if: github.event_name == 'release' && github.event.action == 'published' + + steps: + - uses: actions/download-artifact@v6 + with: + pattern: artifact-* + merge-multiple: true + path: dist + + - uses: pypa/gh-action-pypi-publish@v1.13.0 + with: + user: __token__ + password: ${{ secrets.pypi_password }} + # password: ${{ secrets.testpypi_password }} + # repository_url: https://test.pypi.org/legacy/ diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index bdc2ddd4..3eccb965 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,35 +1,38 @@ -# This is a basic workflow to help you get started with Actions - -name: Test PyGLM on various systems and Python versions - -# Controls when the workflow will run -on: [push, pull_request, workflow_dispatch] - -# A workflow run is made up of one or more jobs that can run sequentially or in parallel -jobs: - test-build: - # The type of runner that the job will run on - runs-on: ${{ matrix.os }} - strategy: - matrix: - os: [ubuntu-latest, macos-latest, windows-latest] - python-version: ["3.6", "3.7", "3.8", "3.9", "3.10"] - - # Steps represent a sequence of tasks that will be executed as part of the job - steps: - - uses: actions/checkout@v2 - with: - submodules: recursive - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - name: Build PyGLM - run: python setup.py install - - name: Install pytest - run: | - python -m pip install pip --upgrade - pip install pytest - - name: Test with pytest - run: pytest test/PyGLM_test.py -v - +# This is a basic workflow to help you get started with Actions + +name: Test PyGLM on various systems and Python versions + +# Controls when the workflow will run +on: [push, pull_request, workflow_dispatch] + +# A workflow run is made up of one or more jobs that can run sequentially or in parallel +jobs: + test-build: + # The type of runner that the job will run on + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"] + + # Steps represent a sequence of tasks that will be executed as part of the job + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v6 + with: + python-version: ${{ matrix.python-version }} + - name: Install pip, build and pytest + run: | + python -m pip install pip --upgrade + pip install pytest + pip install build + - name: Build PyGLM + run: python -m build + - name: Install PyGLM + run: python -c "import os, glob, subprocess; wheels = glob.glob('dist/*.whl'); subprocess.check_call(['pip', 'install', wheels[0]])" + - name: Test with pytest + run: pytest test/PyGLM_test.py -v + diff --git a/.gitignore b/.gitignore index 7f6a72e7..daae7453 100644 --- a/.gitignore +++ b/.gitignore @@ -2,20 +2,5 @@ build/ dist/ PyGLM.egg-info/ -PyGLM test/ -PyGLM build/ -pyvers/ -tests/ -glm_old/ -.pypirc -build.bat -build 32.bat -DevToolsx64.lnk -upload.bat -runreadmelang.bat -readmelang.py *.pyc -gen_macro_function.py -expand.py *.pyd -*.bat diff --git a/.gitmodules b/.gitmodules index ee16f331..2df25807 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,4 +1,4 @@ [submodule "glm"] - path = glm + path = PyGLM_lib/glm url = https://github.com/Zuzu-Typ/glm branch = PyGLM diff --git a/COPYING b/COPYING index efd6cc5e..a2f58b19 100644 --- a/COPYING +++ b/COPYING @@ -28,6 +28,34 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +================================================================================ +pyglm-typing by esoma +-------------------------------------------------------------------------------- +This project includes pyglm-typing, which is licensed under + +================================================================================ +The MIT License +-------------------------------------------------------------------------------- +Copyright 2021 Erik Soma + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + ================================================================================ PyGLM -------------------------------------------------------------------------------- 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/MANIFEST.in b/MANIFEST.in index cf446ead..79aee409 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -3,8 +3,7 @@ include COPYING include README.md include setup.py include setup.cfg -include build_options.h -include version.h -include license.h -recursive-include PyGLM * -recursive-include glm * \ No newline at end of file +include VERSION +include glm/py.typed +recursive-include pyglm-stubs * +recursive-include PyGLM_lib * diff --git a/PyGLM/functions/detail/func_geometric.h b/PyGLM/functions/detail/func_geometric.h deleted file mode 100644 index 5e980501..00000000 --- a/PyGLM/functions/detail/func_geometric.h +++ /dev/null @@ -1,121 +0,0 @@ -#pragma once - -#include "../../compiler_setup.h" - -#include "../../types/all.h" - -#include "../../internal_functions/all.h" - -#include "../function_generator_macros.h" - - -PyDoc_STRVAR(length_docstr, - "length(x: float) -> float\n" - " Returns the length of `x`, i.e., `abs(x)`.\n" - "length(x: vecN) -> float\n" - " Returns the length of `x`, i.e., `sqrt(x * x)`.\n" - "length(x: quat) -> float\n" - " Returns the norm of a quaternion." -); -PyGLM_MAKE_GLM_FUNC_N_V_Q__tfF(length) - -PyDoc_STRVAR(distance_docstr, - "distance(p0: float, p1: float) -> float\n" - " Returns the distance between `p0` and `p1`, i.e., `length(p0 - p1)`.\n" - "distance(p0: vecN, p1: vecN) -> float\n" - " Returns the distance between `p0` and `p1`, i.e., `length(p0 - p1)`." -); -PyGLM_MAKE_GLM_FUNC_NN_VV__tfF(distance) - -PyDoc_STRVAR(dot_docstr, - "dot(x: float, y: float) -> float\n" - " Returns the dot product of `x` and `y`, i.e., `result = x * y`.\n" - "dot(x: vecN, y: vecN) -> float\n" - " Returns the dot product of `x` and `y`, i.e., `result = x[0] * y[0] + x[1] * y[1] + ...`\n" - "dot(x: quat, y: quat) -> float\n" - " Returns dot product of `x` and `y`, i.e., `x[0] * y[0] + x[1] * y[1] + ...`" -); -PyGLM_MAKE_GLM_FUNC_NN_VV_QQ__tfF(dot) - -PyDoc_STRVAR(cross_docstr, - "cross(x: vec3, y: vec3) -> vec3\n" - " Returns the cross product of `x` and `y`.\n" - "cross(x: quat, y: quat) -> quat\n" - " Compute a cross product." -); -static PyObject* -cross_(PyObject*, PyObject* args) { - PyObject *arg1, *arg2; - PyGLM_Arg_Unpack_2O(args, "cross", arg1, arg2); - PyGLM_PTI_Init0(arg1, PyGLM_T_VEC | PyGLM_T_QUA | PyGLM_SHAPE_3 | PyGLM_DT_FD); - PyGLM_PTI_Init1(arg2, PyGLM_T_VEC | PyGLM_T_QUA | PyGLM_SHAPE_3 | PyGLM_DT_FD); - if (PyGLM_Vec_PTI_Check0(3, float, arg1) && PyGLM_Vec_PTI_Check1(3, float, arg2)) { - glm::vec<3, float> o = PyGLM_Vec_PTI_Get0(3, float, arg1); - glm::vec<3, float> o2 = PyGLM_Vec_PTI_Get1(3, float, arg2); - return pack(glm::cross(o, o2)); - } - if (PyGLM_Vec_PTI_Check0(3, double, arg1) && PyGLM_Vec_PTI_Check1(3, double, arg2)) { - glm::vec<3, double> o = PyGLM_Vec_PTI_Get0(3, double, arg1); - glm::vec<3, double> o2 = PyGLM_Vec_PTI_Get1(3, double, arg2); - return pack(glm::cross(o, o2)); - } - if (PyGLM_Qua_PTI_Check0(float, arg1) && PyGLM_Qua_PTI_Check1(float, arg2)) { - glm::qua o = PyGLM_Qua_PTI_Get0(float, arg1); - glm::qua o2 = PyGLM_Qua_PTI_Get1(float, arg2); - return pack(glm::cross(o, o2)); - } - if (PyGLM_Qua_PTI_Check0(double, arg1) && PyGLM_Qua_PTI_Check1(double, arg2)) { - glm::qua o = PyGLM_Qua_PTI_Get0(double, arg1); - glm::qua o2 = PyGLM_Qua_PTI_Get1(double, arg2); - return pack(glm::cross(o, o2)); - } - PyGLM_TYPEERROR_2O("invalid argument type(s) for cross(): ", arg1, arg2); - return NULL; -} - -PyDoc_STRVAR(normalize_docstr, - "normalize(x: vecN) -> vecN\n" - " Returns a vector in the same direction as `x` but with length of `1`.\n" - "normalize(x: quat) -> quat\n" - " Returns the normalized quaternion." -); -PyGLM_MAKE_GLM_FUNC_V_Q__tfF(normalize) - -PyDoc_STRVAR(faceforward_docstr, - "faceforward(N: float, I: float, Nref: float) -> float\n" - " If `dot(Nref, I) < 0.0`, return `N`, otherwise, return `-N`.\n" - "faceforward(N: vecN, I: vecN, Nref: vecN) -> vecN\n" - " For every index `i`:\n" - " If `dot(Nref[i], I[i]) < 0.0`, return `N[i]`, otherwise, return `-N[i]`." -); -PyGLM_MAKE_GLM_FUNC_NNN_VVV__tfF(faceforward) - -PyDoc_STRVAR(reflect_docstr, - "reflect(I: float, N: float) -> float\n" - " For the incident vector `I` and surface orientation `N`, returns the reflection direction:\n" - " `result = I - 2.0 * dot(N, I) * N`.\n" - "reflect(I: vecN, N: vecN) -> vecN\n" - " For the incident vector `I` and surface orientation `N`, returns the reflection direction:\n" - " `result = I - 2.0 * dot(N, I) * N`." -); -PyGLM_MAKE_GLM_FUNC_NN_VV__tfF(reflect) - -PyDoc_STRVAR(refract_docstr, - "refract(I: float, N: float, eta: float) -> float\n" - " For the incident vector `I` and surface normal `N`, and the ratio of indices of refraction `eta`,\n" - " return the refraction vector.\n" - "refract(I: vecN, N: vecN, eta: float) -> vecN\n" - " For the incident vector `I` and surface normal `N`, and the ratio of indices of refraction `eta`,\n" - " return the refraction vector." -); -PyGLM_MAKE_GLM_FUNC_NNN_VVN__tfF(refract) - -#define FUNC_GEOMETRIC_METHODS \ -{ "length", (PyCFunction)length_, METH_O, length_docstr }, \ -{ "distance", (PyCFunction)distance_, METH_VARARGS, distance_docstr }, \ -{ "dot", (PyCFunction)dot_, METH_VARARGS, dot_docstr }, \ -{ "cross", (PyCFunction)cross_, METH_VARARGS, cross_docstr }, \ -{ "normalize", (PyCFunction)normalize_, METH_O, normalize_docstr }, \ -{ "faceforward", (PyCFunction)faceforward_, METH_VARARGS, faceforward_docstr }, \ -{ "reflect", (PyCFunction)reflect_, METH_VARARGS, reflect_docstr }, \ -{ "refract", (PyCFunction)refract_, METH_VARARGS, refract_docstr } diff --git a/PyGLM/internal_functions/version_info.h b/PyGLM/internal_functions/version_info.h deleted file mode 100644 index 9a682ef9..00000000 --- a/PyGLM/internal_functions/version_info.h +++ /dev/null @@ -1,6 +0,0 @@ -#pragma once - -#include "../compiler_setup.h" - -PyObject* PyGLM_VERSION_STRING = NULL; -PyObject* PyGLM_LICENSE_STRING = NULL; \ No newline at end of file diff --git a/PyGLM.cpp b/PyGLM_lib/PyGLM.cpp similarity index 99% rename from PyGLM.cpp rename to PyGLM_lib/PyGLM.cpp index 438da693..68088a9e 100644 --- a/PyGLM.cpp +++ b/PyGLM_lib/PyGLM.cpp @@ -141,6 +141,8 @@ static PyMethodDef glmmethods[] = { TERNARY_METHODS, // PyGLM functions + CUSTOM_METHODS, + { "silence", (PyCFunction)silence, METH_O, silence_docstr }, //{ "_get_type_info", (PyCFunction)_get_type_info, METH_VARARGS, "_get_type_info(accepted_types, object) -> None\nAn internal testing funtion to check wether or not the type checking works correctly." }, #ifdef HAS_TEST @@ -856,6 +858,8 @@ extern "C" { PyGLM_LICENSE_STRING = PyUnicode_FromString(PyGLM_LICENSE); Py_INCREF(PyGLM_LICENSE_STRING); PyModule_AddObject(module_glm, "license", PyGLM_LICENSE_STRING); + + PyModule_AddStringConstant(module_glm, "__version__", PyGLM_VERSION); return module_glm; } diff --git a/PyGLM/compiler_setup.h b/PyGLM_lib/PyGLM/compiler_setup.h similarity index 100% rename from PyGLM/compiler_setup.h rename to PyGLM_lib/PyGLM/compiler_setup.h diff --git a/PyGLM/functions/all.h b/PyGLM_lib/PyGLM/functions/all.h similarity index 100% rename from PyGLM/functions/all.h rename to PyGLM_lib/PyGLM/functions/all.h diff --git a/PyGLM/functions/detail/all.h b/PyGLM_lib/PyGLM/functions/detail/all.h similarity index 100% rename from PyGLM/functions/detail/all.h rename to PyGLM_lib/PyGLM/functions/detail/all.h diff --git a/PyGLM/functions/detail/func_common.h b/PyGLM_lib/PyGLM/functions/detail/func_common.h similarity index 100% rename from PyGLM/functions/detail/func_common.h rename to PyGLM_lib/PyGLM/functions/detail/func_common.h diff --git a/PyGLM/functions/detail/func_exponential.h b/PyGLM_lib/PyGLM/functions/detail/func_exponential.h similarity index 100% rename from PyGLM/functions/detail/func_exponential.h rename to PyGLM_lib/PyGLM/functions/detail/func_exponential.h diff --git a/PyGLM_lib/PyGLM/functions/detail/func_geometric.h b/PyGLM_lib/PyGLM/functions/detail/func_geometric.h new file mode 100644 index 00000000..22fa2e35 --- /dev/null +++ b/PyGLM_lib/PyGLM/functions/detail/func_geometric.h @@ -0,0 +1,261 @@ +#pragma once + +#include "../../compiler_setup.h" + +#include "../../types/all.h" + +#include "../../internal_functions/all.h" + +#include "../function_generator_macros.h" + + +PyDoc_STRVAR(length_docstr, + "length(x: float) -> float\n" + " Returns the length of `x`, i.e., `abs(x)`.\n" + "length(x: vecN) -> float\n" + " Returns the length of `x`, i.e., `sqrt(x * x)`.\n" + "length(x: quat) -> float\n" + " Returns the norm of a quaternion." +); +PyGLM_MAKE_GLM_FUNC_N_V_Q__tfF(length) + +PyDoc_STRVAR(distance_docstr, + "distance(p0: float, p1: float) -> float\n" + " Returns the distance between `p0` and `p1`, i.e., `length(p0 - p1)`.\n" + "distance(p0: vecN, p1: vecN) -> float\n" + " Returns the distance between `p0` and `p1`, i.e., `length(p0 - p1)`." +); +PyGLM_MAKE_GLM_FUNC_NN_VV__tfF(distance) + +PyDoc_STRVAR(dot_docstr, + "dot(x: number, y: number) -> float\n" + " Returns the dot product of `x` and `y`, i.e., `result = x * y`.\n" + "dot(x: vecN, y: vecN) -> number\n" + " Returns the dot product of `x` and `y`, i.e., `result = x[0] * y[0] + x[1] * y[1] + ...`\n" + "dot(x: quat, y: quat) -> float\n" + " Returns dot product of `x` and `y`, i.e., `x[0] * y[0] + x[1] * y[1] + ...`" +); + +static PyObject* +dot_(PyObject*, PyObject* args) { + PyObject *arg1, *arg2; + PyGLM_Arg_Unpack_2O(args, "dot", arg1, arg2); + if (PyGLM_Number_Check(arg1) && PyGLM_Number_Check(arg2)) { + return pack(glm::custom::dot(PyGLM_Number_FromPyObject(arg1), PyGLM_Number_FromPyObject(arg2))); + } + PyGLM_PTI_Init0(arg1, PyGLM_T_VEC | PyGLM_T_QUA | PyGLM_SHAPE_ALL | PyGLM_DT_FD | PyGLM_DT_I); + PyGLM_PTI_Init1(arg2, PyGLM_T_VEC | PyGLM_T_QUA | PyGLM_SHAPE_ALL | PyGLM_DT_FD | PyGLM_DT_I); + if (PyGLM_PTI_IsVec(0)) { + if (PyGLM_Vec_PTI_Check0(1, float, arg1) && PyGLM_Vec_PTI_Check1(1, float, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, float, arg1), PyGLM_Vec_PTI_Get1(1, float, arg2))); + } + if (PyGLM_Vec_PTI_Check0(1, double, arg1) && PyGLM_Vec_PTI_Check1(1, double, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, double, arg1), PyGLM_Vec_PTI_Get1(1, double, arg2))); + } + if (PyGLM_Vec_PTI_Check0(1, int32, arg1) && PyGLM_Vec_PTI_Check1(1, int32, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, int32, arg1), PyGLM_Vec_PTI_Get1(1, int32, arg2))); + } + if (PyGLM_Vec_PTI_Check0(1, uint32, arg1) && PyGLM_Vec_PTI_Check1(1, uint32, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, uint32, arg1), PyGLM_Vec_PTI_Get1(1, uint32, arg2))); + } + if (PyGLM_Vec_PTI_Check0(1, int64, arg1) && PyGLM_Vec_PTI_Check1(1, int64, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, int64, arg1), PyGLM_Vec_PTI_Get1(1, int64, arg2))); + } + if (PyGLM_Vec_PTI_Check0(1, uint64, arg1) && PyGLM_Vec_PTI_Check1(1, uint64, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, uint64, arg1), PyGLM_Vec_PTI_Get1(1, uint64, arg2))); + } + if (PyGLM_Vec_PTI_Check0(1, int16, arg1) && PyGLM_Vec_PTI_Check1(1, int16, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, int16, arg1), PyGLM_Vec_PTI_Get1(1, int16, arg2))); + } + if (PyGLM_Vec_PTI_Check0(1, uint16, arg1) && PyGLM_Vec_PTI_Check1(1, uint16, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, uint16, arg1), PyGLM_Vec_PTI_Get1(1, uint16, arg2))); + } + if (PyGLM_Vec_PTI_Check0(1, int8, arg1) && PyGLM_Vec_PTI_Check1(1, int8, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, int8, arg1), PyGLM_Vec_PTI_Get1(1, int8, arg2))); + } + if (PyGLM_Vec_PTI_Check0(1, uint8, arg1) && PyGLM_Vec_PTI_Check1(1, uint8, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, uint8, arg1), PyGLM_Vec_PTI_Get1(1, uint8, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, float, arg1) && PyGLM_Vec_PTI_Check1(2, float, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, float, arg1), PyGLM_Vec_PTI_Get1(2, float, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, double, arg1) && PyGLM_Vec_PTI_Check1(2, double, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, double, arg1), PyGLM_Vec_PTI_Get1(2, double, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, int32, arg1) && PyGLM_Vec_PTI_Check1(2, int32, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, int32, arg1), PyGLM_Vec_PTI_Get1(2, int32, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, uint32, arg1) && PyGLM_Vec_PTI_Check1(2, uint32, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, uint32, arg1), PyGLM_Vec_PTI_Get1(2, uint32, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, int64, arg1) && PyGLM_Vec_PTI_Check1(2, int64, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, int64, arg1), PyGLM_Vec_PTI_Get1(2, int64, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, uint64, arg1) && PyGLM_Vec_PTI_Check1(2, uint64, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, uint64, arg1), PyGLM_Vec_PTI_Get1(2, uint64, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, int16, arg1) && PyGLM_Vec_PTI_Check1(2, int16, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, int16, arg1), PyGLM_Vec_PTI_Get1(2, int16, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, uint16, arg1) && PyGLM_Vec_PTI_Check1(2, uint16, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, uint16, arg1), PyGLM_Vec_PTI_Get1(2, uint16, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, int8, arg1) && PyGLM_Vec_PTI_Check1(2, int8, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, int8, arg1), PyGLM_Vec_PTI_Get1(2, int8, arg2))); + } + if (PyGLM_Vec_PTI_Check0(2, uint8, arg1) && PyGLM_Vec_PTI_Check1(2, uint8, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, uint8, arg1), PyGLM_Vec_PTI_Get1(2, uint8, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, float, arg1) && PyGLM_Vec_PTI_Check1(3, float, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, float, arg1), PyGLM_Vec_PTI_Get1(3, float, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, double, arg1) && PyGLM_Vec_PTI_Check1(3, double, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, double, arg1), PyGLM_Vec_PTI_Get1(3, double, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, int32, arg1) && PyGLM_Vec_PTI_Check1(3, int32, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, int32, arg1), PyGLM_Vec_PTI_Get1(3, int32, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, uint32, arg1) && PyGLM_Vec_PTI_Check1(3, uint32, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, uint32, arg1), PyGLM_Vec_PTI_Get1(3, uint32, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, int64, arg1) && PyGLM_Vec_PTI_Check1(3, int64, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, int64, arg1), PyGLM_Vec_PTI_Get1(3, int64, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, uint64, arg1) && PyGLM_Vec_PTI_Check1(3, uint64, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, uint64, arg1), PyGLM_Vec_PTI_Get1(3, uint64, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, int16, arg1) && PyGLM_Vec_PTI_Check1(3, int16, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, int16, arg1), PyGLM_Vec_PTI_Get1(3, int16, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, uint16, arg1) && PyGLM_Vec_PTI_Check1(3, uint16, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, uint16, arg1), PyGLM_Vec_PTI_Get1(3, uint16, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, int8, arg1) && PyGLM_Vec_PTI_Check1(3, int8, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, int8, arg1), PyGLM_Vec_PTI_Get1(3, int8, arg2))); + } + if (PyGLM_Vec_PTI_Check0(3, uint8, arg1) && PyGLM_Vec_PTI_Check1(3, uint8, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, uint8, arg1), PyGLM_Vec_PTI_Get1(3, uint8, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, float, arg1) && PyGLM_Vec_PTI_Check1(4, float, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, float, arg1), PyGLM_Vec_PTI_Get1(4, float, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, double, arg1) && PyGLM_Vec_PTI_Check1(4, double, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, double, arg1), PyGLM_Vec_PTI_Get1(4, double, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, int32, arg1) && PyGLM_Vec_PTI_Check1(4, int32, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, int32, arg1), PyGLM_Vec_PTI_Get1(4, int32, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, uint32, arg1) && PyGLM_Vec_PTI_Check1(4, uint32, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, uint32, arg1), PyGLM_Vec_PTI_Get1(4, uint32, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, int64, arg1) && PyGLM_Vec_PTI_Check1(4, int64, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, int64, arg1), PyGLM_Vec_PTI_Get1(4, int64, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, uint64, arg1) && PyGLM_Vec_PTI_Check1(4, uint64, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, uint64, arg1), PyGLM_Vec_PTI_Get1(4, uint64, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, int16, arg1) && PyGLM_Vec_PTI_Check1(4, int16, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, int16, arg1), PyGLM_Vec_PTI_Get1(4, int16, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, uint16, arg1) && PyGLM_Vec_PTI_Check1(4, uint16, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, uint16, arg1), PyGLM_Vec_PTI_Get1(4, uint16, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, int8, arg1) && PyGLM_Vec_PTI_Check1(4, int8, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, int8, arg1), PyGLM_Vec_PTI_Get1(4, int8, arg2))); + } + if (PyGLM_Vec_PTI_Check0(4, uint8, arg1) && PyGLM_Vec_PTI_Check1(4, uint8, arg2)) { + return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, uint8, arg1), PyGLM_Vec_PTI_Get1(4, uint8, arg2))); + } + } + if (PyGLM_Qua_PTI_Check0(float, arg1) && PyGLM_Qua_PTI_Check1(float, arg2)) { + return pack(glm::custom::dot(PyGLM_Qua_PTI_Get0(float, arg1), PyGLM_Qua_PTI_Get1(float, arg2))); + } + if (PyGLM_Qua_PTI_Check0(double, arg1) && PyGLM_Qua_PTI_Check1(double, arg2)) { + return pack(glm::custom::dot(PyGLM_Qua_PTI_Get0(double, arg1), PyGLM_Qua_PTI_Get1(double, arg2))); + } + PyGLM_TYPEERROR_2O("invalid argument type(s) for dot(): ", arg1, arg2); + return NULL; +} + +PyDoc_STRVAR(cross_docstr, + "cross(x: vec3, y: vec3) -> vec3\n" + " Returns the cross product of `x` and `y`.\n" + "cross(x: quat, y: quat) -> quat\n" + " Compute a cross product." +); +static PyObject* +cross_(PyObject*, PyObject* args) { + PyObject *arg1, *arg2; + PyGLM_Arg_Unpack_2O(args, "cross", arg1, arg2); + PyGLM_PTI_Init0(arg1, PyGLM_T_VEC | PyGLM_T_QUA | PyGLM_SHAPE_3 | PyGLM_DT_FD); + PyGLM_PTI_Init1(arg2, PyGLM_T_VEC | PyGLM_T_QUA | PyGLM_SHAPE_3 | PyGLM_DT_FD); + if (PyGLM_Vec_PTI_Check0(3, float, arg1) && PyGLM_Vec_PTI_Check1(3, float, arg2)) { + glm::vec<3, float> o = PyGLM_Vec_PTI_Get0(3, float, arg1); + glm::vec<3, float> o2 = PyGLM_Vec_PTI_Get1(3, float, arg2); + return pack(glm::cross(o, o2)); + } + if (PyGLM_Vec_PTI_Check0(3, double, arg1) && PyGLM_Vec_PTI_Check1(3, double, arg2)) { + glm::vec<3, double> o = PyGLM_Vec_PTI_Get0(3, double, arg1); + glm::vec<3, double> o2 = PyGLM_Vec_PTI_Get1(3, double, arg2); + return pack(glm::cross(o, o2)); + } + if (PyGLM_Qua_PTI_Check0(float, arg1) && PyGLM_Qua_PTI_Check1(float, arg2)) { + glm::qua o = PyGLM_Qua_PTI_Get0(float, arg1); + glm::qua o2 = PyGLM_Qua_PTI_Get1(float, arg2); + return pack(glm::cross(o, o2)); + } + if (PyGLM_Qua_PTI_Check0(double, arg1) && PyGLM_Qua_PTI_Check1(double, arg2)) { + glm::qua o = PyGLM_Qua_PTI_Get0(double, arg1); + glm::qua o2 = PyGLM_Qua_PTI_Get1(double, arg2); + return pack(glm::cross(o, o2)); + } + PyGLM_TYPEERROR_2O("invalid argument type(s) for cross(): ", arg1, arg2); + return NULL; +} + +PyDoc_STRVAR(normalize_docstr, + "normalize(x: vecN) -> vecN\n" + " Returns a vector in the same direction as `x` but with length of `1`.\n" + "normalize(x: quat) -> quat\n" + " Returns the normalized quaternion." +); +PyGLM_MAKE_GLM_FUNC_V_Q__tfF(normalize) + +PyDoc_STRVAR(faceforward_docstr, + "faceforward(N: float, I: float, Nref: float) -> float\n" + " If `dot(Nref, I) < 0.0`, return `N`, otherwise, return `-N`.\n" + "faceforward(N: vecN, I: vecN, Nref: vecN) -> vecN\n" + " For every index `i`:\n" + " If `dot(Nref[i], I[i]) < 0.0`, return `N[i]`, otherwise, return `-N[i]`." +); +PyGLM_MAKE_GLM_FUNC_NNN_VVV__tfF(faceforward) + +PyDoc_STRVAR(reflect_docstr, + "reflect(I: float, N: float) -> float\n" + " For the incident vector `I` and surface orientation `N`, returns the reflection direction:\n" + " `result = I - 2.0 * dot(N, I) * N`.\n" + "reflect(I: vecN, N: vecN) -> vecN\n" + " For the incident vector `I` and surface orientation `N`, returns the reflection direction:\n" + " `result = I - 2.0 * dot(N, I) * N`." +); +PyGLM_MAKE_GLM_FUNC_NN_VV__tfF(reflect) + +PyDoc_STRVAR(refract_docstr, + "refract(I: float, N: float, eta: float) -> float\n" + " For the incident vector `I` and surface normal `N`, and the ratio of indices of refraction `eta`,\n" + " return the refraction vector.\n" + "refract(I: vecN, N: vecN, eta: float) -> vecN\n" + " For the incident vector `I` and surface normal `N`, and the ratio of indices of refraction `eta`,\n" + " return the refraction vector." +); +PyGLM_MAKE_GLM_FUNC_NNN_VVN__tfF(refract) + +#define FUNC_GEOMETRIC_METHODS \ +{ "length", (PyCFunction)length_, METH_O, length_docstr }, \ +{ "distance", (PyCFunction)distance_, METH_VARARGS, distance_docstr }, \ +{ "dot", (PyCFunction)dot_, METH_VARARGS, dot_docstr }, \ +{ "cross", (PyCFunction)cross_, METH_VARARGS, cross_docstr }, \ +{ "normalize", (PyCFunction)normalize_, METH_O, normalize_docstr }, \ +{ "faceforward", (PyCFunction)faceforward_, METH_VARARGS, faceforward_docstr }, \ +{ "reflect", (PyCFunction)reflect_, METH_VARARGS, reflect_docstr }, \ +{ "refract", (PyCFunction)refract_, METH_VARARGS, refract_docstr } diff --git a/PyGLM/functions/detail/func_integer.h b/PyGLM_lib/PyGLM/functions/detail/func_integer.h similarity index 100% rename from PyGLM/functions/detail/func_integer.h rename to PyGLM_lib/PyGLM/functions/detail/func_integer.h diff --git a/PyGLM/functions/detail/func_matrix.h b/PyGLM_lib/PyGLM/functions/detail/func_matrix.h similarity index 100% rename from PyGLM/functions/detail/func_matrix.h rename to PyGLM_lib/PyGLM/functions/detail/func_matrix.h diff --git a/PyGLM/functions/detail/func_packing.h b/PyGLM_lib/PyGLM/functions/detail/func_packing.h similarity index 100% rename from PyGLM/functions/detail/func_packing.h rename to PyGLM_lib/PyGLM/functions/detail/func_packing.h diff --git a/PyGLM/functions/detail/func_trigonometric.h b/PyGLM_lib/PyGLM/functions/detail/func_trigonometric.h similarity index 100% rename from PyGLM/functions/detail/func_trigonometric.h rename to PyGLM_lib/PyGLM/functions/detail/func_trigonometric.h diff --git a/PyGLM/functions/detail/func_vector_relational.h b/PyGLM_lib/PyGLM/functions/detail/func_vector_relational.h similarity index 100% rename from PyGLM/functions/detail/func_vector_relational.h rename to PyGLM_lib/PyGLM/functions/detail/func_vector_relational.h diff --git a/PyGLM/functions/function_generator_macros.h b/PyGLM_lib/PyGLM/functions/function_generator_macros.h similarity index 100% rename from PyGLM/functions/function_generator_macros.h rename to PyGLM_lib/PyGLM/functions/function_generator_macros.h diff --git a/PyGLM/functions/other/all.h b/PyGLM_lib/PyGLM/functions/other/all.h similarity index 78% rename from PyGLM/functions/other/all.h rename to PyGLM_lib/PyGLM/functions/other/all.h index 8a342a87..5d9af29a 100644 --- a/PyGLM/functions/other/all.h +++ b/PyGLM_lib/PyGLM/functions/other/all.h @@ -5,3 +5,5 @@ #include "binary.h" #include "ternary.h" + +#include "custom.h" diff --git a/PyGLM/functions/other/binary.h b/PyGLM_lib/PyGLM/functions/other/binary.h similarity index 100% rename from PyGLM/functions/other/binary.h rename to PyGLM_lib/PyGLM/functions/other/binary.h diff --git a/PyGLM_lib/PyGLM/functions/other/custom.h b/PyGLM_lib/PyGLM/functions/other/custom.h new file mode 100644 index 00000000..2d7f15fb --- /dev/null +++ b/PyGLM_lib/PyGLM/functions/other/custom.h @@ -0,0 +1,48 @@ +#pragma once + +#include "../../compiler_setup.h" +#include "../../internal_functions/all.h" + +PyDoc_STRVAR(quat_to_vec4_docstr, + "quat_to_vec4(quat) -> vec4\n" + " Component wise conversion of quat to vec4." +); +static PyObject* +quat_to_vec4_(PyObject*, PyObject* arg) { + if (Py_TYPE(arg) == PyGLM_QUA_TYPE()) { + glm::qua q = unpack_qua(arg); + return pack(glm::vec<4, float>(q.x, q.y, q.z, q.w)); + } + + if (Py_TYPE(arg) == PyGLM_QUA_TYPE()) { + glm::qua q = unpack_qua(arg); + return pack(glm::vec<4, double>(q.x, q.y, q.z, q.w)); + } + + PyGLM_TYPEERROR_O("Invalid argument type for 'quat_to_vec4'. Expected 'quat', got ", arg); + return NULL; +} + +PyDoc_STRVAR(vec4_to_quat_docstr, + "vec4_to_quat(vec4) -> quat\n" + " Component wise conversion of vec4 to quat." +); +static PyObject* +vec4_to_quat_(PyObject*, PyObject* arg) { + if (Py_TYPE(arg) == PyGLM_VEC_TYPE<4, float>()) { + glm::vec<4, float> v = unpack_vec<4, float>(arg); + return pack(glm::qua(v.w, v.x, v.y, v.z)); + } + + if (Py_TYPE(arg) == PyGLM_VEC_TYPE<4, double>()) { + glm::vec<4, double> v = unpack_vec<4, double>(arg); + return pack(glm::qua(v.w, v.x, v.y, v.z)); + } + + PyGLM_TYPEERROR_O("Invalid argument type for 'vec4_to_quat'. Expected 'vec4', got ", arg); + return NULL; +} + +#define CUSTOM_METHODS \ +{ "quat_to_vec4", (PyCFunction)quat_to_vec4_, METH_O, quat_to_vec4_docstr }, \ +{ "vec4_to_quat", (PyCFunction)vec4_to_quat_, METH_O, vec4_to_quat_docstr } diff --git a/PyGLM/functions/other/ternary.h b/PyGLM_lib/PyGLM/functions/other/ternary.h similarity index 100% rename from PyGLM/functions/other/ternary.h rename to PyGLM_lib/PyGLM/functions/other/ternary.h diff --git a/PyGLM/functions/other/unary.h b/PyGLM_lib/PyGLM/functions/other/unary.h similarity index 100% rename from PyGLM/functions/other/unary.h rename to PyGLM_lib/PyGLM/functions/other/unary.h diff --git a/PyGLM/functions/stable_extensions/all.h b/PyGLM_lib/PyGLM/functions/stable_extensions/all.h similarity index 100% rename from PyGLM/functions/stable_extensions/all.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/all.h diff --git a/PyGLM/functions/stable_extensions/color_space.h b/PyGLM_lib/PyGLM/functions/stable_extensions/color_space.h similarity index 100% rename from PyGLM/functions/stable_extensions/color_space.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/color_space.h diff --git a/PyGLM/functions/stable_extensions/constants.h b/PyGLM_lib/PyGLM/functions/stable_extensions/constants.h similarity index 100% rename from PyGLM/functions/stable_extensions/constants.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/constants.h diff --git a/PyGLM/functions/stable_extensions/epsilon.h b/PyGLM_lib/PyGLM/functions/stable_extensions/epsilon.h similarity index 100% rename from PyGLM/functions/stable_extensions/epsilon.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/epsilon.h diff --git a/PyGLM/functions/stable_extensions/integer.h b/PyGLM_lib/PyGLM/functions/stable_extensions/integer.h similarity index 100% rename from PyGLM/functions/stable_extensions/integer.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/integer.h diff --git a/PyGLM/functions/stable_extensions/matrix_access.h b/PyGLM_lib/PyGLM/functions/stable_extensions/matrix_access.h similarity index 100% rename from PyGLM/functions/stable_extensions/matrix_access.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/matrix_access.h diff --git a/PyGLM/functions/stable_extensions/matrix_clip_space.h b/PyGLM_lib/PyGLM/functions/stable_extensions/matrix_clip_space.h similarity index 100% rename from PyGLM/functions/stable_extensions/matrix_clip_space.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/matrix_clip_space.h diff --git a/PyGLM/functions/stable_extensions/matrix_inverse.h b/PyGLM_lib/PyGLM/functions/stable_extensions/matrix_inverse.h similarity index 100% rename from PyGLM/functions/stable_extensions/matrix_inverse.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/matrix_inverse.h diff --git a/PyGLM/functions/stable_extensions/matrix_projection.h b/PyGLM_lib/PyGLM/functions/stable_extensions/matrix_projection.h similarity index 100% rename from PyGLM/functions/stable_extensions/matrix_projection.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/matrix_projection.h diff --git a/PyGLM/functions/stable_extensions/matrix_transform.h b/PyGLM_lib/PyGLM/functions/stable_extensions/matrix_transform.h similarity index 98% rename from PyGLM/functions/stable_extensions/matrix_transform.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/matrix_transform.h index 11a264f3..474106de 100644 --- a/PyGLM/functions/stable_extensions/matrix_transform.h +++ b/PyGLM_lib/PyGLM/functions/stable_extensions/matrix_transform.h @@ -156,6 +156,7 @@ translate_(PyObject*, PyObject* args) { if (PyGLM_Vec_PTI_Check0(2, uint32, arg1)) { return pack(glm::translate(glm::mat<3, 3, uint32>(1), PyGLM_Vec_PTI_Get0(2, uint32, arg1))); } + PyGLM_TYPEERROR_O("invalid argument type for translate(): ", arg1); } else { PyGLM_PTI_Init0(arg1, PyGLM_T_MAT | PyGLM_SHAPE_3x3 | PyGLM_SHAPE_4x4 | PyGLM_DT_NORMAL); @@ -178,8 +179,8 @@ translate_(PyObject*, PyObject* args) { if (PyGLM_Mat_PTI_Check0(3, 3, double, arg1) && PyGLM_Vec_PTI_Check1(2, double, arg2)) { return pack(glm::translate(PyGLM_Mat_PTI_Get0(3, 3, double, arg1), PyGLM_Vec_PTI_Get1(2, double, arg2))); } + PyGLM_TYPEERROR_2O("invalid argument types for translate(): ", arg1, arg2); } - PyGLM_TYPEERROR_2O("invalid argument type(s) for translate(): ", arg1, arg2); return NULL; } @@ -312,6 +313,8 @@ scale_(PyObject*, PyObject* args) { if (PyGLM_Vec_PTI_Check0(2, uint32, arg1)) { return pack(glm::scale(glm::mat<3, 3, uint32>(1), PyGLM_Vec_PTI_Get0(2, uint32, arg1))); } + PyGLM_TYPEERROR_O("invalid argument type(s) for scale(): ", arg1); + return NULL; } else { PyGLM_PTI_Init0(arg1, PyGLM_T_MAT | PyGLM_SHAPE_3x3 | PyGLM_SHAPE_4x4 | PyGLM_DT_NORMAL); @@ -334,9 +337,9 @@ scale_(PyObject*, PyObject* args) { if (PyGLM_Mat_PTI_Check0(3, 3, double, arg1) && PyGLM_Vec_PTI_Check1(2, double, arg2)) { return pack(glm::scale(PyGLM_Mat_PTI_Get0(3, 3, double, arg1), PyGLM_Vec_PTI_Get1(2, double, arg2))); } + PyGLM_TYPEERROR_2O("invalid argument type(s) for scale(): ", arg1, arg2); + return NULL; } - PyGLM_TYPEERROR_2O("invalid argument type(s) for scale(): ", arg1, arg2); - return NULL; } PyGLM_MAKE_GLM_FUNC_M4V3__tfF(scale_slow) diff --git a/PyGLM/functions/stable_extensions/noise.h b/PyGLM_lib/PyGLM/functions/stable_extensions/noise.h similarity index 100% rename from PyGLM/functions/stable_extensions/noise.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/noise.h diff --git a/PyGLM/functions/stable_extensions/packing.h b/PyGLM_lib/PyGLM/functions/stable_extensions/packing.h similarity index 100% rename from PyGLM/functions/stable_extensions/packing.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/packing.h diff --git a/PyGLM/functions/stable_extensions/quaternion.h b/PyGLM_lib/PyGLM/functions/stable_extensions/quaternion.h similarity index 100% rename from PyGLM/functions/stable_extensions/quaternion.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/quaternion.h diff --git a/PyGLM/functions/stable_extensions/quaternion_common.h b/PyGLM_lib/PyGLM/functions/stable_extensions/quaternion_common.h similarity index 100% rename from PyGLM/functions/stable_extensions/quaternion_common.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/quaternion_common.h diff --git a/PyGLM/functions/stable_extensions/quaternion_trigonometric.h b/PyGLM_lib/PyGLM/functions/stable_extensions/quaternion_trigonometric.h similarity index 100% rename from PyGLM/functions/stable_extensions/quaternion_trigonometric.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/quaternion_trigonometric.h diff --git a/PyGLM/functions/stable_extensions/random.h b/PyGLM_lib/PyGLM/functions/stable_extensions/random.h similarity index 100% rename from PyGLM/functions/stable_extensions/random.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/random.h diff --git a/PyGLM/functions/stable_extensions/reciprocal.h b/PyGLM_lib/PyGLM/functions/stable_extensions/reciprocal.h similarity index 100% rename from PyGLM/functions/stable_extensions/reciprocal.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/reciprocal.h diff --git a/PyGLM/functions/stable_extensions/round.h b/PyGLM_lib/PyGLM/functions/stable_extensions/round.h similarity index 100% rename from PyGLM/functions/stable_extensions/round.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/round.h diff --git a/PyGLM/functions/stable_extensions/type_ptr.h b/PyGLM_lib/PyGLM/functions/stable_extensions/type_ptr.h similarity index 100% rename from PyGLM/functions/stable_extensions/type_ptr.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/type_ptr.h diff --git a/PyGLM/functions/stable_extensions/ulp.h b/PyGLM_lib/PyGLM/functions/stable_extensions/ulp.h similarity index 100% rename from PyGLM/functions/stable_extensions/ulp.h rename to PyGLM_lib/PyGLM/functions/stable_extensions/ulp.h diff --git a/PyGLM/functions/unstable_extensions/all.h b/PyGLM_lib/PyGLM/functions/unstable_extensions/all.h similarity index 100% rename from PyGLM/functions/unstable_extensions/all.h rename to PyGLM_lib/PyGLM/functions/unstable_extensions/all.h diff --git a/PyGLM/functions/unstable_extensions/compatibility.h b/PyGLM_lib/PyGLM/functions/unstable_extensions/compatibility.h similarity index 100% rename from PyGLM/functions/unstable_extensions/compatibility.h rename to PyGLM_lib/PyGLM/functions/unstable_extensions/compatibility.h diff --git a/PyGLM/functions/unstable_extensions/matrix_decompose.h b/PyGLM_lib/PyGLM/functions/unstable_extensions/matrix_decompose.h similarity index 100% rename from PyGLM/functions/unstable_extensions/matrix_decompose.h rename to PyGLM_lib/PyGLM/functions/unstable_extensions/matrix_decompose.h diff --git a/PyGLM/functions/unstable_extensions/matrix_transform_2d.h b/PyGLM_lib/PyGLM/functions/unstable_extensions/matrix_transform_2d.h similarity index 100% rename from PyGLM/functions/unstable_extensions/matrix_transform_2d.h rename to PyGLM_lib/PyGLM/functions/unstable_extensions/matrix_transform_2d.h diff --git a/PyGLM/functions/unstable_extensions/norm.h b/PyGLM_lib/PyGLM/functions/unstable_extensions/norm.h similarity index 100% rename from PyGLM/functions/unstable_extensions/norm.h rename to PyGLM_lib/PyGLM/functions/unstable_extensions/norm.h diff --git a/PyGLM/functions/unstable_extensions/polar_coordinates.h b/PyGLM_lib/PyGLM/functions/unstable_extensions/polar_coordinates.h similarity index 100% rename from PyGLM/functions/unstable_extensions/polar_coordinates.h rename to PyGLM_lib/PyGLM/functions/unstable_extensions/polar_coordinates.h diff --git a/PyGLM/functions/unstable_extensions/rotate_vector.h b/PyGLM_lib/PyGLM/functions/unstable_extensions/rotate_vector.h similarity index 100% rename from PyGLM/functions/unstable_extensions/rotate_vector.h rename to PyGLM_lib/PyGLM/functions/unstable_extensions/rotate_vector.h diff --git a/PyGLM/imports.h b/PyGLM_lib/PyGLM/imports.h similarity index 96% rename from PyGLM/imports.h rename to PyGLM_lib/PyGLM/imports.h index 193d8402..d889c085 100644 --- a/PyGLM/imports.h +++ b/PyGLM_lib/PyGLM/imports.h @@ -16,9 +16,12 @@ #define GLM_ENABLE_EXPERIMENTAL #define GLM_FORCE_QUAT_DATA_WXYZ +#define GLM_LANG_STL11_FORCED #include +#include "internal_functions/glm_customizations.h" + #include #include #include diff --git a/PyGLM/internal_functions/all.h b/PyGLM_lib/PyGLM/internal_functions/all.h similarity index 100% rename from PyGLM/internal_functions/all.h rename to PyGLM_lib/PyGLM/internal_functions/all.h diff --git a/PyGLM/internal_functions/ctypes_pointers.h b/PyGLM_lib/PyGLM/internal_functions/ctypes_pointers.h similarity index 66% rename from PyGLM/internal_functions/ctypes_pointers.h rename to PyGLM_lib/PyGLM/internal_functions/ctypes_pointers.h index 03f7395d..c44c4f07 100644 --- a/PyGLM/internal_functions/ctypes_pointers.h +++ b/PyGLM_lib/PyGLM/internal_functions/ctypes_pointers.h @@ -2,31 +2,31 @@ #include "../compiler_setup.h" -PyObject* ctypes_float; -PyObject* ctypes_double; -PyObject* ctypes_int64; -PyObject* ctypes_int32; -PyObject* ctypes_int16; -PyObject* ctypes_int8; -PyObject* ctypes_uint64; -PyObject* ctypes_uint32; -PyObject* ctypes_uint16; -PyObject* ctypes_uint8; -PyObject* ctypes_bool; +static PyObject* ctypes_float; +static PyObject* ctypes_double; +static PyObject* ctypes_int64; +static PyObject* ctypes_int32; +static PyObject* ctypes_int16; +static PyObject* ctypes_int8; +static PyObject* ctypes_uint64; +static PyObject* ctypes_uint32; +static PyObject* ctypes_uint16; +static PyObject* ctypes_uint8; +static PyObject* ctypes_bool; -destructor ctypes_dealloc; +static destructor ctypes_dealloc; -PyObject* ctypes_void_p = NULL; -PyObject* ctypes_cast = NULL; +static PyObject* ctypes_void_p = NULL; +static PyObject* ctypes_cast = NULL; #if defined(_M_IX86) || defined(__i386__) -PyObject* PyGLM_CtypesVoidP_FromVoidP(void* p) { +static PyObject* PyGLM_CtypesVoidP_FromVoidP(void* p) { PyObject* argList = Py_BuildValue("(K)", (unsigned long)p); PyObject* out = PyObject_CallObject(ctypes_void_p, argList); Py_DECREF(argList); return out; } -unsigned long PyGLM_UnsignedLongLong_FromCtypesP(PyObject* ptr) { +static unsigned long PyGLM_UnsignedLongLong_FromCtypesP(PyObject* ptr) { PyObject* ptr_as_c_void_p = PyObject_CallFunctionObjArgs(ctypes_cast, ptr, ctypes_void_p, NULL); PyObject* ptr_value = PyObject_GetAttrString(ptr_as_c_void_p, "value"); unsigned long out = PyLong_AsUnsignedLong(ptr_value); @@ -35,13 +35,13 @@ unsigned long PyGLM_UnsignedLongLong_FromCtypesP(PyObject* ptr) { return out; } #else -PyObject* PyGLM_CtypesVoidP_FromVoidP(void* p) { +static PyObject* PyGLM_CtypesVoidP_FromVoidP(void* p) { PyObject* argList = Py_BuildValue("(K)", (unsigned long long)p); PyObject* out = PyObject_CallObject(ctypes_void_p, argList); Py_DECREF(argList); return out; } -unsigned long long PyGLM_UnsignedLongLong_FromCtypesP(PyObject* ptr) { +static unsigned long long PyGLM_UnsignedLongLong_FromCtypesP(PyObject* ptr) { PyObject* ptr_as_c_void_p = PyObject_CallFunctionObjArgs(ctypes_cast, ptr, ctypes_void_p, NULL); PyObject* ptr_value = PyObject_GetAttrString(ptr_as_c_void_p, "value"); unsigned long long out = PyLong_AsUnsignedLongLong(ptr_value); @@ -53,17 +53,17 @@ unsigned long long PyGLM_UnsignedLongLong_FromCtypesP(PyObject* ptr) { #if !(PyGLM_BUILD & PyGLM_NO_FUNCTIONS) -PyObject* ctypes_float_p = NULL; -PyObject* ctypes_double_p = NULL; -PyObject* ctypes_int64_p = NULL; -PyObject* ctypes_int32_p = NULL; -PyObject* ctypes_int16_p = NULL; -PyObject* ctypes_int8_p = NULL; -PyObject* ctypes_uint64_p = NULL; -PyObject* ctypes_uint32_p = NULL; -PyObject* ctypes_uint16_p = NULL; -PyObject* ctypes_uint8_p = NULL; -PyObject* ctypes_bool_p = NULL; +static PyObject* ctypes_float_p = NULL; +static PyObject* ctypes_double_p = NULL; +static PyObject* ctypes_int64_p = NULL; +static PyObject* ctypes_int32_p = NULL; +static PyObject* ctypes_int16_p = NULL; +static PyObject* ctypes_int8_p = NULL; +static PyObject* ctypes_uint64_p = NULL; +static PyObject* ctypes_uint32_p = NULL; +static PyObject* ctypes_uint16_p = NULL; +static PyObject* ctypes_uint8_p = NULL; +static PyObject* ctypes_bool_p = NULL; @@ -71,74 +71,76 @@ PyObject* ctypes_bool_p = NULL; -PyObject* PyGLM_ToCtypesP(float* ptr) { +static PyObject* PyGLM_ToCtypesP(float* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_float_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(double* ptr) { +static PyObject* PyGLM_ToCtypesP(double* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_double_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(glm::int64* ptr) { +static PyObject* PyGLM_ToCtypesP(glm::int64* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_int64_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(glm::int32* ptr) { +static PyObject* PyGLM_ToCtypesP(glm::int32* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_int32_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(glm::int16* ptr) { +static PyObject* PyGLM_ToCtypesP(glm::int16* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_int16_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(glm::int8* ptr) { +static PyObject* PyGLM_ToCtypesP(glm::int8* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_int8_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(glm::uint64* ptr) { +static PyObject* PyGLM_ToCtypesP(glm::uint64* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_uint64_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(glm::uint32* ptr) { +static PyObject* PyGLM_ToCtypesP(glm::uint32* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_uint32_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(glm::uint16* ptr) { +static PyObject* PyGLM_ToCtypesP(glm::uint16* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_uint16_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(glm::uint8* ptr) { +static PyObject* PyGLM_ToCtypesP(glm::uint8* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_uint8_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(bool* ptr) { +static PyObject* PyGLM_ToCtypesP(bool* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP((void*)ptr); PyObject* out = PyObject_CallFunctionObjArgs(ctypes_cast, ptr_as_c_void_p, ctypes_bool_p, NULL); Py_DECREF(ptr_as_c_void_p); return out; } -PyObject* PyGLM_ToCtypesP(void* ptr) { +/* +static PyObject* PyGLM_ToCtypesP(void* ptr) { PyObject* ptr_as_c_void_p = PyGLM_CtypesVoidP_FromVoidP(ptr); return ptr_as_c_void_p; } +*/ #endif \ No newline at end of file diff --git a/PyGLM/internal_functions/error_functions.h b/PyGLM_lib/PyGLM/internal_functions/error_functions.h similarity index 97% rename from PyGLM/internal_functions/error_functions.h rename to PyGLM_lib/PyGLM/internal_functions/error_functions.h index 1f565041..123ea6fb 100644 --- a/PyGLM/internal_functions/error_functions.h +++ b/PyGLM_lib/PyGLM/internal_functions/error_functions.h @@ -15,4 +15,4 @@ #define PyGLM_Arg_Unpack_3O(args, name, arg1, arg2, arg3) if(!PyArg_UnpackTuple(args, name, 3, 3, &arg1, &arg2, &arg3)) return NULL #define PyGLM_Arg_Unpack_4O(args, name, arg1, arg2, arg3, arg4) if(!PyArg_UnpackTuple(args, name, 4, 4, &arg1, &arg2, &arg3, &arg4)) return NULL #define PyGLM_Arg_Unpack_5O(args, name, arg1, arg2, arg3, arg4, arg5) if(!PyArg_UnpackTuple(args, name, 5, 5, &arg1, &arg2, &arg3, &arg4, &arg5)) return NULL -#define PyGLM_Arg_Unpack_6O(args, name, arg1, arg2, arg3, arg4, arg5, arg6) if(!PyArg_UnpackTuple(args, name, 6, 6, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) return NULL \ No newline at end of file +#define PyGLM_Arg_Unpack_6O(args, name, arg1, arg2, arg3, arg4, arg5, arg6) if(!PyArg_UnpackTuple(args, name, 6, 6, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) return NULL diff --git a/PyGLM_lib/PyGLM/internal_functions/glm_customizations.h b/PyGLM_lib/PyGLM/internal_functions/glm_customizations.h new file mode 100644 index 00000000..b385a7cf --- /dev/null +++ b/PyGLM_lib/PyGLM/internal_functions/glm_customizations.h @@ -0,0 +1,69 @@ +#pragma once + +#include "../compiler_setup.h" + +namespace glm { + namespace custom { + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(T x, T y) + { + return x * y; + } + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(vec const& x, vec const& y) + { + return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); + } + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(qua const& x, qua const& y) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'dot' accepts only floating-point inputs"); + return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); + } + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat::col_type mat_mul + ( + mat const& m, + typename mat::row_type const& v + ) + { + return m * v; + } + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat::row_type mat_mul + ( + typename mat::col_type const& v, + mat const& m + ) + { + return v * m; + } + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 3, T, Q>::row_type mat_mul(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m) + { + return typename mat<3, 3, T, Q>::row_type( + glm::custom::dot(m[0], v), + glm::custom::dot(m[1], v), + glm::custom::dot(m[2], v)); + } + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 4, T, Q>::row_type mat_mul + ( + typename mat<4, 4, T, Q>::col_type const& v, + mat<4, 4, T, Q> const& m + ) + { + return typename mat<4, 4, T, Q>::row_type( + glm::custom::dot(m[0], v), + glm::custom::dot(m[1], v), + glm::custom::dot(m[2], v), + glm::custom::dot(m[3], v)); + } + } +} diff --git a/PyGLM/internal_functions/helper_macros.h b/PyGLM_lib/PyGLM/internal_functions/helper_macros.h similarity index 90% rename from PyGLM/internal_functions/helper_macros.h rename to PyGLM_lib/PyGLM/internal_functions/helper_macros.h index 311d3af7..869d424f 100644 --- a/PyGLM/internal_functions/helper_macros.h +++ b/PyGLM_lib/PyGLM/internal_functions/helper_macros.h @@ -39,10 +39,3 @@ #define PyGLM_INCREF(ob) (Py_INCREF(ob), ob) #define PyGLM_DECREF(ob) (Py_DECREF(ob), ob) - -static char* PyGLM_String_AsString(PyObject* name) { - PyObject* asciiString = PyUnicode_AsASCIIString(name); - char* out = PyBytes_AsString(asciiString); - Py_DECREF(asciiString); - return out; -} \ No newline at end of file diff --git a/PyGLM/internal_functions/number_functions.h b/PyGLM_lib/PyGLM/internal_functions/number_functions.h similarity index 91% rename from PyGLM/internal_functions/number_functions.h rename to PyGLM_lib/PyGLM/internal_functions/number_functions.h index 7f6ff8cf..1d53e0ad 100644 --- a/PyGLM/internal_functions/number_functions.h +++ b/PyGLM_lib/PyGLM/internal_functions/number_functions.h @@ -2,7 +2,7 @@ #include "../compiler_setup.h" -PyObject* PyGLM_GetNumber(PyObject* arg) { +static PyObject* PyGLM_GetNumber(PyObject* arg) { if (arg->ob_type->tp_as_number->nb_float != NULL) { return PyNumber_Float(arg); } @@ -16,7 +16,7 @@ PyObject* PyGLM_GetNumber(PyObject* arg) { return NULL; } -bool PyGLM_TestNumber(PyObject* arg) { +static bool PyGLM_TestNumber(PyObject* arg) { PyObject* num = PyGLM_GetNumber(arg); if (num == NULL) { @@ -27,7 +27,7 @@ bool PyGLM_TestNumber(PyObject* arg) { return true; } -unsigned long PyLong_AsUnsignedLongAndOverflow(PyObject* arg, int* overflow) { +static unsigned long PyLong_AsUnsignedLongAndOverflow(PyObject* arg, int* overflow) { unsigned long out = PyLong_AsUnsignedLong(arg); if (PyErr_Occurred()) { PyErr_Clear(); @@ -39,7 +39,8 @@ unsigned long PyLong_AsUnsignedLongAndOverflow(PyObject* arg, int* overflow) { return out; } -unsigned long long PyLong_AsUnsignedLongLongAndOverflow(PyObject* arg, int* overflow) { +/* +static unsigned long long PyLong_AsUnsignedLongLongAndOverflow(PyObject* arg, int* overflow) { unsigned long long out = PyLong_AsUnsignedLongLong(arg); if (PyErr_Occurred()) { PyErr_Clear(); @@ -50,8 +51,9 @@ unsigned long long PyLong_AsUnsignedLongLongAndOverflow(PyObject* arg, int* over } return out; } +*/ -int PyLong_Sign(PyObject* arg) { +static int PyLong_Sign(PyObject* arg) { int overflow; long l = PyLong_AsLongAndOverflow(arg, &overflow); if (overflow) { @@ -65,7 +67,7 @@ int PyLong_Sign(PyObject* arg) { #define PyGLM_Number_Check(arg) (PyFloat_Check(arg) || PyLong_Check(arg) || PyBool_Check(arg) || (PyGLM_COULD_BE_NUMBER(arg) &&PyGLM_TestNumber(arg))) template -T _PyGLM_Long_As_Number_No_Error(PyObject* arg) { +static T _PyGLM_Long_As_Number_No_Error(PyObject* arg) { if (std::numeric_limits::is_iec559) { int overflow; long long ll; @@ -121,7 +123,7 @@ T _PyGLM_Long_As_Number_No_Error(PyObject* arg) { return static_cast(PyLong_AsUnsignedLongLongMask(arg)); } -double PyGLM_Number_AsDouble(PyObject* arg) { +static double PyGLM_Number_AsDouble(PyObject* arg) { if (PyFloat_Check(arg)) { return PyFloat_AS_DOUBLE(arg); } @@ -141,7 +143,7 @@ double PyGLM_Number_AsDouble(PyObject* arg) { return -1.0; } -long PyGLM_Number_AsLong(PyObject* arg) { +static long PyGLM_Number_AsLong(PyObject* arg) { if (PyLong_Check(arg)) { return _PyGLM_Long_As_Number_No_Error(arg); } @@ -161,7 +163,7 @@ long PyGLM_Number_AsLong(PyObject* arg) { return -1l; } -unsigned long PyGLM_Number_AsUnsignedLong(PyObject* arg) { +static unsigned long PyGLM_Number_AsUnsignedLong(PyObject* arg) { if (PyLong_Check(arg)) { return _PyGLM_Long_As_Number_No_Error(arg); } @@ -181,7 +183,7 @@ unsigned long PyGLM_Number_AsUnsignedLong(PyObject* arg) { return (unsigned long) - 1l; } -long long PyGLM_Number_AsLongLong(PyObject* arg) { +static long long PyGLM_Number_AsLongLong(PyObject* arg) { if (PyLong_Check(arg)) { return _PyGLM_Long_As_Number_No_Error(arg); } @@ -201,7 +203,7 @@ long long PyGLM_Number_AsLongLong(PyObject* arg) { return -1ll; } -unsigned long long PyGLM_Number_AsUnsignedLongLong(PyObject* arg) { +static unsigned long long PyGLM_Number_AsUnsignedLongLong(PyObject* arg) { if (PyLong_Check(arg)) { return _PyGLM_Long_As_Number_No_Error(arg); } @@ -221,7 +223,7 @@ unsigned long long PyGLM_Number_AsUnsignedLongLong(PyObject* arg) { return (unsigned long long)-1ll; } -bool PyGLM_Number_AsBool(PyObject* arg) { +static bool PyGLM_Number_AsBool(PyObject* arg) { if (PyBool_Check(arg)) { return (arg == Py_True) ? true : false; } @@ -241,7 +243,7 @@ bool PyGLM_Number_AsBool(PyObject* arg) { return false; } -float PyGLM_Number_AsFloat(PyObject* arg) { +static float PyGLM_Number_AsFloat(PyObject* arg) { if (PyFloat_Check(arg)) { return (float)PyFloat_AS_DOUBLE(arg); } diff --git a/PyGLM/internal_functions/packers.h b/PyGLM_lib/PyGLM/internal_functions/packers.h similarity index 100% rename from PyGLM/internal_functions/packers.h rename to PyGLM_lib/PyGLM/internal_functions/packers.h diff --git a/PyGLM/internal_functions/type_checkers.h b/PyGLM_lib/PyGLM/internal_functions/type_checkers.h similarity index 89% rename from PyGLM/internal_functions/type_checkers.h rename to PyGLM_lib/PyGLM/internal_functions/type_checkers.h index 53d9654e..2e675bd5 100644 --- a/PyGLM/internal_functions/type_checkers.h +++ b/PyGLM_lib/PyGLM/internal_functions/type_checkers.h @@ -11,6 +11,8 @@ #include "helper_macros.h" #include "number_functions.h" +#include + #define PyGLM_SHAPE_GET(C, R) (1 << (11 + (3 * (C-2) + (R-2)))) #define PyGLM_TYPE_GET(T) (PyGLMTypeInfo::getDT()) @@ -26,6 +28,206 @@ #define _SUB_PyGLM_PTI_GET_TYPE(o) ((o->ob_type->tp_dealloc == (destructor)vec_dealloc) ? PyGLM_T_VEC : (o->ob_type->tp_dealloc == (destructor)mat_dealloc) ? PyGLM_T_MAT : (o->ob_type->tp_dealloc == (destructor)qua_dealloc) ? PyGLM_T_QUA : (o->ob_type->tp_dealloc == (destructor)mvec_dealloc) ? PyGLM_T_MVEC : PyGLM_UNKNOWN) #define PyGLM_PTI_GET_TYPE(o) _SUB_PyGLM_PTI_GET_TYPE(((PyObject*)o)) +enum class _FormatType { + FLOAT, DOUBLE, INT8, UINT8, INT16, UINT16, INT32, UINT32, INT64, UINT64, BOOL, NONE +}; + +static bool is_big_endian(void) +{ + union { + uint32_t i; + int8_t c[4]; + } num = {0x01020304}; + + return num.c[0] == 1; +} + +// Get a Py_buffer from a PyObject in F-contiguous form +static bool get_py_buffer(PyObject* arg, Py_buffer* out) { + if (!PyObject_CheckBuffer(arg)) { + return false; + } + + constexpr int accepted_buffer_flags[] = {PyBUF_RECORDS_RO}; + + bool buffer_found = false; + + for (size_t i = 0; i < sizeof(accepted_buffer_flags) / sizeof(int); i++) { + if (PyObject_GetBuffer(arg, out, accepted_buffer_flags[i]) == -1) { + PyErr_Clear(); + } else { + buffer_found = true; + break; + } + } + + if (!buffer_found) { + return false; + } + + if (PyBuffer_IsContiguous(out, 'F')) { + return true; + } + + Py_buffer temp = *out; + + out->buf = PyMem_Malloc(temp.len); + + if (out->buf == NULL) { + PyBuffer_Release(&temp); + return false; + } + + // make out->buf a contiguous version of temp.buf + PyBuffer_ToContiguous(out->buf, &temp, temp.len, 'F'); + + out->shape = reinterpret_cast(PyMem_Malloc(sizeof(Py_ssize_t) * temp.ndim)); + out->strides = reinterpret_cast(PyMem_Malloc(sizeof(Py_ssize_t) * temp.ndim)); + + // copy format from temp to out + const size_t format_len = strlen(temp.format); + + char* format = reinterpret_cast(PyMem_Malloc((format_len + 1) * sizeof(char))); + memcpy(format, temp.format, (format_len + 1) * sizeof(char)); + + out->format = format; + + // copy shape from temp to out + memcpy(out->shape, temp.shape, sizeof(Py_ssize_t) * temp.ndim); + + // adjust out->strides to Fortran contiguous layout + PyBuffer_FillContiguousStrides(temp.ndim, temp.shape, out->strides, static_cast(temp.itemsize), 'F'); + + // mark buffer as readonly, since it's not the original data buffer + out->readonly = 1; + + out->obj = NULL; + + PyBuffer_Release(&temp); + + return true; +} + +// Release a Py_buffer aquired with get_py_buffer +static void release_py_buffer(Py_buffer* buf) { + if (buf->obj == NULL) { + PyMem_Free(buf->format); + PyMem_Free(buf->shape); + PyMem_Free(buf->strides); + PyMem_Free(buf->buf); + } + else { + PyBuffer_Release(buf); + } +} + +static _FormatType getFormatFromSize(int size, bool isSigned) { + switch(size) { + case 1: + if (isSigned) + return _FormatType::INT8; + return _FormatType::UINT8; + case 2: + if (isSigned) + return _FormatType::INT16; + return _FormatType::UINT16; + case 4: + if (isSigned) + return _FormatType::INT32; + return _FormatType::UINT32; + case 8: + if (isSigned) + return _FormatType::INT64; + return _FormatType::UINT64; + } + return _FormatType::NONE; +} + +static _FormatType getFormatType(char* format) { + if (format == NULL) { + return _FormatType::UINT8; + } + if (format[0] == '=' || (is_big_endian() && format[0] == '>') || (!is_big_endian() && format[0] == '<') || (is_big_endian() && format[0] == '!')) { + switch(format[1]) { + case 'b': + return _FormatType::INT8; + case 'c': + case 'B': + return _FormatType::UINT8; + case 'h': + return _FormatType::INT16; + case 'H': + return _FormatType::UINT16; + case 'i': + case 'l': + return _FormatType::INT32; + case 'I': + case 'L': + return _FormatType::UINT32; + case 'q': + case 'n': + return _FormatType::INT64; + case 'Q': + case 'N': + return _FormatType::UINT64; + case 'f': + return _FormatType::FLOAT; + case 'd': + return _FormatType::DOUBLE; + case 'P': + return _FormatType::UINT64; + case '?': + return _FormatType::BOOL; + default: + return _FormatType::NONE; + + } + } + if ((!is_big_endian() && format[0] == '>') || (is_big_endian() && format[0] == '<') || (!is_big_endian() && format[0] == '!')) { + return _FormatType::NONE; + } + + const char formatChar = (format[0] == '@') ? format[1] : format[0]; + + switch(formatChar) { + case 'f': + return _FormatType::FLOAT; + case 'd': + return _FormatType::DOUBLE; + case 'b': + return getFormatFromSize(sizeof(char), true); + case 'c': + case 'B': + return getFormatFromSize(sizeof(unsigned char), false); + case 'h': + return getFormatFromSize(sizeof(short), true); + case 'H': + return getFormatFromSize(sizeof(unsigned short), false); + case 'i': + return getFormatFromSize(sizeof(int), true); + case 'I': + return getFormatFromSize(sizeof(unsigned int), false); + case 'l': + return getFormatFromSize(sizeof(long), true); + case 'L': + return getFormatFromSize(sizeof(unsigned long), false); + case 'q': + return getFormatFromSize(sizeof(long long), true); + case 'Q': + return getFormatFromSize(sizeof(unsigned long long), false); + case 'n': + return getFormatFromSize(sizeof(Py_ssize_t), true); + case 'N': + return getFormatFromSize(sizeof(std::size_t), false); + case 'P': + return getFormatFromSize(sizeof(void*), false); + case '?': + return _FormatType::BOOL; + default: + return _FormatType::NONE; + } +} + // necessary forward declarations template static glm::vec unpack_vec(PyObject* value); @@ -411,313 +613,301 @@ struct PyGLMTypeInfo { if (obj->ob_type != &glmArrayType && PyObject_CheckBuffer(obj)) { Py_buffer view; char* customDataBuffer = NULL; - if (PyObject_GetBuffer(obj, &view, PyBUF_RECORDS_RO | PyBUF_F_CONTIGUOUS) == -1) { - PyErr_Clear(); - if (PyObject_GetBuffer(obj, &view, PyBUF_RECORDS_RO | PyBUF_C_CONTIGUOUS) == -1) { - PyErr_Clear(); - return; - } - if (view.ndim != 2) { - PyBuffer_Release(&view); - return; - } - char* oldBuffer = reinterpret_cast(view.buf); - customDataBuffer = reinterpret_cast(dataArray); - for (Py_ssize_t R = 0; R < view.shape[0]; R++) { - for (Py_ssize_t C = 0; C < view.shape[1]; C++) { - memcpy(customDataBuffer + (C * view.shape[0] * view.itemsize) + (R * view.itemsize), oldBuffer, view.itemsize); - oldBuffer += view.itemsize; - } - } + if (!get_py_buffer(obj, &view)) { + return; + } - view.readonly = -1; + const _FormatType formatType = getFormatType(view.format); + + if (formatType == _FormatType::NONE) { + release_py_buffer(&view); + return; } + switch (view.ndim) { case 1: // one dimensional array (vec / qua) if (view.shape == NULL) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } switch (view.shape[0]) { case 1: // vec1's if (!((accepted_types & PyGLM_T_ANY_VEC) && (accepted_types & PyGLM_SHAPE_1)) || view.format == NULL) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_DOUBLE); break; - case 'b': + case _FormatType::INT8: if (!(accepted_types & PyGLM_DT_INT8)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_INT8); break; - case 'B': + case _FormatType::UINT8: if (!(accepted_types & PyGLM_DT_UINT8)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_UINT8); break; - case 'h': + case _FormatType::INT16: if (!(accepted_types & PyGLM_DT_INT16)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_INT16); break; - case 'H': + case _FormatType::UINT16: if (!(accepted_types & PyGLM_DT_UINT16)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_UINT16); break; - case 'l': - case 'i': + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_INT); break; - case 'L': - case 'I': + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_UINT); break; - case 'q': + case _FormatType::INT64: if (!(accepted_types & PyGLM_DT_INT64)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_INT64); break; - case 'Q': + case _FormatType::UINT64: if (!(accepted_types & PyGLM_DT_UINT64)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_UINT64); break; - case '?': + case _FormatType::BOOL: if (!(accepted_types & PyGLM_DT_BOOL)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_1 | PyGLM_DT_BOOL); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 2: // vec2's if (!((accepted_types & PyGLM_T_ANY_VEC) && (accepted_types & PyGLM_SHAPE_2)) || view.format == NULL) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_DOUBLE); break; - case 'b': + case _FormatType::INT8: if (!(accepted_types & PyGLM_DT_INT8)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_INT8); break; - case 'B': + case _FormatType::UINT8: if (!(accepted_types & PyGLM_DT_UINT8)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_UINT8); break; - case 'h': + case _FormatType::INT16: if (!(accepted_types & PyGLM_DT_INT16)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_INT16); break; - case 'H': + case _FormatType::UINT16: if (!(accepted_types & PyGLM_DT_UINT16)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_UINT16); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_UINT); break; - case 'q': + case _FormatType::INT64: if (!(accepted_types & PyGLM_DT_INT64)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_INT64); break; - case 'Q': + case _FormatType::UINT64: if (!(accepted_types & PyGLM_DT_UINT64)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_UINT64); break; - case '?': + case _FormatType::BOOL: if (!(accepted_types & PyGLM_DT_BOOL)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_2 | PyGLM_DT_BOOL); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 3: // vec3's if (!((accepted_types & PyGLM_T_ANY_VEC) && (accepted_types & PyGLM_SHAPE_3)) || view.format == NULL) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_DOUBLE); break; - case 'b': + case _FormatType::INT8: if (!(accepted_types & PyGLM_DT_INT8)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_INT8); break; - case 'B': + case _FormatType::UINT8: if (!(accepted_types & PyGLM_DT_UINT8)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_UINT8); break; - case 'h': + case _FormatType::INT16: if (!(accepted_types & PyGLM_DT_INT16)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_INT16); break; - case 'H': + case _FormatType::UINT16: if (!(accepted_types & PyGLM_DT_UINT16)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_UINT16); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_UINT); break; - case 'q': + case _FormatType::INT64: if (!(accepted_types & PyGLM_DT_INT64)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_INT64); break; - case 'Q': + case _FormatType::UINT64: if (!(accepted_types & PyGLM_DT_UINT64)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_UINT64); break; - case '?': + case _FormatType::BOOL: if (!(accepted_types & PyGLM_DT_BOOL)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_3 | PyGLM_DT_BOOL); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 4: // vec4's and qua's if (!(((accepted_types & PyGLM_T_ANY_VEC) && (accepted_types & PyGLM_SHAPE_4)) || (accepted_types & PyGLM_T_QUA)) || view.format == NULL) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } if (((accepted_types & PyGLM_T_ANY_VEC) && (accepted_types & PyGLM_SHAPE_4))) @@ -725,9 +915,9 @@ struct PyGLMTypeInfo { else setInfo(PyGLM_T_QUA | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } if (((accepted_types & PyGLM_T_ANY_VEC) && (accepted_types & PyGLM_SHAPE_4))) @@ -735,496 +925,496 @@ struct PyGLMTypeInfo { else setInfo(PyGLM_T_QUA | PyGLM_DT_DOUBLE); break; - case 'b': + case _FormatType::INT8: if (!(accepted_types & PyGLM_DT_INT8)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_4 | PyGLM_DT_INT8); break; - case 'B': + case _FormatType::UINT8: if (!(accepted_types & PyGLM_DT_UINT8)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_4 | PyGLM_DT_UINT8); break; - case 'h': + case _FormatType::INT16: if (!(accepted_types & PyGLM_DT_INT16)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_4 | PyGLM_DT_INT16); break; - case 'H': + case _FormatType::UINT16: if (!(accepted_types & PyGLM_DT_UINT16)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_4 | PyGLM_DT_UINT16); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_4 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_4 | PyGLM_DT_UINT); break; - case 'q': + case _FormatType::INT64: if (!(accepted_types & PyGLM_DT_INT64)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_4 | PyGLM_DT_INT64); break; - case 'Q': + case _FormatType::UINT64: if (!(accepted_types & PyGLM_DT_UINT64)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_4 | PyGLM_DT_UINT64); break; - case '?': + case _FormatType::BOOL: if (!(accepted_types & PyGLM_DT_BOOL)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_VEC | PyGLM_SHAPE_4 | PyGLM_DT_BOOL); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 2: // two dimensional array (mat) if (view.shape == NULL || !(accepted_types & PyGLM_T_MAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } switch (view.shape[1]) { case 2: // mat2xM's if (!(accepted_types & PyGLM_SHAPE_2xM)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } switch (view.shape[0]) { case 2: // mat2x2's if (!(accepted_types & PyGLM_SHAPE_2x2)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x2 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x2 | PyGLM_DT_DOUBLE); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x2 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x2 | PyGLM_DT_UINT); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 3: // mat2x3's if (!(accepted_types & PyGLM_SHAPE_2x3)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x3 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x3 | PyGLM_DT_DOUBLE); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x3 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x3 | PyGLM_DT_UINT); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 4: // mat2x4's if (!(accepted_types & PyGLM_SHAPE_2x4)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x4 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x4 | PyGLM_DT_DOUBLE); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x4 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_2x4 | PyGLM_DT_UINT); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 3: // mat3xM's if (!(accepted_types & PyGLM_SHAPE_3xM)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } switch (view.shape[0]) { case 2: // mat3x2's if (!(accepted_types & PyGLM_SHAPE_3x2)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x2 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x2 | PyGLM_DT_DOUBLE); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x2 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x2 | PyGLM_DT_UINT); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 3: // mat3x3's if (!(accepted_types & PyGLM_SHAPE_3x3)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x3 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x3 | PyGLM_DT_DOUBLE); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x3 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x3 | PyGLM_DT_UINT); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 4: // mat3x4's if (!(accepted_types & PyGLM_SHAPE_3x4)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x4 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x4 | PyGLM_DT_DOUBLE); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x4 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_3x4 | PyGLM_DT_UINT); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 4: // mat4xM's if (!(accepted_types & PyGLM_SHAPE_4xM)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } switch (view.shape[0]) { case 2: // mat4x2's if (!(accepted_types & PyGLM_SHAPE_4x2)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x2 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x2 | PyGLM_DT_DOUBLE); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x2 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x2 | PyGLM_DT_UINT); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 3: // mat4x3's if (!(accepted_types & PyGLM_SHAPE_4x3)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x3 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x3 | PyGLM_DT_DOUBLE); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x3 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x3 | PyGLM_DT_UINT); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; case 4: // mat4x4's if (!(accepted_types & PyGLM_SHAPE_4x4)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } - switch (view.format[0]) { - case 'f': + switch (formatType) { + case _FormatType::FLOAT: if (!(accepted_types & PyGLM_DT_FLOAT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x4 | PyGLM_DT_FLOAT); break; - case 'd': + case _FormatType::DOUBLE: if (!(accepted_types & PyGLM_DT_DOUBLE)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x4 | PyGLM_DT_DOUBLE); break; - case 'l': - case 'i': + + case _FormatType::INT32: if (!(accepted_types & PyGLM_DT_INT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x4 | PyGLM_DT_INT); break; - case 'L': - case 'I': + + case _FormatType::UINT32: if (!(accepted_types & PyGLM_DT_UINT)) { - PyBuffer_Release(&view); + release_py_buffer(&view); return; } setInfo(PyGLM_T_MAT | PyGLM_SHAPE_4x4 | PyGLM_DT_UINT); break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } break; default: - PyBuffer_Release(&view); + release_py_buffer(&view); return; } if (view.readonly == 0) { @@ -1234,7 +1424,7 @@ struct PyGLMTypeInfo { allocate(view.len); memcpy(data, view.buf, view.len); } - PyBuffer_Release(&view); + release_py_buffer(&view); return; } // end of getbuffer checking @@ -2304,7 +2494,7 @@ struct PyGLMTypeInfo { #define PyGLM_Qua_CheckExact(T, o) (Py_TYPE(o) == UNBRACKET (PyGLM_QUA_TYPE())) template -constexpr int get_PTI_type() { +static constexpr int get_PTI_type() { return ( (std::is_same::value) ? PyGLM_DT_DOUBLE : (std::is_same::value) ? PyGLM_DT_FLOAT : @@ -2321,7 +2511,7 @@ constexpr int get_PTI_type() { } template -constexpr int get_vec_PTI_info() { +static constexpr int get_vec_PTI_info() { return PyGLM_T_VEC | ( (L == 1) ? PyGLM_SHAPE_1 : @@ -2333,7 +2523,7 @@ constexpr int get_vec_PTI_info() { } template -constexpr int get_mat_PTI_info() { +static constexpr int get_mat_PTI_info() { return PyGLM_T_MAT | ( (C == 2) ? @@ -2358,12 +2548,12 @@ constexpr int get_mat_PTI_info() { } template -constexpr int get_qua_PTI_info() { +static constexpr int get_qua_PTI_info() { return PyGLM_T_QUA | get_PTI_type(); } -bool GET_PTI_COMPATIBLE_SIMPLE(PyObject* o, int accepted_types) { +static bool GET_PTI_COMPATIBLE_SIMPLE(PyObject* o, int accepted_types) { int& PTI_info = ((PyGLMTypeObject*)(o->ob_type))->PTI_info; return (PTI_info & accepted_types) == PTI_info; } @@ -2416,25 +2606,25 @@ enum SourceType {NONE, PyGLM_VEC, PyGLM_MVEC, PyGLM_MAT, PyGLM_QUA, PTI}; -PyGLMTypeInfo PTI0; -SourceType sourceType0; +static PyGLMTypeInfo PTI0; +static SourceType sourceType0; -PyGLMTypeInfo PTI1; -SourceType sourceType1; +static PyGLMTypeInfo PTI1; +static SourceType sourceType1; -PyGLMTypeInfo PTI2; -SourceType sourceType2; +static PyGLMTypeInfo PTI2; +static SourceType sourceType2; -PyGLMTypeInfo PTI3; -SourceType sourceType3; +static PyGLMTypeInfo PTI3; +static SourceType sourceType3; #ifdef PyGLM_DEBUG -PyObject* ARG0 = NULL; -PyObject* ARG1 = NULL; -PyObject* ARG2 = NULL; -PyObject* ARG3 = NULL; +static PyObject* ARG0 = NULL; +static PyObject* ARG1 = NULL; +static PyObject* ARG2 = NULL; +static PyObject* ARG3 = NULL; -bool ARGUSED = true; +static bool ARGUSED = true; #endif #ifdef PyGLM_DEBUG @@ -2446,14 +2636,14 @@ bool ARGUSED = true; else { PTI ## N = PyGLMTypeInfo(accepted_types, o); if (PTI ## N.info == 0) sourceType ## N = NONE; else sourceType ## N = PTI;};\ if (N == 0 && !ARGUSED) throw; ARG ## N = o; if (N == 0 && sourceType ## N != NONE) {ARGUSED = false;}; -bool PyGLM_PTI_DEBUG_EQ_FUNC(PyObject* o, PyObject* arg) { +static bool PyGLM_PTI_DEBUG_EQ_FUNC(PyObject* o, PyObject* arg) { if (o != arg) { throw; } return false; } -inline bool set_ARGUSED() { +static inline bool set_ARGUSED() { ARGUSED = true; return ARGUSED; } @@ -2492,7 +2682,7 @@ inline bool set_ARGUSED() { #ifdef PyGLM_DEBUG -inline bool assertAndReturn(bool expr) { +static inline bool assertAndReturn(bool expr) { assert(expr); return expr; } @@ -2540,13 +2730,13 @@ inline bool assertAndReturn(bool expr) { #else enum SourceType { NONE, PyGLM_VEC, PyGLM_MVEC, PyGLM_MAT, PyGLM_QUA }; -SourceType sourceType0; +static SourceType sourceType0; -SourceType sourceType1; +static SourceType sourceType1; -SourceType sourceType2; +static SourceType sourceType2; -SourceType sourceType3; +static SourceType sourceType3; #define PyGLM_PTI_InitN(N, o, accepted_types) \ if (o->ob_type->tp_dealloc == (destructor)vec_dealloc){if (GET_PTI_COMPATIBLE_SIMPLE(o, accepted_types)) {sourceType ## N = PyGLM_VEC;} else {sourceType ## N = NONE;}}\ diff --git a/PyGLM/internal_functions/type_getters/all.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/all.h similarity index 100% rename from PyGLM/internal_functions/type_getters/all.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/all.h diff --git a/PyGLM/internal_functions/type_getters/ctypes_datatypes.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/ctypes_datatypes.h similarity index 100% rename from PyGLM/internal_functions/type_getters/ctypes_datatypes.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/ctypes_datatypes.h diff --git a/PyGLM/internal_functions/type_getters/mat.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/mat.h similarity index 100% rename from PyGLM/internal_functions/type_getters/mat.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/mat.h diff --git a/PyGLM/internal_functions/type_getters/mat_iter.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/mat_iter.h similarity index 100% rename from PyGLM/internal_functions/type_getters/mat_iter.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/mat_iter.h diff --git a/PyGLM/internal_functions/type_getters/mvec.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/mvec.h similarity index 100% rename from PyGLM/internal_functions/type_getters/mvec.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/mvec.h diff --git a/PyGLM/internal_functions/type_getters/mvec_iter.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/mvec_iter.h similarity index 100% rename from PyGLM/internal_functions/type_getters/mvec_iter.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/mvec_iter.h diff --git a/PyGLM/internal_functions/type_getters/qua.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/qua.h similarity index 100% rename from PyGLM/internal_functions/type_getters/qua.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/qua.h diff --git a/PyGLM/internal_functions/type_getters/qua_iter.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/qua_iter.h similarity index 100% rename from PyGLM/internal_functions/type_getters/qua_iter.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/qua_iter.h diff --git a/PyGLM/internal_functions/type_getters/type_checkers.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/type_checkers.h similarity index 100% rename from PyGLM/internal_functions/type_getters/type_checkers.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/type_checkers.h diff --git a/PyGLM/internal_functions/type_getters/vec.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/vec.h similarity index 100% rename from PyGLM/internal_functions/type_getters/vec.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/vec.h diff --git a/PyGLM/internal_functions/type_getters/vec_iter.h b/PyGLM_lib/PyGLM/internal_functions/type_getters/vec_iter.h similarity index 100% rename from PyGLM/internal_functions/type_getters/vec_iter.h rename to PyGLM_lib/PyGLM/internal_functions/type_getters/vec_iter.h diff --git a/PyGLM/internal_functions/unpackers.h b/PyGLM_lib/PyGLM/internal_functions/unpackers.h similarity index 100% rename from PyGLM/internal_functions/unpackers.h rename to PyGLM_lib/PyGLM/internal_functions/unpackers.h diff --git a/PyGLM_lib/PyGLM/internal_functions/version_info.h b/PyGLM_lib/PyGLM/internal_functions/version_info.h new file mode 100644 index 00000000..6729d65f --- /dev/null +++ b/PyGLM_lib/PyGLM/internal_functions/version_info.h @@ -0,0 +1,6 @@ +#pragma once + +#include "../compiler_setup.h" + +static PyObject* PyGLM_VERSION_STRING = NULL; +static PyObject* PyGLM_LICENSE_STRING = NULL; \ No newline at end of file diff --git a/PyGLM/internal_functions/warnings.h b/PyGLM_lib/PyGLM/internal_functions/warnings.h similarity index 93% rename from PyGLM/internal_functions/warnings.h rename to PyGLM_lib/PyGLM/internal_functions/warnings.h index 58b48a59..ab652274 100644 --- a/PyGLM/internal_functions/warnings.h +++ b/PyGLM_lib/PyGLM/internal_functions/warnings.h @@ -9,7 +9,7 @@ #define PyGLM_OVERFLOW_WARNING 5 #define PyGLM_ARGUMENT_DEPRECATION_WARNING 6 -unsigned long long PyGLM_SHOW_WARNINGS = 18446744073709551615ull; +static unsigned long long PyGLM_SHOW_WARNINGS = 18446744073709551615ull; PyDoc_STRVAR(silence_docstr, "silence(ID: int) -> None\n" diff --git a/PyGLM/type_methods/all.h b/PyGLM_lib/PyGLM/type_methods/all.h similarity index 100% rename from PyGLM/type_methods/all.h rename to PyGLM_lib/PyGLM/type_methods/all.h diff --git a/PyGLM/type_methods/glmArray.h b/PyGLM_lib/PyGLM/type_methods/glmArray.h similarity index 99% rename from PyGLM/type_methods/glmArray.h rename to PyGLM_lib/PyGLM/type_methods/glmArray.h index 91fe5b92..75a2c764 100644 --- a/PyGLM/type_methods/glmArray.h +++ b/PyGLM_lib/PyGLM/type_methods/glmArray.h @@ -32,7 +32,7 @@ glmArray_from_bytes(PyObject*, PyObject* args) { if (PyGLM_Is_PyGLM_Type(typeObj)) { PyGLMTypeObject* pto = (PyGLMTypeObject*)typeObj; - Py_ssize_t& nBytes = PyBytes_GET_SIZE(bytesObj); + const Py_ssize_t nBytes = PyBytes_GET_SIZE(bytesObj); PyGLM_ASSERT((nBytes > 0 && nBytes % pto->itemSize == 0), "Invalid bytes string length"); @@ -517,7 +517,7 @@ if (PyGLM_Number_Check(value)) {\ PyGLM_TYPEERROR_O("invalid assignment type ", value); \ return -1; -int glmArray_set(glmArray* self, Py_ssize_t index, PyObject* value) { +static int glmArray_set(glmArray* self, Py_ssize_t index, PyObject* value) { if (index >= self->itemCount || index < -self->itemCount) { PyErr_SetString(PyExc_IndexError, "index out of range"); return -1; @@ -688,7 +688,7 @@ return PyGLM_PyObject_FromNumber(*(((T*)self->data) + index)); #define GLM_ARRAY_GET_IF_IS_QUA(T) return pack(*(((glm::qua*)self->data) + index)); -PyObject* glmArray_get(glmArray* self, Py_ssize_t index) { +static PyObject* glmArray_get(glmArray* self, Py_ssize_t index) { if (index >= self->itemCount || index < -self->itemCount) { PyErr_SetString(PyExc_IndexError, "index out of range"); return NULL; @@ -980,7 +980,7 @@ glmArray_getbuffer(glmArray* self, Py_buffer* view, int flags) { return 0; } -void +static void glmArray_releasebuffer(PyObject* self, Py_buffer* view) { PyMem_Free(view->shape); PyMem_Free(view->strides); @@ -2592,7 +2592,7 @@ glmArray_init(glmArray* self, PyObject* args, PyObject* kwds) { return -1; } PyObject* firstElement = PyGLM_TupleOrList_GET_ITEM(args, 0); - PyTypeObject*& firstElementType = Py_TYPE(firstElement); + PyTypeObject* firstElementType = Py_TYPE(firstElement); // PyGLM types if (PyGLM_Is_PyGLM_Type(firstElementType)) { @@ -5072,6 +5072,15 @@ static PyObject* glmArray_sub(PyObject* obj1, PyObject* obj2) { return NULL; } +template +static inline T glmArray_simple_mul(T a, T b) { + return a * b; +} + +static inline bool glmArray_simple_mul(bool a, bool b) { + return a && b; +} + template static PyObject* glmArray_mul_T_SEQ(glmArray* arr1, glmArray* arr2) { glmArray* outArray = (glmArray*)glmArray_new(&glmArrayType, NULL, NULL); @@ -5118,7 +5127,7 @@ static PyObject* glmArray_mul_T_SEQ(glmArray* arr1, glmArray* arr2) { Py_ssize_t arr2Ratio = arr2->itemSize / outArray->dtSize; for (Py_ssize_t j = 0; j < outArrayRatio; j++) { - outArrayDataPtr[outArrayIndex++] = arr1DataPtr[i * arr1Ratio + (j % arr1Ratio)] * arr2DataPtr[i * arr2Ratio + (j % arr2Ratio)]; + outArrayDataPtr[outArrayIndex++] = glmArray_simple_mul(arr1DataPtr[i * arr1Ratio + (j % arr1Ratio)], arr2DataPtr[i * arr2Ratio + (j % arr2Ratio)]); } } @@ -5134,15 +5143,13 @@ static PyObject* glmArray_mul_T_MMUL(glmArray* arr1, glmArray* arr2) { outArray->readonly = false; outArray->reference = NULL; - Py_ssize_t n, arr1Stride, arr2Stride, trueShape1; + Py_ssize_t n, arr1Stride, arr2Stride; if (arr1->glmType == PyGLM_TYPE_VEC) { n = arr1->shape[0]; arr1Stride = 1; arr2Stride = arr2->shape[1]; - trueShape1 = 1; - outArray->glmType = PyGLM_TYPE_VEC; outArray->shape[0] = arr2->shape[0]; outArray->shape[1] = 0; @@ -5155,8 +5162,6 @@ static PyObject* glmArray_mul_T_MMUL(glmArray* arr1, glmArray* arr2) { arr1Stride = arr1->shape[1]; arr2Stride = 0; - trueShape1 = arr1->shape[1]; - outArray->glmType = PyGLM_TYPE_VEC; outArray->shape[0] = arr1->shape[1]; outArray->shape[1] = 0; @@ -5169,8 +5174,6 @@ static PyObject* glmArray_mul_T_MMUL(glmArray* arr1, glmArray* arr2) { arr1Stride = arr1->shape[1]; arr2Stride = arr2->shape[1]; - trueShape1 = arr1->shape[1]; - outArray->glmType = PyGLM_TYPE_MAT; outArray->shape[0] = arr2->shape[0]; outArray->shape[1] = arr1->shape[1]; @@ -5198,13 +5201,16 @@ static PyObject* glmArray_mul_T_MMUL(glmArray* arr1, glmArray* arr2) { for (Py_ssize_t j = 0; j < outArrayRatio; j++) { T result = (T)0; for (Py_ssize_t k = 0; k < n; k++) { - T a = arr1DataPtr[k * arr1Stride + j % trueShape1]; - T b = arr2DataPtr[k + (j / trueShape1) * arr2Stride]; + T a = arr1DataPtr[k * arr1Stride + j % arr1Stride]; + T b = arr2DataPtr[k + (j / arr1Stride) * arr2Stride]; result += a * b; } outArrayDataPtr[outArrayIndex++] = result; } + // move pointers by one item + arr1DataPtr = reinterpret_cast(reinterpret_cast(arr1DataPtr) + arr1->itemSize); + arr2DataPtr = reinterpret_cast(reinterpret_cast(arr2DataPtr) + arr2->itemSize); } return (PyObject*)outArray; @@ -5244,7 +5250,7 @@ static PyObject* glmArray_mulO_T(glmArray* arr, T* o, Py_ssize_t o_size, PyGLMTy for (Py_ssize_t i = 0; i < outArray->itemCount; i++) { for (Py_ssize_t j = 0; j < outArrayRatio; j++) { - outArrayDataPtr[outArrayIndex++] = arrDataPtr[i * arrRatio + (j % arrRatio)] * o[j % o_size]; + outArrayDataPtr[outArrayIndex++] = glmArray_simple_mul(arrDataPtr[i * arrRatio + (j % arrRatio)], o[j % o_size]); } } @@ -5276,22 +5282,20 @@ static PyObject* glmArray_mulO_T(glmArray* arr, T* o, Py_ssize_t o_size, PyGLMTy for (Py_ssize_t i = 0; i < outArray->itemCount; i++) { for (Py_ssize_t j = 0; j < outArrayRatio; j++) { - outArrayDataPtr[outArrayIndex++] = arrDataPtr[i * arrRatio + (j % arrRatio)] * o[j % o_size]; + outArrayDataPtr[outArrayIndex++] = glmArray_simple_mul(arrDataPtr[i * arrRatio + (j % arrRatio)], o[j % o_size]); } } return (PyObject*)outArray; } - Py_ssize_t n, arrStride, oStride, trueShape1; + Py_ssize_t n, arrStride, oStride; if (arr->glmType == PyGLM_TYPE_VEC) { n = arr->shape[0]; arrStride = 1; oStride = pto->R; - trueShape1 = 1; - outArray->glmType = PyGLM_TYPE_VEC; outArray->shape[0] = pto->C; outArray->shape[1] = 0; @@ -5304,8 +5308,6 @@ static PyObject* glmArray_mulO_T(glmArray* arr, T* o, Py_ssize_t o_size, PyGLMTy arrStride = arr->shape[1]; oStride = 0; - trueShape1 = arr->shape[1]; - outArray->glmType = PyGLM_TYPE_VEC; outArray->shape[0] = arr->shape[1]; outArray->shape[1] = 0; @@ -5318,8 +5320,6 @@ static PyObject* glmArray_mulO_T(glmArray* arr, T* o, Py_ssize_t o_size, PyGLMTy arrStride = arr->shape[1]; oStride = pto->R; - trueShape1 = arr->shape[1]; - outArray->glmType = PyGLM_TYPE_MAT; outArray->shape[0] = pto->C; outArray->shape[1] = arr->shape[1]; @@ -5346,13 +5346,14 @@ static PyObject* glmArray_mulO_T(glmArray* arr, T* o, Py_ssize_t o_size, PyGLMTy for (Py_ssize_t j = 0; j < outArrayRatio; j++) { T result = (T)0; for (Py_ssize_t k = 0; k < n; k++) { - T a = arrDataPtr[k * arrStride + j % trueShape1]; - T b = o[k + (j / trueShape1) * oStride]; + T a = arrDataPtr[k * arrStride + j % arrStride]; + T b = o[k + (j / arrStride) * oStride]; result = result + a * b; } outArrayDataPtr[outArrayIndex++] = result; } + arrDataPtr = reinterpret_cast(reinterpret_cast(arrDataPtr) + arr->itemSize); } return (PyObject*)outArray; @@ -5441,6 +5442,7 @@ static PyObject* glmArray_rmulO_T(glmArray* arr, T* o, Py_ssize_t o_size, PyGLMT } outArrayDataPtr[outArrayIndex++] = result; } + arrDataPtr = reinterpret_cast(reinterpret_cast(arrDataPtr) + arr->itemSize); } return (PyObject*)outArray; diff --git a/PyGLM/type_methods/mat.h b/PyGLM_lib/PyGLM/type_methods/mat.h similarity index 99% rename from PyGLM/type_methods/mat.h rename to PyGLM_lib/PyGLM/type_methods/mat.h index 7f9177f2..b403e9bb 100644 --- a/PyGLM/type_methods/mat.h +++ b/PyGLM_lib/PyGLM/type_methods/mat.h @@ -1375,7 +1375,7 @@ mat_mul(PyObject *obj1, PyObject *obj2) if (PyGLM_Vec_PTI_Check0(R, T, obj1)) { // obj1 is a col_type glm::vec o = PyGLM_Vec_PTI_Get0(R, T, obj1); - return pack_vec(o * ((mat*)obj2)->super_type); + return pack_vec(glm::custom::mat_mul(o, ((mat*)obj2)->super_type)); } if (!PyGLM_Mat_PTI_Check0(C, R, T, obj1)) { // obj1 can't be interpreted as mat @@ -1394,7 +1394,7 @@ mat_mul(PyObject *obj1, PyObject *obj2) if (PyGLM_Vec_PTI_Check0(C, T, obj2)) { // obj2 is a row_type glm::vec o2 = PyGLM_Vec_PTI_Get0(C, T, obj2); - return pack_vec(o * o2); + return pack_vec(glm::custom::mat_mul(o, o2)); } if (PyGLM_Mat_PTI_Check0(2, C, T, obj2)) { @@ -2877,7 +2877,7 @@ mat_getbuffer(mat* self, Py_buffer* view, int flags) { return 0; } -void +static void mat_releasebuffer(PyObject*, Py_buffer* view) { PyMem_Free(view->shape); PyMem_Free(view->strides); diff --git a/PyGLM/type_methods/mvec.h b/PyGLM_lib/PyGLM/type_methods/mvec.h similarity index 94% rename from PyGLM/type_methods/mvec.h rename to PyGLM_lib/PyGLM/type_methods/mvec.h index 17c6bcfc..24d22070 100644 --- a/PyGLM/type_methods/mvec.h +++ b/PyGLM_lib/PyGLM/type_methods/mvec.h @@ -6,6 +6,8 @@ #include "../types/mvec/all.h" +#include "vec.h" + static void mvec_dealloc(PyObject* self) { @@ -222,6 +224,49 @@ mvec_div(PyObject *obj1, PyObject *obj2) return pack_vec(o / o2); } +template +static PyObject * +imvec_floordiv(PyObject *obj1, PyObject *obj2) +{ + if (PyGLM_Number_Check(obj1)) { // obj1 is a scalar, obj2 is self + PyObject* temp = pack_vec(glm::vec(PyGLM_Number_FromPyObject(obj1))); + PyObject* result = imvec_floordiv(temp, obj2); + Py_DECREF(temp); + return result; + } + + if (PyGLM_Number_Check(obj2)) { // obj2 is a scalar, obj1 is self + PyObject* temp = pack_vec(glm::vec(PyGLM_Number_FromPyObject(obj2))); + PyObject* result = imvec_floordiv(obj1, temp); + Py_DECREF(temp); + return result; + } + + PyGLM_PTI_Init0(obj1, (get_vec_PTI_info())); + + if (PyGLM_PTI_IsNone(0)) { // obj1 is not supported. + PyGLM_TYPEERROR_O("unsupported operand type(s) for /: 'glm.vec' and ", obj1); + return NULL; + } + + glm::vec o = PyGLM_Vec_PTI_Get0(L, T, obj1); + + PyGLM_PTI_Init1(obj2, (get_vec_PTI_info())); + + if (PyGLM_PTI_IsNone(1)) { // obj1 is self, obj2 is something else + Py_RETURN_NOTIMPLEMENTED; + } + + glm::vec o2 = PyGLM_Vec_PTI_Get1(L, T, obj2); + + if (!glm::all((glm::vec)o2)) { + PyGLM_ZERO_DIVISION_ERROR_T(T); + } + + // obj1 and obj2 can be interpreted as a mvec + return pack_vec(ivec_floordivmod(o, o2)); +} + template static PyObject * mvec_mod(PyObject *obj1, PyObject *obj2) @@ -683,6 +728,21 @@ mvec_ifloordiv(mvec *self, PyObject *obj) return (PyObject*)self; } +template +static PyObject * +imvec_ifloordiv(mvec *self, PyObject *obj) +{ + vec * temp = (vec*)imvec_floordiv((PyObject*)self, obj); + + if (Py_IS_NOTIMPLEMENTED(temp)) return (PyObject*)temp; + + *self->super_type = temp->super_type; + + Py_DECREF(temp); + Py_INCREF(self); + return (PyObject*)self; +} + template static PyObject* mvec_imatmul(mvec* self, PyObject* obj) @@ -1148,23 +1208,31 @@ static T& unswizzle2_mvec(mvec<4, T> * self, char c, bool& success) { template static PyObject * mvec_getattr(PyObject * obj, PyObject * name) { - char * name_as_ccp = PyGLM_String_AsString(name); - size_t len = strlen(name_as_ccp); - + Py_ssize_t len; + char* name_as_ccp; + PyObject* asciiString = PyUnicode_AsASCIIString(name); + if (asciiString == NULL) + return NULL; + if (PyBytes_AsStringAndSize(asciiString, &name_as_ccp, &len) != 0) { + Py_DECREF(asciiString); + return NULL; + } + + PyObject * result = NULL; if (len >= 4 && name_as_ccp[0] == '_' && name_as_ccp[1] == '_' && name_as_ccp[len - 1] == '_' && name_as_ccp[len - 2] == '_') { - return PyObject_GenericGetAttr(obj, name); + result = PyObject_GenericGetAttr(obj, name); } - if (len == 1) { + else if (len == 1) { T x; if (unswizzle_mvec((mvec *)obj, name_as_ccp[0], x)) { - return PyGLM_PyObject_FromNumber((T)x); + result = PyGLM_PyObject_FromNumber((T)x); } } else if (len == 2) { T x; T y; if (unswizzle_mvec((mvec *)obj, name_as_ccp[0], x) && unswizzle_mvec((mvec *)obj, name_as_ccp[1], y)) { - return pack_vec<2, T>(glm::vec<2, T>(x, y)); + result = pack_vec<2, T>(glm::vec<2, T>(x, y)); } } else if (len == 3) { @@ -1172,7 +1240,7 @@ static PyObject * mvec_getattr(PyObject * obj, PyObject * name) { T y; T z; if (unswizzle_mvec((mvec *)obj, name_as_ccp[0], x) && unswizzle_mvec((mvec *)obj, name_as_ccp[1], y) && unswizzle_mvec((mvec *)obj, name_as_ccp[2], z)) { - return pack_vec<3, T>(glm::vec<3, T>(x, y, z)); + result = pack_vec<3, T>(glm::vec<3, T>(x, y, z)); } } else if (len == 4) { @@ -1181,10 +1249,12 @@ static PyObject * mvec_getattr(PyObject * obj, PyObject * name) { T z; T w; if (unswizzle_mvec((mvec *)obj, name_as_ccp[0], x) && unswizzle_mvec((mvec *)obj, name_as_ccp[1], y) && unswizzle_mvec((mvec *)obj, name_as_ccp[2], z) && unswizzle_mvec((mvec *)obj, name_as_ccp[3], w)) { - return pack_vec<4, T>(glm::vec<4, T>(x, y, z, w)); + result = pack_vec<4, T>(glm::vec<4, T>(x, y, z, w)); } } - return PyObject_GenericGetAttr(obj, name); + Py_DECREF(asciiString); + if (result == NULL) return PyObject_GenericGetAttr(obj, name); + else return result; } template @@ -1194,17 +1264,17 @@ static int mvec_setattr(PyObject * obj, PyObject * name, PyObject* value) { return -1; } - char * name_as_ccp = PyGLM_String_AsString(name); + PyObject* asciiString = PyUnicode_AsASCIIString(name); + char* name_as_ccp = PyBytes_AsString(asciiString); size_t len = strlen(name_as_ccp); + bool success = true; if (PyGLM_Number_Check(value)) { T v = PyGLM_Number_FromPyObject(value); - bool success = true; if (len == 1) { T& x = unswizzle2_mvec((mvec*)obj, name_as_ccp[0], success); if (success) { x = v; - return 0; } } else if (len == 2) { @@ -1213,7 +1283,6 @@ static int mvec_setattr(PyObject * obj, PyObject * name, PyObject* value) { if (success) { x = v; y = v; - return 0; } } else if (len == 3) { @@ -1224,7 +1293,6 @@ static int mvec_setattr(PyObject * obj, PyObject * name, PyObject* value) { x = v; y = v; z = v; - return 0; } } else if (len == 4) { @@ -1237,7 +1305,6 @@ static int mvec_setattr(PyObject * obj, PyObject * name, PyObject* value) { y = v; z = v; w = v; - return 0; } } } @@ -1245,27 +1312,22 @@ static int mvec_setattr(PyObject * obj, PyObject * name, PyObject* value) { PyGLM_PTI_Init0(value, PyGLM_T_VEC | PyGLM_SHAPE_ALL | PyGLM_PTI_GetDT(T)); if (len == 1 && PyGLM_Vec_PTI_Check0(1, T, value)) { glm::vec<1, T> v = PyGLM_Vec_PTI_Get0(1, T, value); - bool success = true; T& x = unswizzle2_mvec((mvec*)obj, name_as_ccp[0], success); if (success) { x = v.x; - return 0; } } else if (len == 2 && PyGLM_Vec_PTI_Check0(2, T, value)) { glm::vec<2, T> v = PyGLM_Vec_PTI_Get0(2, T, value); - bool success = true; T& x = unswizzle2_mvec((mvec*)obj, name_as_ccp[0], success); T& y = unswizzle2_mvec((mvec*)obj, name_as_ccp[1], success); if (success) { x = v.x; y = v.y; - return 0; } } else if (len == 3 && PyGLM_Vec_PTI_Check0(3, T, value)) { glm::vec<3, T> v = PyGLM_Vec_PTI_Get0(3, T, value); - bool success = true; T& x = unswizzle2_mvec((mvec*)obj, name_as_ccp[0], success); T& y = unswizzle2_mvec((mvec*)obj, name_as_ccp[1], success); T& z = unswizzle2_mvec((mvec*)obj, name_as_ccp[2], success); @@ -1273,12 +1335,10 @@ static int mvec_setattr(PyObject * obj, PyObject * name, PyObject* value) { x = v.x; y = v.y; z = v.z; - return 0; } } else if (len == 4 && PyGLM_Vec_PTI_Check0(4, T, value)) { glm::vec<4, T> v = PyGLM_Vec_PTI_Get0(4, T, value); - bool success = true; T& x = unswizzle2_mvec((mvec*)obj, name_as_ccp[0], success); T& y = unswizzle2_mvec((mvec*)obj, name_as_ccp[1], success); T& z = unswizzle2_mvec((mvec*)obj, name_as_ccp[2], success); @@ -1288,12 +1348,13 @@ static int mvec_setattr(PyObject * obj, PyObject * name, PyObject* value) { y = v.y; z = v.z; w = v.w; - return 0; } } } - return PyObject_GenericSetAttr(obj, name, value); + Py_DECREF(asciiString); + if (success) return 0; + else return PyObject_GenericSetAttr(obj, name, value); } // iterator @@ -1439,7 +1500,7 @@ mvec_getbuffer(mvec* self, Py_buffer* view, int flags) { return 0; } -void +static void mvec_releasebuffer(PyObject*, Py_buffer* view) { PyMem_Free(view->shape); } @@ -1569,4 +1630,4 @@ mvec_deepcopy(PyObject* self, PyObject* memo) { PyObject* copy = mvec_copy(self, NULL); PyDict_SetItem(memo, PyLong_FromVoidPtr((void*)self), copy); return copy; -} \ No newline at end of file +} diff --git a/PyGLM/type_methods/qua.h b/PyGLM_lib/PyGLM/type_methods/qua.h similarity index 99% rename from PyGLM/type_methods/qua.h rename to PyGLM_lib/PyGLM/type_methods/qua.h index e336d12c..867ab716 100644 --- a/PyGLM/type_methods/qua.h +++ b/PyGLM_lib/PyGLM/type_methods/qua.h @@ -547,7 +547,7 @@ qua_getbuffer(qua* self, Py_buffer* view, int flags) { return 0; } -void +static void qua_releasebuffer(PyObject*, Py_buffer* view) { PyMem_Free(view->shape); } diff --git a/PyGLM/type_methods/vec.h b/PyGLM_lib/PyGLM/type_methods/vec.h similarity index 95% rename from PyGLM/type_methods/vec.h rename to PyGLM_lib/PyGLM/type_methods/vec.h index 837c12b2..1374ab4b 100644 --- a/PyGLM/type_methods/vec.h +++ b/PyGLM_lib/PyGLM/type_methods/vec.h @@ -719,6 +719,70 @@ vec_div(PyObject *obj1, PyObject *obj2) return pack_vec(o / o2); } +template +static glm::vec +ivec_floordivmod(glm::vec a, glm::vec b) { + const glm::vec u = glm::abs(a); + const glm::vec v = glm::abs(b); + + glm::vec result; + + for (int i = 0; i < L; i++) { + T q = u[i] / v[i]; + T r = u[i] % v[i]; + if ((a[i] < 0) != (b[i] < 0)) { + result[i] = -(q + (r > 0)); + } else { + result[i] = q; + } + } + + return result; +} + +template +static PyObject * +ivec_floordiv(PyObject *obj1, PyObject *obj2) +{ + if (PyGLM_Number_Check(obj1)) { // obj1 is a scalar, obj2 is self + PyObject* temp = pack_vec(glm::vec(PyGLM_Number_FromPyObject(obj1))); + PyObject* result = ivec_floordiv(temp, obj2); + Py_DECREF(temp); + return result; + } + + if (PyGLM_Number_Check(obj2)) { // obj1 is self, obj2 is a scalar + PyObject* temp = pack_vec(glm::vec(PyGLM_Number_FromPyObject(obj2))); + PyObject* result = ivec_floordiv(obj1, temp); + Py_DECREF(temp); + return result; + } + + PyGLM_PTI_Init0(obj1, (get_vec_PTI_info())); + + if (PyGLM_PTI_IsNone(0)) { // obj1 is not supported. + PyGLM_TYPEERROR_O("unsupported operand type(s) for /: 'glm.vec' and ", obj1); + return NULL; + } + + glm::vec o = PyGLM_Vec_PTI_Get0(L, T, obj1); + + PyGLM_PTI_Init1(obj2, (get_vec_PTI_info())); + + if (PyGLM_PTI_IsNone(1)) { // obj1 is self, obj2 is something else + Py_RETURN_NOTIMPLEMENTED; + } + + glm::vec o2 = PyGLM_Vec_PTI_Get1(L, T, obj2); + + if (!glm::all((glm::vec)o2)) { + PyGLM_ZERO_DIVISION_ERROR_T(T); + } + + // obj1 and obj2 can be interpreted as a vec + return pack_vec(ivec_floordivmod(o, o2)); +} + template static inline glm::vec vec_mod_f(glm::vec a, glm::vec b) { @@ -1102,10 +1166,19 @@ vec_pow(PyObject * obj1, PyObject * obj2, PyObject * obj3) { return pack_vec(glm::mod(glm::pow(o, o2), o3)); } +static PyObject* dot_(PyObject*, PyObject* args); + static PyObject* vec_matmul(PyObject* obj1, PyObject* obj2) { - PyObject* out = PyNumber_Multiply(obj1, obj2); + PyObject* args = PyTuple_New(2); + PyTuple_SET_ITEM(args, 0, PyGLM_INCREF(obj1)); + PyTuple_SET_ITEM(args, 1, PyGLM_INCREF(obj2)); + + PyObject* out = dot_(NULL, args); + + Py_DECREF(args); + if (out == NULL) { PyGLM_TYPEERROR_2O("unsupported operand type(s) for @: ", obj1, obj2); } @@ -1234,6 +1307,21 @@ vec_ifloordiv(vec *self, PyObject *obj) return (PyObject*)self; } +template +static PyObject * +ivec_ifloordiv(vec *self, PyObject *obj) +{ + vec * temp = (vec*)ivec_floordiv((PyObject*)self, obj); + + if (Py_IS_NOTIMPLEMENTED(temp)) return (PyObject*)temp; + + self->super_type = temp->super_type; + + Py_DECREF(temp); + Py_INCREF(self); + return (PyObject*)self; +} + template static PyObject* vec_imatmul(vec* self, PyObject* obj) @@ -1799,23 +1887,31 @@ static T& unswizzle2_vec(vec<4, T> * self, char c, bool& success) { template static PyObject * vec_getattr(PyObject * obj, PyObject * name) { - char * name_as_ccp = PyGLM_String_AsString(name); - size_t len = strlen(name_as_ccp); + Py_ssize_t len; + char* name_as_ccp; + PyObject* asciiString = PyUnicode_AsASCIIString(name); + if (asciiString == NULL) + return NULL; + if (PyBytes_AsStringAndSize(asciiString, &name_as_ccp, &len) != 0) { + Py_DECREF(asciiString); + return NULL; + } + PyObject * result = NULL; if (len >= 4 && name_as_ccp[0] == '_' && name_as_ccp[1] == '_' && name_as_ccp[len - 1] == '_' && name_as_ccp[len - 2] == '_') { - return PyObject_GenericGetAttr(obj, name); + result = PyObject_GenericGetAttr(obj, name); } - if (len == 1) { + else if (len == 1) { T x; if (unswizzle_vec((vec *)obj, name_as_ccp[0], x)) { - return PyGLM_PyObject_FromNumber((T)x); + result = PyGLM_PyObject_FromNumber((T)x); } } else if (len == 2) { T x; T y; if (unswizzle_vec((vec *)obj, name_as_ccp[0], x) && unswizzle_vec((vec *)obj, name_as_ccp[1], y)) { - return pack_vec<2, T>(glm::vec<2, T>(x, y)); + result = pack_vec<2, T>(glm::vec<2, T>(x, y)); } } else if (len == 3) { @@ -1823,7 +1919,7 @@ static PyObject * vec_getattr(PyObject * obj, PyObject * name) { T y; T z; if (unswizzle_vec((vec *)obj, name_as_ccp[0], x) && unswizzle_vec((vec *)obj, name_as_ccp[1], y) && unswizzle_vec((vec *)obj, name_as_ccp[2], z)) { - return pack_vec<3, T>(glm::vec<3, T>(x, y, z)); + result = pack_vec<3, T>(glm::vec<3, T>(x, y, z)); } } else if (len == 4) { @@ -1832,10 +1928,12 @@ static PyObject * vec_getattr(PyObject * obj, PyObject * name) { T z; T w; if (unswizzle_vec((vec *)obj, name_as_ccp[0], x) && unswizzle_vec((vec *)obj, name_as_ccp[1], y) && unswizzle_vec((vec *)obj, name_as_ccp[2], z) && unswizzle_vec((vec *)obj, name_as_ccp[3], w)) { - return pack_vec<4, T>(glm::vec<4, T>(x, y, z, w)); + result = pack_vec<4, T>(glm::vec<4, T>(x, y, z, w)); } } - return PyObject_GenericGetAttr(obj, name); + Py_DECREF(asciiString); + if (result == NULL) return PyObject_GenericGetAttr(obj, name); + else return result; } template @@ -1846,21 +1944,17 @@ static int vec_setattr(PyObject * obj, PyObject * name, PyObject* value) { return -1; } - char * name_as_ccp = PyGLM_String_AsString(name); + PyObject* asciiString = PyUnicode_AsASCIIString(name); + char* name_as_ccp = PyBytes_AsString(asciiString); size_t len = strlen(name_as_ccp); - //if (len >= 4 && name_as_ccp[0] == '_' && name_as_ccp[1] == '_' && name_as_ccp[len - 1] == '_' && name_as_ccp[len - 2] == '_') { - // return PyObject_GenericGetAttr(obj, name); - //} - + bool success = true; if (PyGLM_Number_Check(value)) { T v = PyGLM_Number_FromPyObject(value); - bool success = true; if (len == 1) { T& x = unswizzle2_vec((vec*)obj, name_as_ccp[0], success); if (success) { x = v; - return 0; } } else if (len == 2) { @@ -1869,7 +1963,6 @@ static int vec_setattr(PyObject * obj, PyObject * name, PyObject* value) { if (success) { x = v; y = v; - return 0; } } else if (len == 3) { @@ -1880,7 +1973,6 @@ static int vec_setattr(PyObject * obj, PyObject * name, PyObject* value) { x = v; y = v; z = v; - return 0; } } else if (len == 4) { @@ -1893,7 +1985,6 @@ static int vec_setattr(PyObject * obj, PyObject * name, PyObject* value) { y = v; z = v; w = v; - return 0; } } } @@ -1901,27 +1992,22 @@ static int vec_setattr(PyObject * obj, PyObject * name, PyObject* value) { PyGLM_PTI_Init0(value, PyGLM_T_VEC | PyGLM_SHAPE_ALL | PyGLM_PTI_GetDT(T)); if (len == 1 && PyGLM_Vec_PTI_Check0(1, T, value)) { glm::vec<1, T> v = PyGLM_Vec_PTI_Get0(1, T, value); - bool success = true; T& x = unswizzle2_vec((vec*)obj, name_as_ccp[0], success); if (success) { x = v.x; - return 0; } } else if (len == 2 && PyGLM_Vec_PTI_Check0(2, T, value)) { glm::vec<2, T> v = PyGLM_Vec_PTI_Get0(2, T, value); - bool success = true; T& x = unswizzle2_vec((vec*)obj, name_as_ccp[0], success); T& y = unswizzle2_vec((vec*)obj, name_as_ccp[1], success); if (success) { x = v.x; y = v.y; - return 0; } } else if (len == 3 && PyGLM_Vec_PTI_Check0(3, T, value)) { glm::vec<3, T> v = PyGLM_Vec_PTI_Get0(3, T, value); - bool success = true; T& x = unswizzle2_vec((vec*)obj, name_as_ccp[0], success); T& y = unswizzle2_vec((vec*)obj, name_as_ccp[1], success); T& z = unswizzle2_vec((vec*)obj, name_as_ccp[2], success); @@ -1929,12 +2015,10 @@ static int vec_setattr(PyObject * obj, PyObject * name, PyObject* value) { x = v.x; y = v.y; z = v.z; - return 0; } } else if (len == 4 && PyGLM_Vec_PTI_Check0(4, T, value)) { glm::vec<4, T> v = PyGLM_Vec_PTI_Get0(4, T, value); - bool success = true; T& x = unswizzle2_vec((vec*)obj, name_as_ccp[0], success); T& y = unswizzle2_vec((vec*)obj, name_as_ccp[1], success); T& z = unswizzle2_vec((vec*)obj, name_as_ccp[2], success); @@ -1944,11 +2028,12 @@ static int vec_setattr(PyObject * obj, PyObject * name, PyObject* value) { y = v.y; z = v.z; w = v.w; - return 0; } } } - return PyObject_GenericSetAttr(obj, name, value); + Py_DECREF(asciiString); + if (success) return 0; + else return PyObject_GenericSetAttr(obj, name, value); } // iterator @@ -2113,7 +2198,7 @@ vec_getbuffer(vec* self, Py_buffer* view, int flags) { return 0; } -void +static void vec_releasebuffer(PyObject*, Py_buffer* view) { PyMem_Free(view->shape); } @@ -2250,4 +2335,4 @@ static PyObject* vec4_setstate(vec<4, T>* self, PyObject* state) { self->super_type.z = PyGLM_Number_FromPyObject(PyTuple_GET_ITEM(state, 2)); self->super_type.w = PyGLM_Number_FromPyObject(PyTuple_GET_ITEM(state, 3)); Py_RETURN_NONE; -} \ No newline at end of file +} diff --git a/PyGLM/types/all.h b/PyGLM_lib/PyGLM/types/all.h similarity index 100% rename from PyGLM/types/all.h rename to PyGLM_lib/PyGLM/types/all.h diff --git a/PyGLM/types/forward_declarations.h b/PyGLM_lib/PyGLM/types/forward_declarations.h similarity index 100% rename from PyGLM/types/forward_declarations.h rename to PyGLM_lib/PyGLM/types/forward_declarations.h diff --git a/PyGLM/types/glmArray/forward_declarations.h b/PyGLM_lib/PyGLM/types/glmArray/forward_declarations.h similarity index 98% rename from PyGLM/types/glmArray/forward_declarations.h rename to PyGLM_lib/PyGLM/types/glmArray/forward_declarations.h index f3d6ac1f..f0742747 100644 --- a/PyGLM/types/glmArray/forward_declarations.h +++ b/PyGLM_lib/PyGLM/types/glmArray/forward_declarations.h @@ -5,7 +5,7 @@ static int glmArray_getbuffer(glmArray* self, Py_buffer* view, int flags); -void glmArray_releasebuffer(PyObject* self, Py_buffer* view); +static void glmArray_releasebuffer(PyObject* self, Py_buffer* view); PyDoc_STRVAR(glmArray_to_bytes_docstr, "Return the data of this array as a bytes string" @@ -176,6 +176,10 @@ PyDoc_STRVAR(glmArray_setstate_docstr, static PyObject* glmArray_setstate(glmArray* self, PyObject* state); +PyDoc_STRVAR(glmArray_class_getitem_docstr, + "See PEP 585" +); + PyDoc_STRVAR(glmArray_filter_docstr, "filter(func: callable) -> array\n" " Filters this array with the given funtion and returns the resulting array.\n" diff --git a/PyGLM/types/glmArray/glmArray.h b/PyGLM_lib/PyGLM/types/glmArray/glmArray.h similarity index 97% rename from PyGLM/types/glmArray/glmArray.h rename to PyGLM_lib/PyGLM/types/glmArray/glmArray.h index c882b048..fa6a5daf 100644 --- a/PyGLM/types/glmArray/glmArray.h +++ b/PyGLM_lib/PyGLM/types/glmArray/glmArray.h @@ -28,6 +28,9 @@ static PyMethodDef glmArray_methods[] = { { "__deepcopy__", (PyCFunction)generic_deepcopy, METH_O, generic_deepcopy_docstr }, { "__getstate__", (PyCFunction)glmArray_getstate, METH_NOARGS, glmArray_getstate_docstr }, { "__setstate__", (PyCFunction)glmArray_setstate, METH_O, glmArray_setstate_docstr }, +#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 9 + { "__class_getitem__", Py_GenericAlias, METH_O | METH_CLASS, glmArray_class_getitem_docstr }, +#endif { "to_bytes", (PyCFunction)glmArray_to_bytes, METH_NOARGS, glmArray_to_bytes_docstr }, { "from_bytes", (PyCFunction)glmArray_from_bytes, METH_VARARGS | METH_STATIC, glmArray_from_bytes_docstr }, { "reinterpret_cast",(PyCFunction)glmArray_reinterpret_cast,METH_O, glmArray_reinterpret_cast_docstr }, @@ -110,7 +113,7 @@ static PyNumberMethods glmArrayNumMethods = { }; static PyTypeObject glmArrayType = { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.array", // tp_name sizeof(glmArray), // tp_basicsize 0, // tp_itemsize diff --git a/PyGLM/types/mat/all.h b/PyGLM_lib/PyGLM/types/mat/all.h similarity index 100% rename from PyGLM/types/mat/all.h rename to PyGLM_lib/PyGLM/types/mat/all.h diff --git a/PyGLM/types/mat/double/all.h b/PyGLM_lib/PyGLM/types/mat/double/all.h similarity index 100% rename from PyGLM/types/mat/double/all.h rename to PyGLM_lib/PyGLM/types/mat/double/all.h diff --git a/PyGLM/types/mat/double/mat2x2.h b/PyGLM_lib/PyGLM/types/mat/double/mat2x2.h similarity index 99% rename from PyGLM/types/mat/double/mat2x2.h rename to PyGLM_lib/PyGLM/types/mat/double/mat2x2.h index bee12ef7..0b215e83 100644 --- a/PyGLM/types/mat/double/mat2x2.h +++ b/PyGLM_lib/PyGLM/types/mat/double/mat2x2.h @@ -116,7 +116,7 @@ static PyTypeObject hdmat2x2IterType = { static PyGLMTypeObject hdmat2x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmat2x2", /* tp_name */ sizeof(mat<2, 2, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/double/mat2x3.h b/PyGLM_lib/PyGLM/types/mat/double/mat2x3.h similarity index 99% rename from PyGLM/types/mat/double/mat2x3.h rename to PyGLM_lib/PyGLM/types/mat/double/mat2x3.h index 3e1e4845..0c1ec257 100644 --- a/PyGLM/types/mat/double/mat2x3.h +++ b/PyGLM_lib/PyGLM/types/mat/double/mat2x3.h @@ -116,7 +116,7 @@ static PyTypeObject hdmat2x3IterType = { static PyGLMTypeObject hdmat2x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmat2x3", /* tp_name */ sizeof(mat<2, 3, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/double/mat2x4.h b/PyGLM_lib/PyGLM/types/mat/double/mat2x4.h similarity index 99% rename from PyGLM/types/mat/double/mat2x4.h rename to PyGLM_lib/PyGLM/types/mat/double/mat2x4.h index 4681f114..f348c4b1 100644 --- a/PyGLM/types/mat/double/mat2x4.h +++ b/PyGLM_lib/PyGLM/types/mat/double/mat2x4.h @@ -116,7 +116,7 @@ static PyTypeObject hdmat2x4IterType = { static PyGLMTypeObject hdmat2x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmat2x4", /* tp_name */ sizeof(mat<2, 4, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/double/mat3x2.h b/PyGLM_lib/PyGLM/types/mat/double/mat3x2.h similarity index 99% rename from PyGLM/types/mat/double/mat3x2.h rename to PyGLM_lib/PyGLM/types/mat/double/mat3x2.h index a7ad851a..76d0e6f6 100644 --- a/PyGLM/types/mat/double/mat3x2.h +++ b/PyGLM_lib/PyGLM/types/mat/double/mat3x2.h @@ -116,7 +116,7 @@ static PyTypeObject hdmat3x2IterType = { static PyGLMTypeObject hdmat3x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmat3x2", /* tp_name */ sizeof(mat<3, 2, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/double/mat3x3.h b/PyGLM_lib/PyGLM/types/mat/double/mat3x3.h similarity index 99% rename from PyGLM/types/mat/double/mat3x3.h rename to PyGLM_lib/PyGLM/types/mat/double/mat3x3.h index afcf310d..ea76ede7 100644 --- a/PyGLM/types/mat/double/mat3x3.h +++ b/PyGLM_lib/PyGLM/types/mat/double/mat3x3.h @@ -116,7 +116,7 @@ static PyTypeObject hdmat3x3IterType = { static PyGLMTypeObject hdmat3x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmat3x3", /* tp_name */ sizeof(mat<3, 3, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/double/mat3x4.h b/PyGLM_lib/PyGLM/types/mat/double/mat3x4.h similarity index 99% rename from PyGLM/types/mat/double/mat3x4.h rename to PyGLM_lib/PyGLM/types/mat/double/mat3x4.h index 9813ca23..6bb6835c 100644 --- a/PyGLM/types/mat/double/mat3x4.h +++ b/PyGLM_lib/PyGLM/types/mat/double/mat3x4.h @@ -116,7 +116,7 @@ static PyTypeObject hdmat3x4IterType = { static PyGLMTypeObject hdmat3x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmat3x4", /* tp_name */ sizeof(mat<3, 4, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/double/mat4x2.h b/PyGLM_lib/PyGLM/types/mat/double/mat4x2.h similarity index 99% rename from PyGLM/types/mat/double/mat4x2.h rename to PyGLM_lib/PyGLM/types/mat/double/mat4x2.h index 639e19e0..5fd7d08a 100644 --- a/PyGLM/types/mat/double/mat4x2.h +++ b/PyGLM_lib/PyGLM/types/mat/double/mat4x2.h @@ -116,7 +116,7 @@ static PyTypeObject hdmat4x2IterType = { static PyGLMTypeObject hdmat4x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmat4x2", /* tp_name */ sizeof(mat<4, 2, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/double/mat4x3.h b/PyGLM_lib/PyGLM/types/mat/double/mat4x3.h similarity index 99% rename from PyGLM/types/mat/double/mat4x3.h rename to PyGLM_lib/PyGLM/types/mat/double/mat4x3.h index 96864e00..b78c89c9 100644 --- a/PyGLM/types/mat/double/mat4x3.h +++ b/PyGLM_lib/PyGLM/types/mat/double/mat4x3.h @@ -116,7 +116,7 @@ static PyTypeObject hdmat4x3IterType = { static PyGLMTypeObject hdmat4x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmat4x3", /* tp_name */ sizeof(mat<4, 3, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/double/mat4x4.h b/PyGLM_lib/PyGLM/types/mat/double/mat4x4.h similarity index 99% rename from PyGLM/types/mat/double/mat4x4.h rename to PyGLM_lib/PyGLM/types/mat/double/mat4x4.h index b5516d96..34ece325 100644 --- a/PyGLM/types/mat/double/mat4x4.h +++ b/PyGLM_lib/PyGLM/types/mat/double/mat4x4.h @@ -116,7 +116,7 @@ static PyTypeObject hdmat4x4IterType = { static PyGLMTypeObject hdmat4x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmat4x4", /* tp_name */ sizeof(mat<4, 4, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/float/all.h b/PyGLM_lib/PyGLM/types/mat/float/all.h similarity index 100% rename from PyGLM/types/mat/float/all.h rename to PyGLM_lib/PyGLM/types/mat/float/all.h diff --git a/PyGLM/types/mat/float/mat2x2.h b/PyGLM_lib/PyGLM/types/mat/float/mat2x2.h similarity index 99% rename from PyGLM/types/mat/float/mat2x2.h rename to PyGLM_lib/PyGLM/types/mat/float/mat2x2.h index 233574ad..175b5bc2 100644 --- a/PyGLM/types/mat/float/mat2x2.h +++ b/PyGLM_lib/PyGLM/types/mat/float/mat2x2.h @@ -116,7 +116,7 @@ static PyTypeObject hfmat2x2IterType = { static PyGLMTypeObject hfmat2x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mat2x2", /* tp_name */ sizeof(mat<2, 2, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/float/mat2x3.h b/PyGLM_lib/PyGLM/types/mat/float/mat2x3.h similarity index 99% rename from PyGLM/types/mat/float/mat2x3.h rename to PyGLM_lib/PyGLM/types/mat/float/mat2x3.h index 27e2bafc..be8d8f92 100644 --- a/PyGLM/types/mat/float/mat2x3.h +++ b/PyGLM_lib/PyGLM/types/mat/float/mat2x3.h @@ -116,7 +116,7 @@ static PyTypeObject hfmat2x3IterType = { static PyGLMTypeObject hfmat2x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mat2x3", /* tp_name */ sizeof(mat<2, 3, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/float/mat2x4.h b/PyGLM_lib/PyGLM/types/mat/float/mat2x4.h similarity index 99% rename from PyGLM/types/mat/float/mat2x4.h rename to PyGLM_lib/PyGLM/types/mat/float/mat2x4.h index 3002083a..89b0e1ed 100644 --- a/PyGLM/types/mat/float/mat2x4.h +++ b/PyGLM_lib/PyGLM/types/mat/float/mat2x4.h @@ -116,7 +116,7 @@ static PyTypeObject hfmat2x4IterType = { static PyGLMTypeObject hfmat2x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mat2x4", /* tp_name */ sizeof(mat<2, 4, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/float/mat3x2.h b/PyGLM_lib/PyGLM/types/mat/float/mat3x2.h similarity index 99% rename from PyGLM/types/mat/float/mat3x2.h rename to PyGLM_lib/PyGLM/types/mat/float/mat3x2.h index 8c70e64a..1d5a2977 100644 --- a/PyGLM/types/mat/float/mat3x2.h +++ b/PyGLM_lib/PyGLM/types/mat/float/mat3x2.h @@ -116,7 +116,7 @@ static PyTypeObject hfmat3x2IterType = { static PyGLMTypeObject hfmat3x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mat3x2", /* tp_name */ sizeof(mat<3, 2, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/float/mat3x3.h b/PyGLM_lib/PyGLM/types/mat/float/mat3x3.h similarity index 99% rename from PyGLM/types/mat/float/mat3x3.h rename to PyGLM_lib/PyGLM/types/mat/float/mat3x3.h index f2a5ca96..58379046 100644 --- a/PyGLM/types/mat/float/mat3x3.h +++ b/PyGLM_lib/PyGLM/types/mat/float/mat3x3.h @@ -116,7 +116,7 @@ static PyTypeObject hfmat3x3IterType = { static PyGLMTypeObject hfmat3x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mat3x3", /* tp_name */ sizeof(mat<3, 3, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/float/mat3x4.h b/PyGLM_lib/PyGLM/types/mat/float/mat3x4.h similarity index 99% rename from PyGLM/types/mat/float/mat3x4.h rename to PyGLM_lib/PyGLM/types/mat/float/mat3x4.h index 29fcf0f9..822c2ab8 100644 --- a/PyGLM/types/mat/float/mat3x4.h +++ b/PyGLM_lib/PyGLM/types/mat/float/mat3x4.h @@ -116,7 +116,7 @@ static PyTypeObject hfmat3x4IterType = { static PyGLMTypeObject hfmat3x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mat3x4", /* tp_name */ sizeof(mat<3, 4, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/float/mat4x2.h b/PyGLM_lib/PyGLM/types/mat/float/mat4x2.h similarity index 99% rename from PyGLM/types/mat/float/mat4x2.h rename to PyGLM_lib/PyGLM/types/mat/float/mat4x2.h index 5e5adc8c..1346b0d2 100644 --- a/PyGLM/types/mat/float/mat4x2.h +++ b/PyGLM_lib/PyGLM/types/mat/float/mat4x2.h @@ -116,7 +116,7 @@ static PyTypeObject hfmat4x2IterType = { static PyGLMTypeObject hfmat4x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mat4x2", /* tp_name */ sizeof(mat<4, 2, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/float/mat4x3.h b/PyGLM_lib/PyGLM/types/mat/float/mat4x3.h similarity index 99% rename from PyGLM/types/mat/float/mat4x3.h rename to PyGLM_lib/PyGLM/types/mat/float/mat4x3.h index 26591d9f..7d2c7a15 100644 --- a/PyGLM/types/mat/float/mat4x3.h +++ b/PyGLM_lib/PyGLM/types/mat/float/mat4x3.h @@ -116,7 +116,7 @@ static PyTypeObject hfmat4x3IterType = { static PyGLMTypeObject hfmat4x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mat4x3", /* tp_name */ sizeof(mat<4, 3, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/float/mat4x4.h b/PyGLM_lib/PyGLM/types/mat/float/mat4x4.h similarity index 99% rename from PyGLM/types/mat/float/mat4x4.h rename to PyGLM_lib/PyGLM/types/mat/float/mat4x4.h index ad8368ad..f7bd604b 100644 --- a/PyGLM/types/mat/float/mat4x4.h +++ b/PyGLM_lib/PyGLM/types/mat/float/mat4x4.h @@ -116,7 +116,7 @@ static PyTypeObject hfmat4x4IterType = { static PyGLMTypeObject hfmat4x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mat4x4", /* tp_name */ sizeof(mat<4, 4, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/forward_declarations.h b/PyGLM_lib/PyGLM/types/mat/forward_declarations.h similarity index 99% rename from PyGLM/types/mat/forward_declarations.h rename to PyGLM_lib/PyGLM/types/mat/forward_declarations.h index f759d7e9..4ab67239 100644 --- a/PyGLM/types/mat/forward_declarations.h +++ b/PyGLM_lib/PyGLM/types/mat/forward_declarations.h @@ -8,7 +8,7 @@ static PyObject* mat_length(PyObject * self, PyObject* arg); template static int mat_getbuffer(mat* self, Py_buffer* view, int flags); -void mat_releasebuffer(PyObject* self, Py_buffer* view); +static void mat_releasebuffer(PyObject* self, Py_buffer* view); template static Py_ssize_t mat_len(PyObject* self); diff --git a/PyGLM/types/mat/int/all.h b/PyGLM_lib/PyGLM/types/mat/int/all.h similarity index 100% rename from PyGLM/types/mat/int/all.h rename to PyGLM_lib/PyGLM/types/mat/int/all.h diff --git a/PyGLM/types/mat/int/mat2x2.h b/PyGLM_lib/PyGLM/types/mat/int/mat2x2.h similarity index 99% rename from PyGLM/types/mat/int/mat2x2.h rename to PyGLM_lib/PyGLM/types/mat/int/mat2x2.h index 699b9159..f289534f 100644 --- a/PyGLM/types/mat/int/mat2x2.h +++ b/PyGLM_lib/PyGLM/types/mat/int/mat2x2.h @@ -116,7 +116,7 @@ static PyTypeObject himat2x2IterType = { static PyGLMTypeObject himat2x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imat2x2", /* tp_name */ sizeof(mat<2, 2, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/int/mat2x3.h b/PyGLM_lib/PyGLM/types/mat/int/mat2x3.h similarity index 99% rename from PyGLM/types/mat/int/mat2x3.h rename to PyGLM_lib/PyGLM/types/mat/int/mat2x3.h index 49638d1b..fe21e84c 100644 --- a/PyGLM/types/mat/int/mat2x3.h +++ b/PyGLM_lib/PyGLM/types/mat/int/mat2x3.h @@ -116,7 +116,7 @@ static PyTypeObject himat2x3IterType = { static PyGLMTypeObject himat2x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imat2x3", /* tp_name */ sizeof(mat<2, 3, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/int/mat2x4.h b/PyGLM_lib/PyGLM/types/mat/int/mat2x4.h similarity index 99% rename from PyGLM/types/mat/int/mat2x4.h rename to PyGLM_lib/PyGLM/types/mat/int/mat2x4.h index 6f2f96bf..dc824207 100644 --- a/PyGLM/types/mat/int/mat2x4.h +++ b/PyGLM_lib/PyGLM/types/mat/int/mat2x4.h @@ -116,7 +116,7 @@ static PyTypeObject himat2x4IterType = { static PyGLMTypeObject himat2x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imat2x4", /* tp_name */ sizeof(mat<2, 4, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/int/mat3x2.h b/PyGLM_lib/PyGLM/types/mat/int/mat3x2.h similarity index 99% rename from PyGLM/types/mat/int/mat3x2.h rename to PyGLM_lib/PyGLM/types/mat/int/mat3x2.h index 77f316da..9c433ad2 100644 --- a/PyGLM/types/mat/int/mat3x2.h +++ b/PyGLM_lib/PyGLM/types/mat/int/mat3x2.h @@ -116,7 +116,7 @@ static PyTypeObject himat3x2IterType = { static PyGLMTypeObject himat3x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imat3x2", /* tp_name */ sizeof(mat<3, 2, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/int/mat3x3.h b/PyGLM_lib/PyGLM/types/mat/int/mat3x3.h similarity index 99% rename from PyGLM/types/mat/int/mat3x3.h rename to PyGLM_lib/PyGLM/types/mat/int/mat3x3.h index f192ea3d..ed7b2602 100644 --- a/PyGLM/types/mat/int/mat3x3.h +++ b/PyGLM_lib/PyGLM/types/mat/int/mat3x3.h @@ -116,7 +116,7 @@ static PyTypeObject himat3x3IterType = { static PyGLMTypeObject himat3x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imat3x3", /* tp_name */ sizeof(mat<3, 3, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/int/mat3x4.h b/PyGLM_lib/PyGLM/types/mat/int/mat3x4.h similarity index 99% rename from PyGLM/types/mat/int/mat3x4.h rename to PyGLM_lib/PyGLM/types/mat/int/mat3x4.h index 57e40249..bbe82bad 100644 --- a/PyGLM/types/mat/int/mat3x4.h +++ b/PyGLM_lib/PyGLM/types/mat/int/mat3x4.h @@ -116,7 +116,7 @@ static PyTypeObject himat3x4IterType = { static PyGLMTypeObject himat3x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imat3x4", /* tp_name */ sizeof(mat<3, 4, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/int/mat4x2.h b/PyGLM_lib/PyGLM/types/mat/int/mat4x2.h similarity index 99% rename from PyGLM/types/mat/int/mat4x2.h rename to PyGLM_lib/PyGLM/types/mat/int/mat4x2.h index 7320e5f2..0218d56a 100644 --- a/PyGLM/types/mat/int/mat4x2.h +++ b/PyGLM_lib/PyGLM/types/mat/int/mat4x2.h @@ -116,7 +116,7 @@ static PyTypeObject himat4x2IterType = { static PyGLMTypeObject himat4x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imat4x2", /* tp_name */ sizeof(mat<4, 2, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/int/mat4x3.h b/PyGLM_lib/PyGLM/types/mat/int/mat4x3.h similarity index 99% rename from PyGLM/types/mat/int/mat4x3.h rename to PyGLM_lib/PyGLM/types/mat/int/mat4x3.h index 36a59efc..736b36df 100644 --- a/PyGLM/types/mat/int/mat4x3.h +++ b/PyGLM_lib/PyGLM/types/mat/int/mat4x3.h @@ -116,7 +116,7 @@ static PyTypeObject himat4x3IterType = { static PyGLMTypeObject himat4x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imat4x3", /* tp_name */ sizeof(mat<4, 3, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/int/mat4x4.h b/PyGLM_lib/PyGLM/types/mat/int/mat4x4.h similarity index 99% rename from PyGLM/types/mat/int/mat4x4.h rename to PyGLM_lib/PyGLM/types/mat/int/mat4x4.h index 9fc7bd4c..57ab894e 100644 --- a/PyGLM/types/mat/int/mat4x4.h +++ b/PyGLM_lib/PyGLM/types/mat/int/mat4x4.h @@ -116,7 +116,7 @@ static PyTypeObject himat4x4IterType = { static PyGLMTypeObject himat4x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imat4x4", /* tp_name */ sizeof(mat<4, 4, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/uint/all.h b/PyGLM_lib/PyGLM/types/mat/uint/all.h similarity index 100% rename from PyGLM/types/mat/uint/all.h rename to PyGLM_lib/PyGLM/types/mat/uint/all.h diff --git a/PyGLM/types/mat/uint/float.h b/PyGLM_lib/PyGLM/types/mat/uint/float.h similarity index 100% rename from PyGLM/types/mat/uint/float.h rename to PyGLM_lib/PyGLM/types/mat/uint/float.h diff --git a/PyGLM/types/mat/uint/forward_declarations.h b/PyGLM_lib/PyGLM/types/mat/uint/forward_declarations.h similarity index 100% rename from PyGLM/types/mat/uint/forward_declarations.h rename to PyGLM_lib/PyGLM/types/mat/uint/forward_declarations.h diff --git a/PyGLM/types/mat/uint/mat2x2.h b/PyGLM_lib/PyGLM/types/mat/uint/mat2x2.h similarity index 99% rename from PyGLM/types/mat/uint/mat2x2.h rename to PyGLM_lib/PyGLM/types/mat/uint/mat2x2.h index 7e8fb820..96da9fe9 100644 --- a/PyGLM/types/mat/uint/mat2x2.h +++ b/PyGLM_lib/PyGLM/types/mat/uint/mat2x2.h @@ -116,7 +116,7 @@ static PyTypeObject humat2x2IterType = { static PyGLMTypeObject humat2x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umat2x2", /* tp_name */ sizeof(mat<2, 2, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/uint/mat2x3.h b/PyGLM_lib/PyGLM/types/mat/uint/mat2x3.h similarity index 99% rename from PyGLM/types/mat/uint/mat2x3.h rename to PyGLM_lib/PyGLM/types/mat/uint/mat2x3.h index 4f6f6bab..14d352af 100644 --- a/PyGLM/types/mat/uint/mat2x3.h +++ b/PyGLM_lib/PyGLM/types/mat/uint/mat2x3.h @@ -116,7 +116,7 @@ static PyTypeObject humat2x3IterType = { static PyGLMTypeObject humat2x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umat2x3", /* tp_name */ sizeof(mat<2, 3, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/uint/mat2x4.h b/PyGLM_lib/PyGLM/types/mat/uint/mat2x4.h similarity index 99% rename from PyGLM/types/mat/uint/mat2x4.h rename to PyGLM_lib/PyGLM/types/mat/uint/mat2x4.h index fec38e00..15741c30 100644 --- a/PyGLM/types/mat/uint/mat2x4.h +++ b/PyGLM_lib/PyGLM/types/mat/uint/mat2x4.h @@ -116,7 +116,7 @@ static PyTypeObject humat2x4IterType = { static PyGLMTypeObject humat2x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umat2x4", /* tp_name */ sizeof(mat<2, 4, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/uint/mat3x2.h b/PyGLM_lib/PyGLM/types/mat/uint/mat3x2.h similarity index 99% rename from PyGLM/types/mat/uint/mat3x2.h rename to PyGLM_lib/PyGLM/types/mat/uint/mat3x2.h index 405effac..787ccaa5 100644 --- a/PyGLM/types/mat/uint/mat3x2.h +++ b/PyGLM_lib/PyGLM/types/mat/uint/mat3x2.h @@ -116,7 +116,7 @@ static PyTypeObject humat3x2IterType = { static PyGLMTypeObject humat3x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umat3x2", /* tp_name */ sizeof(mat<3, 2, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/uint/mat3x3.h b/PyGLM_lib/PyGLM/types/mat/uint/mat3x3.h similarity index 99% rename from PyGLM/types/mat/uint/mat3x3.h rename to PyGLM_lib/PyGLM/types/mat/uint/mat3x3.h index 24fa5067..651c0d34 100644 --- a/PyGLM/types/mat/uint/mat3x3.h +++ b/PyGLM_lib/PyGLM/types/mat/uint/mat3x3.h @@ -116,7 +116,7 @@ static PyTypeObject humat3x3IterType = { static PyGLMTypeObject humat3x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umat3x3", /* tp_name */ sizeof(mat<3, 3, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/uint/mat3x4.h b/PyGLM_lib/PyGLM/types/mat/uint/mat3x4.h similarity index 99% rename from PyGLM/types/mat/uint/mat3x4.h rename to PyGLM_lib/PyGLM/types/mat/uint/mat3x4.h index d7ff7aee..ee88aaa8 100644 --- a/PyGLM/types/mat/uint/mat3x4.h +++ b/PyGLM_lib/PyGLM/types/mat/uint/mat3x4.h @@ -116,7 +116,7 @@ static PyTypeObject humat3x4IterType = { static PyGLMTypeObject humat3x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umat3x4", /* tp_name */ sizeof(mat<3, 4, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/uint/mat4x2.h b/PyGLM_lib/PyGLM/types/mat/uint/mat4x2.h similarity index 99% rename from PyGLM/types/mat/uint/mat4x2.h rename to PyGLM_lib/PyGLM/types/mat/uint/mat4x2.h index 48e581c9..77d3fa1c 100644 --- a/PyGLM/types/mat/uint/mat4x2.h +++ b/PyGLM_lib/PyGLM/types/mat/uint/mat4x2.h @@ -116,7 +116,7 @@ static PyTypeObject humat4x2IterType = { static PyGLMTypeObject humat4x2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umat4x2", /* tp_name */ sizeof(mat<4, 2, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/uint/mat4x3.h b/PyGLM_lib/PyGLM/types/mat/uint/mat4x3.h similarity index 99% rename from PyGLM/types/mat/uint/mat4x3.h rename to PyGLM_lib/PyGLM/types/mat/uint/mat4x3.h index f3e84ac9..9ba3564e 100644 --- a/PyGLM/types/mat/uint/mat4x3.h +++ b/PyGLM_lib/PyGLM/types/mat/uint/mat4x3.h @@ -116,7 +116,7 @@ static PyTypeObject humat4x3IterType = { static PyGLMTypeObject humat4x3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umat4x3", /* tp_name */ sizeof(mat<4, 3, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mat/uint/mat4x4.h b/PyGLM_lib/PyGLM/types/mat/uint/mat4x4.h similarity index 99% rename from PyGLM/types/mat/uint/mat4x4.h rename to PyGLM_lib/PyGLM/types/mat/uint/mat4x4.h index 180be608..d92e81c3 100644 --- a/PyGLM/types/mat/uint/mat4x4.h +++ b/PyGLM_lib/PyGLM/types/mat/uint/mat4x4.h @@ -116,7 +116,7 @@ static PyTypeObject humat4x4IterType = { static PyGLMTypeObject humat4x4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umat4x4", /* tp_name */ sizeof(mat<4, 4, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/all.h b/PyGLM_lib/PyGLM/types/mvec/all.h similarity index 100% rename from PyGLM/types/mvec/all.h rename to PyGLM_lib/PyGLM/types/mvec/all.h diff --git a/PyGLM/types/mvec/double/all.h b/PyGLM_lib/PyGLM/types/mvec/double/all.h similarity index 100% rename from PyGLM/types/mvec/double/all.h rename to PyGLM_lib/PyGLM/types/mvec/double/all.h diff --git a/PyGLM/types/mvec/double/mvec2.h b/PyGLM_lib/PyGLM/types/mvec/double/mvec2.h similarity index 99% rename from PyGLM/types/mvec/double/mvec2.h rename to PyGLM_lib/PyGLM/types/mvec/double/mvec2.h index e72b0bac..8bb0cda5 100644 --- a/PyGLM/types/mvec/double/mvec2.h +++ b/PyGLM_lib/PyGLM/types/mvec/double/mvec2.h @@ -111,7 +111,7 @@ static PyTypeObject hdmvec2IterType = { static PyGLMTypeObject hdmvec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmvec2", /* tp_name */ sizeof(mvec<2, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/double/mvec3.h b/PyGLM_lib/PyGLM/types/mvec/double/mvec3.h similarity index 99% rename from PyGLM/types/mvec/double/mvec3.h rename to PyGLM_lib/PyGLM/types/mvec/double/mvec3.h index 28fe7a39..0c93aae5 100644 --- a/PyGLM/types/mvec/double/mvec3.h +++ b/PyGLM_lib/PyGLM/types/mvec/double/mvec3.h @@ -111,7 +111,7 @@ static PyTypeObject hdmvec3IterType = { static PyGLMTypeObject hdmvec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmvec3", /* tp_name */ sizeof(mvec<3, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/double/mvec4.h b/PyGLM_lib/PyGLM/types/mvec/double/mvec4.h similarity index 99% rename from PyGLM/types/mvec/double/mvec4.h rename to PyGLM_lib/PyGLM/types/mvec/double/mvec4.h index 54d020e2..088b1603 100644 --- a/PyGLM/types/mvec/double/mvec4.h +++ b/PyGLM_lib/PyGLM/types/mvec/double/mvec4.h @@ -111,7 +111,7 @@ static PyTypeObject hdmvec4IterType = { static PyGLMTypeObject hdmvec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dmvec4", /* tp_name */ sizeof(mvec<4, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/float/all.h b/PyGLM_lib/PyGLM/types/mvec/float/all.h similarity index 100% rename from PyGLM/types/mvec/float/all.h rename to PyGLM_lib/PyGLM/types/mvec/float/all.h diff --git a/PyGLM/types/mvec/float/mvec2.h b/PyGLM_lib/PyGLM/types/mvec/float/mvec2.h similarity index 99% rename from PyGLM/types/mvec/float/mvec2.h rename to PyGLM_lib/PyGLM/types/mvec/float/mvec2.h index e65842ed..508315bd 100644 --- a/PyGLM/types/mvec/float/mvec2.h +++ b/PyGLM_lib/PyGLM/types/mvec/float/mvec2.h @@ -111,7 +111,7 @@ static PyTypeObject hfmvec2IterType = { static PyGLMTypeObject hfmvec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mvec2", /* tp_name */ sizeof(mvec<2, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/float/mvec3.h b/PyGLM_lib/PyGLM/types/mvec/float/mvec3.h similarity index 99% rename from PyGLM/types/mvec/float/mvec3.h rename to PyGLM_lib/PyGLM/types/mvec/float/mvec3.h index be60912f..0f7a8c67 100644 --- a/PyGLM/types/mvec/float/mvec3.h +++ b/PyGLM_lib/PyGLM/types/mvec/float/mvec3.h @@ -111,7 +111,7 @@ static PyTypeObject hfmvec3IterType = { static PyGLMTypeObject hfmvec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mvec3", /* tp_name */ sizeof(mvec<3, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/float/mvec4.h b/PyGLM_lib/PyGLM/types/mvec/float/mvec4.h similarity index 99% rename from PyGLM/types/mvec/float/mvec4.h rename to PyGLM_lib/PyGLM/types/mvec/float/mvec4.h index 87e998d3..d9fb3741 100644 --- a/PyGLM/types/mvec/float/mvec4.h +++ b/PyGLM_lib/PyGLM/types/mvec/float/mvec4.h @@ -111,7 +111,7 @@ static PyTypeObject hfmvec4IterType = { static PyGLMTypeObject hfmvec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.mvec4", /* tp_name */ sizeof(mvec<4, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/forward_declarations.h b/PyGLM_lib/PyGLM/types/mvec/forward_declarations.h similarity index 95% rename from PyGLM/types/mvec/forward_declarations.h rename to PyGLM_lib/PyGLM/types/mvec/forward_declarations.h index ccb32a40..fb4d3367 100644 --- a/PyGLM/types/mvec/forward_declarations.h +++ b/PyGLM_lib/PyGLM/types/mvec/forward_declarations.h @@ -5,7 +5,7 @@ template static int mvec_getbuffer(mvec* self, Py_buffer* view, int flags); -void mvec_releasebuffer(PyObject* self, Py_buffer* view); +static void mvec_releasebuffer(PyObject* self, Py_buffer* view); template static PyObject* mvec2_to_list(mvec<2, T>* self, PyObject*); @@ -122,9 +122,15 @@ static PyObject * mvec_floordiv(PyObject *obj1, PyObject *obj2); template static PyObject * mvec_div(PyObject *obj1, PyObject *obj2); +template +static PyObject* imvec_floordiv(PyObject* obj1, PyObject* obj2); + template static PyObject * mvec_ifloordiv(mvec* self, PyObject *obj); +template +static PyObject* imvec_ifloordiv(mvec* self, PyObject* obj); + template static PyObject * mvec_idiv(mvec* self, PyObject *obj); diff --git a/PyGLM/types/mvec/int/all.h b/PyGLM_lib/PyGLM/types/mvec/int/all.h similarity index 100% rename from PyGLM/types/mvec/int/all.h rename to PyGLM_lib/PyGLM/types/mvec/int/all.h diff --git a/PyGLM/types/mvec/int/mvec2.h b/PyGLM_lib/PyGLM/types/mvec/int/mvec2.h similarity index 97% rename from PyGLM/types/mvec/int/mvec2.h rename to PyGLM_lib/PyGLM/types/mvec/int/mvec2.h index e74a7331..4fe7fa31 100644 --- a/PyGLM/types/mvec/int/mvec2.h +++ b/PyGLM_lib/PyGLM/types/mvec/int/mvec2.h @@ -60,9 +60,9 @@ static PyNumberMethods himvec2NumMethods = { (binaryfunc)mvec_iand<2, glm::i32>, //nb_inplace_and (binaryfunc)mvec_ixor<2, glm::i32>, //nb_inplace_xor (binaryfunc)mvec_ior<2, glm::i32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)imvec_floordiv<2, glm::i32>, //nb_floor_divide (binaryfunc)mvec_div<2, glm::i32>, - 0, //nb_inplace_floor_divide + (binaryfunc)imvec_ifloordiv<2, glm::i32>, //nb_inplace_floor_divide (binaryfunc)mvec_idiv<2, glm::i32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)mvec_matmul, //nb_matrix_multiply @@ -111,7 +111,7 @@ static PyTypeObject himvec2IterType = { static PyGLMTypeObject himvec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imvec2", /* tp_name */ sizeof(mvec<2, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/int/mvec3.h b/PyGLM_lib/PyGLM/types/mvec/int/mvec3.h similarity index 97% rename from PyGLM/types/mvec/int/mvec3.h rename to PyGLM_lib/PyGLM/types/mvec/int/mvec3.h index 54473d8e..2ad81d5a 100644 --- a/PyGLM/types/mvec/int/mvec3.h +++ b/PyGLM_lib/PyGLM/types/mvec/int/mvec3.h @@ -60,9 +60,9 @@ static PyNumberMethods himvec3NumMethods = { (binaryfunc)mvec_iand<3, glm::i32>, //nb_inplace_and (binaryfunc)mvec_ixor<3, glm::i32>, //nb_inplace_xor (binaryfunc)mvec_ior<3, glm::i32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)imvec_floordiv<3, glm::i32>, //nb_floor_divide (binaryfunc)mvec_div<3, glm::i32>, - 0, //nb_inplace_floor_divide + (binaryfunc)imvec_ifloordiv<3, glm::i32>, //nb_inplace_floor_divide (binaryfunc)mvec_idiv<3, glm::i32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)mvec_matmul, //nb_matrix_multiply @@ -111,7 +111,7 @@ static PyTypeObject himvec3IterType = { static PyGLMTypeObject himvec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imvec3", /* tp_name */ sizeof(mvec<3, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/int/mvec4.h b/PyGLM_lib/PyGLM/types/mvec/int/mvec4.h similarity index 97% rename from PyGLM/types/mvec/int/mvec4.h rename to PyGLM_lib/PyGLM/types/mvec/int/mvec4.h index 227a48dc..f47f26aa 100644 --- a/PyGLM/types/mvec/int/mvec4.h +++ b/PyGLM_lib/PyGLM/types/mvec/int/mvec4.h @@ -60,9 +60,9 @@ static PyNumberMethods himvec4NumMethods = { (binaryfunc)mvec_iand<4, glm::i32>, //nb_inplace_and (binaryfunc)mvec_ixor<4, glm::i32>, //nb_inplace_xor (binaryfunc)mvec_ior<4, glm::i32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)imvec_floordiv<4, glm::i32>, //nb_floor_divide (binaryfunc)mvec_div<4, glm::i32>, - 0, //nb_inplace_floor_divide + (binaryfunc)imvec_ifloordiv<4, glm::i32>, //nb_inplace_floor_divide (binaryfunc)mvec_idiv<4, glm::i32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)mvec_matmul, //nb_matrix_multiply @@ -111,7 +111,7 @@ static PyTypeObject himvec4IterType = { static PyGLMTypeObject himvec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.imvec4", /* tp_name */ sizeof(mvec<4, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/uint/all.h b/PyGLM_lib/PyGLM/types/mvec/uint/all.h similarity index 100% rename from PyGLM/types/mvec/uint/all.h rename to PyGLM_lib/PyGLM/types/mvec/uint/all.h diff --git a/PyGLM/types/mvec/uint/mvec2.h b/PyGLM_lib/PyGLM/types/mvec/uint/mvec2.h similarity index 97% rename from PyGLM/types/mvec/uint/mvec2.h rename to PyGLM_lib/PyGLM/types/mvec/uint/mvec2.h index 367bd2db..f2937d62 100644 --- a/PyGLM/types/mvec/uint/mvec2.h +++ b/PyGLM_lib/PyGLM/types/mvec/uint/mvec2.h @@ -60,9 +60,9 @@ static PyNumberMethods humvec2NumMethods = { (binaryfunc)mvec_iand<2, glm::u32>, //nb_inplace_and (binaryfunc)mvec_ixor<2, glm::u32>, //nb_inplace_xor (binaryfunc)mvec_ior<2, glm::u32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)mvec_div<2, glm::u32>, //nb_floor_divide (binaryfunc)mvec_div<2, glm::u32>, - 0, //nb_inplace_floor_divide + (binaryfunc)mvec_idiv<2, glm::u32>, //nb_inplace_floor_divide (binaryfunc)mvec_idiv<2, glm::u32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)mvec_matmul, //nb_matrix_multiply @@ -111,7 +111,7 @@ static PyTypeObject humvec2IterType = { static PyGLMTypeObject humvec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umvec2", /* tp_name */ sizeof(mvec<2, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/uint/mvec3.h b/PyGLM_lib/PyGLM/types/mvec/uint/mvec3.h similarity index 97% rename from PyGLM/types/mvec/uint/mvec3.h rename to PyGLM_lib/PyGLM/types/mvec/uint/mvec3.h index 217baf11..8cbb3569 100644 --- a/PyGLM/types/mvec/uint/mvec3.h +++ b/PyGLM_lib/PyGLM/types/mvec/uint/mvec3.h @@ -60,9 +60,9 @@ static PyNumberMethods humvec3NumMethods = { (binaryfunc)mvec_iand<3, glm::u32>, //nb_inplace_and (binaryfunc)mvec_ixor<3, glm::u32>, //nb_inplace_xor (binaryfunc)mvec_ior<3, glm::u32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)mvec_div<3, glm::u32>, //nb_floor_divide (binaryfunc)mvec_div<3, glm::u32>, - 0, //nb_inplace_floor_divide + (binaryfunc)mvec_idiv<3, glm::u32>, //nb_inplace_floor_divide (binaryfunc)mvec_idiv<3, glm::u32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)mvec_matmul, //nb_matrix_multiply @@ -111,7 +111,7 @@ static PyTypeObject humvec3IterType = { static PyGLMTypeObject humvec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umvec3", /* tp_name */ sizeof(mvec<3, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/mvec/uint/mvec4.h b/PyGLM_lib/PyGLM/types/mvec/uint/mvec4.h similarity index 97% rename from PyGLM/types/mvec/uint/mvec4.h rename to PyGLM_lib/PyGLM/types/mvec/uint/mvec4.h index 914fb381..e743b88e 100644 --- a/PyGLM/types/mvec/uint/mvec4.h +++ b/PyGLM_lib/PyGLM/types/mvec/uint/mvec4.h @@ -60,9 +60,9 @@ static PyNumberMethods humvec4NumMethods = { (binaryfunc)mvec_iand<4, glm::u32>, //nb_inplace_and (binaryfunc)mvec_ixor<4, glm::u32>, //nb_inplace_xor (binaryfunc)mvec_ior<4, glm::u32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)mvec_div<4, glm::u32>, //nb_floor_divide (binaryfunc)mvec_div<4, glm::u32>, - 0, //nb_inplace_floor_divide + (binaryfunc)mvec_idiv<4, glm::u32>, //nb_inplace_floor_divide (binaryfunc)mvec_idiv<4, glm::u32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)mvec_matmul, //nb_matrix_multiply @@ -111,7 +111,7 @@ static PyTypeObject humvec4IterType = { static PyGLMTypeObject humvec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.umvec4", /* tp_name */ sizeof(mvec<4, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/qua/all.h b/PyGLM_lib/PyGLM/types/qua/all.h similarity index 100% rename from PyGLM/types/qua/all.h rename to PyGLM_lib/PyGLM/types/qua/all.h diff --git a/PyGLM/types/qua/double/quat.h b/PyGLM_lib/PyGLM/types/qua/double/quat.h similarity index 99% rename from PyGLM/types/qua/double/quat.h rename to PyGLM_lib/PyGLM/types/qua/double/quat.h index 0885fbc4..99b37bad 100644 --- a/PyGLM/types/qua/double/quat.h +++ b/PyGLM_lib/PyGLM/types/qua/double/quat.h @@ -119,7 +119,7 @@ static PyTypeObject hdquaIterType = { static PyGLMTypeObject hdquaGLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dquat", /* tp_name */ sizeof(qua), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/qua/float/quat.h b/PyGLM_lib/PyGLM/types/qua/float/quat.h similarity index 99% rename from PyGLM/types/qua/float/quat.h rename to PyGLM_lib/PyGLM/types/qua/float/quat.h index fe1604ed..eb2402b6 100644 --- a/PyGLM/types/qua/float/quat.h +++ b/PyGLM_lib/PyGLM/types/qua/float/quat.h @@ -119,7 +119,7 @@ static PyTypeObject hfquaIterType = { static PyGLMTypeObject hfquaGLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.quat", /* tp_name */ sizeof(qua), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/qua/forward_declarations.h b/PyGLM_lib/PyGLM/types/qua/forward_declarations.h similarity index 97% rename from PyGLM/types/qua/forward_declarations.h rename to PyGLM_lib/PyGLM/types/qua/forward_declarations.h index 7b128e65..e7349801 100644 --- a/PyGLM/types/qua/forward_declarations.h +++ b/PyGLM_lib/PyGLM/types/qua/forward_declarations.h @@ -7,7 +7,7 @@ static PyObject* qua_length(PyObject * self, PyObject* arg); template static int qua_getbuffer(qua* self, Py_buffer* view, int flags); -void qua_releasebuffer(PyObject* self, Py_buffer* view); +static void qua_releasebuffer(PyObject* self, Py_buffer* view); static Py_ssize_t qua_len(PyObject* self); diff --git a/PyGLM/types/types.h b/PyGLM_lib/PyGLM/types/types.h similarity index 100% rename from PyGLM/types/types.h rename to PyGLM_lib/PyGLM/types/types.h diff --git a/PyGLM/types/vec/all.h b/PyGLM_lib/PyGLM/types/vec/all.h similarity index 100% rename from PyGLM/types/vec/all.h rename to PyGLM_lib/PyGLM/types/vec/all.h diff --git a/PyGLM/types/vec/bool/all.h b/PyGLM_lib/PyGLM/types/vec/bool/all.h similarity index 100% rename from PyGLM/types/vec/bool/all.h rename to PyGLM_lib/PyGLM/types/vec/bool/all.h diff --git a/PyGLM/types/vec/bool/vec1.h b/PyGLM_lib/PyGLM/types/vec/bool/vec1.h similarity index 98% rename from PyGLM/types/vec/bool/vec1.h rename to PyGLM_lib/PyGLM/types/vec/bool/vec1.h index 2e0868db..c88c5579 100644 --- a/PyGLM/types/vec/bool/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/bool/vec1.h @@ -49,9 +49,9 @@ static PyNumberMethods hbvec1NumMethods = { 0, //nb_invert 0, //nb_lshift 0, //nb_rshift - 0, //nb_and - 0, //nb_xor - 0, //nb_or + vec_and<1, bool>, //nb_and + vec_xor<1, bool>, //nb_xor + vec_or<1, bool>, //nb_or 0, //nb_int 0, //nb_reserved 0, //nb_int @@ -116,7 +116,7 @@ static PyTypeObject hbvec1IterType = { static PyGLMTypeObject hbvec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.bvec1", /* tp_name */ sizeof(vec<1, bool>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/bool/vec2.h b/PyGLM_lib/PyGLM/types/vec/bool/vec2.h similarity index 98% rename from PyGLM/types/vec/bool/vec2.h rename to PyGLM_lib/PyGLM/types/vec/bool/vec2.h index 5bc36c45..c786ee21 100644 --- a/PyGLM/types/vec/bool/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/bool/vec2.h @@ -50,9 +50,9 @@ static PyNumberMethods hbvec2NumMethods = { 0, //nb_invert 0, //nb_lshift 0, //nb_rshift - 0, //nb_and - 0, //nb_xor - 0, //nb_or + vec_and<2, bool>, //nb_and + vec_xor<2, bool>, //nb_xor + vec_or<2, bool>, //nb_or 0, //nb_int 0, //nb_reserved 0, //nb_int @@ -117,7 +117,7 @@ static PyTypeObject hbvec2IterType = { static PyGLMTypeObject hbvec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.bvec2", /* tp_name */ sizeof(vec<2, bool>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/bool/vec3.h b/PyGLM_lib/PyGLM/types/vec/bool/vec3.h similarity index 98% rename from PyGLM/types/vec/bool/vec3.h rename to PyGLM_lib/PyGLM/types/vec/bool/vec3.h index d65c280f..c529ecfb 100644 --- a/PyGLM/types/vec/bool/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/bool/vec3.h @@ -51,9 +51,9 @@ static PyNumberMethods hbvec3NumMethods = { 0, //nb_invert 0, //nb_lshift 0, //nb_rshift - 0, //nb_and - 0, //nb_xor - 0, //nb_or + vec_and<3, bool>, //nb_and + vec_xor<3, bool>, //nb_xor + vec_or<3, bool>, //nb_or 0, //nb_int 0, //nb_reserved 0, //nb_int @@ -118,7 +118,7 @@ static PyTypeObject hbvec3IterType = { static PyGLMTypeObject hbvec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.bvec3", /* tp_name */ sizeof(vec<3, bool>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/bool/vec4.h b/PyGLM_lib/PyGLM/types/vec/bool/vec4.h similarity index 98% rename from PyGLM/types/vec/bool/vec4.h rename to PyGLM_lib/PyGLM/types/vec/bool/vec4.h index 1ab6df0e..518a0ae7 100644 --- a/PyGLM/types/vec/bool/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/bool/vec4.h @@ -52,9 +52,9 @@ static PyNumberMethods hbvec4NumMethods = { 0, //nb_invert 0, //nb_lshift 0, //nb_rshift - 0, //nb_and - 0, //nb_xor - 0, //nb_or + vec_and<4, bool>, //nb_and + vec_xor<4, bool>, //nb_xor + vec_or<4, bool>, //nb_or 0, //nb_int 0, //nb_reserved 0, //nb_int @@ -119,7 +119,7 @@ static PyTypeObject hbvec4IterType = { static PyGLMTypeObject hbvec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.bvec4", /* tp_name */ sizeof(vec<4, bool>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/double/all.h b/PyGLM_lib/PyGLM/types/vec/double/all.h similarity index 100% rename from PyGLM/types/vec/double/all.h rename to PyGLM_lib/PyGLM/types/vec/double/all.h diff --git a/PyGLM/types/vec/double/vec1.h b/PyGLM_lib/PyGLM/types/vec/double/vec1.h similarity index 99% rename from PyGLM/types/vec/double/vec1.h rename to PyGLM_lib/PyGLM/types/vec/double/vec1.h index 1428af18..5fdb6a71 100644 --- a/PyGLM/types/vec/double/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/double/vec1.h @@ -116,7 +116,7 @@ static PyTypeObject hdvec1IterType = { static PyGLMTypeObject hdvec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dvec1", /* tp_name */ sizeof(vec<1, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/double/vec2.h b/PyGLM_lib/PyGLM/types/vec/double/vec2.h similarity index 99% rename from PyGLM/types/vec/double/vec2.h rename to PyGLM_lib/PyGLM/types/vec/double/vec2.h index 5ff2682e..4bc2b991 100644 --- a/PyGLM/types/vec/double/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/double/vec2.h @@ -117,7 +117,7 @@ static PyTypeObject hdvec2IterType = { static PyGLMTypeObject hdvec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dvec2", /* tp_name */ sizeof(vec<2, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/double/vec3.h b/PyGLM_lib/PyGLM/types/vec/double/vec3.h similarity index 99% rename from PyGLM/types/vec/double/vec3.h rename to PyGLM_lib/PyGLM/types/vec/double/vec3.h index 848eb0f8..efa2daf3 100644 --- a/PyGLM/types/vec/double/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/double/vec3.h @@ -118,7 +118,7 @@ static PyTypeObject hdvec3IterType = { static PyGLMTypeObject hdvec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dvec3", /* tp_name */ sizeof(vec<3, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/double/vec4.h b/PyGLM_lib/PyGLM/types/vec/double/vec4.h similarity index 99% rename from PyGLM/types/vec/double/vec4.h rename to PyGLM_lib/PyGLM/types/vec/double/vec4.h index 961da246..49effc1d 100644 --- a/PyGLM/types/vec/double/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/double/vec4.h @@ -119,7 +119,7 @@ static PyTypeObject hdvec4IterType = { static PyGLMTypeObject hdvec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.dvec4", /* tp_name */ sizeof(vec<4, double>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/float/all.h b/PyGLM_lib/PyGLM/types/vec/float/all.h similarity index 100% rename from PyGLM/types/vec/float/all.h rename to PyGLM_lib/PyGLM/types/vec/float/all.h diff --git a/PyGLM/types/vec/float/vec1.h b/PyGLM_lib/PyGLM/types/vec/float/vec1.h similarity index 99% rename from PyGLM/types/vec/float/vec1.h rename to PyGLM_lib/PyGLM/types/vec/float/vec1.h index 6d66d8f0..f29168e2 100644 --- a/PyGLM/types/vec/float/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/float/vec1.h @@ -116,7 +116,7 @@ static PyTypeObject hfvec1IterType = { static PyGLMTypeObject hfvec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.vec1", /* tp_name */ sizeof(vec<1, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/float/vec2.h b/PyGLM_lib/PyGLM/types/vec/float/vec2.h similarity index 99% rename from PyGLM/types/vec/float/vec2.h rename to PyGLM_lib/PyGLM/types/vec/float/vec2.h index 9615d5a2..56804abf 100644 --- a/PyGLM/types/vec/float/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/float/vec2.h @@ -117,7 +117,7 @@ static PyTypeObject hfvec2IterType = { static PyGLMTypeObject hfvec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.vec2", /* tp_name */ sizeof(vec<2, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/float/vec3.h b/PyGLM_lib/PyGLM/types/vec/float/vec3.h similarity index 99% rename from PyGLM/types/vec/float/vec3.h rename to PyGLM_lib/PyGLM/types/vec/float/vec3.h index cfc242cf..17bf4355 100644 --- a/PyGLM/types/vec/float/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/float/vec3.h @@ -118,7 +118,7 @@ static PyTypeObject hfvec3IterType = { static PyGLMTypeObject hfvec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.vec3", /* tp_name */ sizeof(vec<3, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/float/vec4.h b/PyGLM_lib/PyGLM/types/vec/float/vec4.h similarity index 99% rename from PyGLM/types/vec/float/vec4.h rename to PyGLM_lib/PyGLM/types/vec/float/vec4.h index d204a7cc..f74a1542 100644 --- a/PyGLM/types/vec/float/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/float/vec4.h @@ -119,7 +119,7 @@ static PyTypeObject hfvec4IterType = { static PyGLMTypeObject hfvec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.vec4", /* tp_name */ sizeof(vec<4, float>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/forward_declarations.h b/PyGLM_lib/PyGLM/types/vec/forward_declarations.h similarity index 96% rename from PyGLM/types/vec/forward_declarations.h rename to PyGLM_lib/PyGLM/types/vec/forward_declarations.h index 1d1568bb..fcce47a8 100644 --- a/PyGLM/types/vec/forward_declarations.h +++ b/PyGLM_lib/PyGLM/types/vec/forward_declarations.h @@ -5,7 +5,7 @@ template static int vec_getbuffer(vec* self, Py_buffer* view, int flags); -void vec_releasebuffer(PyObject* self, Py_buffer* view); +static void vec_releasebuffer(PyObject* self, Py_buffer* view); template static PyObject* vec1_to_list(vec<1, T>* self, PyObject*); @@ -153,12 +153,18 @@ static PyObject * vec_ipow(vec* self, PyObject * obj2, PyObject * obj3); template static PyObject * vec_floordiv(PyObject *obj1, PyObject *obj2); +template +static PyObject * ivec_floordiv(PyObject *obj1, PyObject *obj2); + template static PyObject * vec_div(PyObject *obj1, PyObject *obj2); template static PyObject * vec_ifloordiv(vec* self, PyObject *obj); +template +static PyObject * ivec_ifloordiv(vec *self, PyObject *obj); + template static PyObject * vec_idiv(vec* self, PyObject *obj); diff --git a/PyGLM/types/vec/int16/all.h b/PyGLM_lib/PyGLM/types/vec/int16/all.h similarity index 100% rename from PyGLM/types/vec/int16/all.h rename to PyGLM_lib/PyGLM/types/vec/int16/all.h diff --git a/PyGLM/types/vec/int16/vec1.h b/PyGLM_lib/PyGLM/types/vec/int16/vec1.h similarity index 97% rename from PyGLM/types/vec/int16/vec1.h rename to PyGLM_lib/PyGLM/types/vec/int16/vec1.h index 964bd999..5710b3f9 100644 --- a/PyGLM/types/vec/int16/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/int16/vec1.h @@ -65,9 +65,9 @@ static PyNumberMethods hi16vec1NumMethods = { (binaryfunc)vec_iand<1, glm::i16>, //nb_inplace_and (binaryfunc)vec_ixor<1, glm::i16>, //nb_inplace_xor (binaryfunc)vec_ior<1, glm::i16>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<1, glm::i16>, //nb_floor_divide (binaryfunc)vec_div<1, glm::i16>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<1, glm::i16>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<1, glm::i16>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -116,7 +116,7 @@ static PyTypeObject hi16vec1IterType = { static PyGLMTypeObject hi16vec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i16vec1", /* tp_name */ sizeof(vec<1, glm::i16>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int16/vec2.h b/PyGLM_lib/PyGLM/types/vec/int16/vec2.h similarity index 97% rename from PyGLM/types/vec/int16/vec2.h rename to PyGLM_lib/PyGLM/types/vec/int16/vec2.h index d23193bc..28247ec2 100644 --- a/PyGLM/types/vec/int16/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/int16/vec2.h @@ -66,9 +66,9 @@ static PyNumberMethods hi16vec2NumMethods = { (binaryfunc)vec_iand<2, glm::i16>, //nb_inplace_and (binaryfunc)vec_ixor<2, glm::i16>, //nb_inplace_xor (binaryfunc)vec_ior<2, glm::i16>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<2, glm::i16>, //nb_floor_divide (binaryfunc)vec_div<2, glm::i16>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<2, glm::i16>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<2, glm::i16>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -117,7 +117,7 @@ static PyTypeObject hi16vec2IterType = { static PyGLMTypeObject hi16vec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i16vec2", /* tp_name */ sizeof(vec<2, glm::i16>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int16/vec3.h b/PyGLM_lib/PyGLM/types/vec/int16/vec3.h similarity index 97% rename from PyGLM/types/vec/int16/vec3.h rename to PyGLM_lib/PyGLM/types/vec/int16/vec3.h index 6e22cfdd..785a062e 100644 --- a/PyGLM/types/vec/int16/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/int16/vec3.h @@ -67,9 +67,9 @@ static PyNumberMethods hi16vec3NumMethods = { (binaryfunc)vec_iand<3, glm::i16>, //nb_inplace_and (binaryfunc)vec_ixor<3, glm::i16>, //nb_inplace_xor (binaryfunc)vec_ior<3, glm::i16>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<3, glm::i16>, //nb_floor_divide (binaryfunc)vec_div<3, glm::i16>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<3, glm::i16>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<3, glm::i16>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -118,7 +118,7 @@ static PyTypeObject hi16vec3IterType = { static PyGLMTypeObject hi16vec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i16vec3", /* tp_name */ sizeof(vec<3, glm::i16>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int16/vec4.h b/PyGLM_lib/PyGLM/types/vec/int16/vec4.h similarity index 97% rename from PyGLM/types/vec/int16/vec4.h rename to PyGLM_lib/PyGLM/types/vec/int16/vec4.h index 29b90996..302d2feb 100644 --- a/PyGLM/types/vec/int16/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/int16/vec4.h @@ -68,9 +68,9 @@ static PyNumberMethods hi16vec4NumMethods = { (binaryfunc)vec_iand<4, glm::i16>, //nb_inplace_and (binaryfunc)vec_ixor<4, glm::i16>, //nb_inplace_xor (binaryfunc)vec_ior<4, glm::i16>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<4, glm::i16>, //nb_floor_divide (binaryfunc)vec_div<4, glm::i16>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<4, glm::i16>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<4, glm::i16>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -119,7 +119,7 @@ static PyTypeObject hi16vec4IterType = { static PyGLMTypeObject hi16vec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i16vec4", /* tp_name */ sizeof(vec<4, glm::i16>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int32/all.h b/PyGLM_lib/PyGLM/types/vec/int32/all.h similarity index 100% rename from PyGLM/types/vec/int32/all.h rename to PyGLM_lib/PyGLM/types/vec/int32/all.h diff --git a/PyGLM/types/vec/int32/vec1.h b/PyGLM_lib/PyGLM/types/vec/int32/vec1.h similarity index 97% rename from PyGLM/types/vec/int32/vec1.h rename to PyGLM_lib/PyGLM/types/vec/int32/vec1.h index cfda10dd..e33d9bed 100644 --- a/PyGLM/types/vec/int32/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/int32/vec1.h @@ -65,9 +65,9 @@ static PyNumberMethods hivec1NumMethods = { (binaryfunc)vec_iand<1, glm::i32>, //nb_inplace_and (binaryfunc)vec_ixor<1, glm::i32>, //nb_inplace_xor (binaryfunc)vec_ior<1, glm::i32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<1, glm::i32>, //nb_floor_divide (binaryfunc)vec_div<1, glm::i32>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<1, glm::i32>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<1, glm::i32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -116,7 +116,7 @@ static PyTypeObject hivec1IterType = { static PyGLMTypeObject hivec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.ivec1", /* tp_name */ sizeof(vec<1, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int32/vec2.h b/PyGLM_lib/PyGLM/types/vec/int32/vec2.h similarity index 97% rename from PyGLM/types/vec/int32/vec2.h rename to PyGLM_lib/PyGLM/types/vec/int32/vec2.h index b331fb0f..4301ed72 100644 --- a/PyGLM/types/vec/int32/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/int32/vec2.h @@ -66,9 +66,9 @@ static PyNumberMethods hivec2NumMethods = { (binaryfunc)vec_iand<2, glm::i32>, //nb_inplace_and (binaryfunc)vec_ixor<2, glm::i32>, //nb_inplace_xor (binaryfunc)vec_ior<2, glm::i32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<2, glm::i32>, //nb_floor_divide (binaryfunc)vec_div<2, glm::i32>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<2, glm::i32>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<2, glm::i32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -117,7 +117,7 @@ static PyTypeObject hivec2IterType = { static PyGLMTypeObject hivec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.ivec2", /* tp_name */ sizeof(vec<2, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int32/vec3.h b/PyGLM_lib/PyGLM/types/vec/int32/vec3.h similarity index 97% rename from PyGLM/types/vec/int32/vec3.h rename to PyGLM_lib/PyGLM/types/vec/int32/vec3.h index 8b763ed8..d958c767 100644 --- a/PyGLM/types/vec/int32/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/int32/vec3.h @@ -67,9 +67,9 @@ static PyNumberMethods hivec3NumMethods = { (binaryfunc)vec_iand<3, glm::i32>, //nb_inplace_and (binaryfunc)vec_ixor<3, glm::i32>, //nb_inplace_xor (binaryfunc)vec_ior<3, glm::i32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<3, glm::i32>, //nb_floor_divide (binaryfunc)vec_div<3, glm::i32>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<3, glm::i32>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<3, glm::i32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -118,7 +118,7 @@ static PyTypeObject hivec3IterType = { static PyGLMTypeObject hivec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.ivec3", /* tp_name */ sizeof(vec<3, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int32/vec4.h b/PyGLM_lib/PyGLM/types/vec/int32/vec4.h similarity index 97% rename from PyGLM/types/vec/int32/vec4.h rename to PyGLM_lib/PyGLM/types/vec/int32/vec4.h index 1a617e33..d5703b33 100644 --- a/PyGLM/types/vec/int32/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/int32/vec4.h @@ -68,9 +68,9 @@ static PyNumberMethods hivec4NumMethods = { (binaryfunc)vec_iand<4, glm::i32>, //nb_inplace_and (binaryfunc)vec_ixor<4, glm::i32>, //nb_inplace_xor (binaryfunc)vec_ior<4, glm::i32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<4, glm::i32>, //nb_floor_divide (binaryfunc)vec_div<4, glm::i32>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<4, glm::i32>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<4, glm::i32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -119,7 +119,7 @@ static PyTypeObject hivec4IterType = { static PyGLMTypeObject hivec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.ivec4", /* tp_name */ sizeof(vec<4, glm::i32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int64/all.h b/PyGLM_lib/PyGLM/types/vec/int64/all.h similarity index 100% rename from PyGLM/types/vec/int64/all.h rename to PyGLM_lib/PyGLM/types/vec/int64/all.h diff --git a/PyGLM/types/vec/int64/vec1.h b/PyGLM_lib/PyGLM/types/vec/int64/vec1.h similarity index 97% rename from PyGLM/types/vec/int64/vec1.h rename to PyGLM_lib/PyGLM/types/vec/int64/vec1.h index 47356073..ea8630ab 100644 --- a/PyGLM/types/vec/int64/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/int64/vec1.h @@ -65,9 +65,9 @@ static PyNumberMethods hi64vec1NumMethods = { (binaryfunc)vec_iand<1, glm::i64>, //nb_inplace_and (binaryfunc)vec_ixor<1, glm::i64>, //nb_inplace_xor (binaryfunc)vec_ior<1, glm::i64>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<1, glm::i64>, //nb_floor_divide (binaryfunc)vec_div<1, glm::i64>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<1, glm::i64>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<1, glm::i64>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -116,7 +116,7 @@ static PyTypeObject hi64vec1IterType = { static PyGLMTypeObject hi64vec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i64vec1", /* tp_name */ sizeof(vec<1, glm::i64>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int64/vec2.h b/PyGLM_lib/PyGLM/types/vec/int64/vec2.h similarity index 97% rename from PyGLM/types/vec/int64/vec2.h rename to PyGLM_lib/PyGLM/types/vec/int64/vec2.h index 67324e84..e99c6701 100644 --- a/PyGLM/types/vec/int64/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/int64/vec2.h @@ -66,9 +66,9 @@ static PyNumberMethods hi64vec2NumMethods = { (binaryfunc)vec_iand<2, glm::i64>, //nb_inplace_and (binaryfunc)vec_ixor<2, glm::i64>, //nb_inplace_xor (binaryfunc)vec_ior<2, glm::i64>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<2, glm::i64>, //nb_floor_divide (binaryfunc)vec_div<2, glm::i64>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<2, glm::i64>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<2, glm::i64>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -117,7 +117,7 @@ static PyTypeObject hi64vec2IterType = { static PyGLMTypeObject hi64vec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i64vec2", /* tp_name */ sizeof(vec<2, glm::i64>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int64/vec3.h b/PyGLM_lib/PyGLM/types/vec/int64/vec3.h similarity index 97% rename from PyGLM/types/vec/int64/vec3.h rename to PyGLM_lib/PyGLM/types/vec/int64/vec3.h index da5c7b79..57d5e3c8 100644 --- a/PyGLM/types/vec/int64/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/int64/vec3.h @@ -67,9 +67,9 @@ static PyNumberMethods hi64vec3NumMethods = { (binaryfunc)vec_iand<3, glm::i64>, //nb_inplace_and (binaryfunc)vec_ixor<3, glm::i64>, //nb_inplace_xor (binaryfunc)vec_ior<3, glm::i64>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<3, glm::i64>, //nb_floor_divide (binaryfunc)vec_div<3, glm::i64>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<3, glm::i64>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<3, glm::i64>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -118,7 +118,7 @@ static PyTypeObject hi64vec3IterType = { static PyGLMTypeObject hi64vec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i64vec3", /* tp_name */ sizeof(vec<3, glm::i64>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int64/vec4.h b/PyGLM_lib/PyGLM/types/vec/int64/vec4.h similarity index 97% rename from PyGLM/types/vec/int64/vec4.h rename to PyGLM_lib/PyGLM/types/vec/int64/vec4.h index ac777989..769d40db 100644 --- a/PyGLM/types/vec/int64/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/int64/vec4.h @@ -68,9 +68,9 @@ static PyNumberMethods hi64vec4NumMethods = { (binaryfunc)vec_iand<4, glm::i64>, //nb_inplace_and (binaryfunc)vec_ixor<4, glm::i64>, //nb_inplace_xor (binaryfunc)vec_ior<4, glm::i64>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<4, glm::i64>, //nb_floor_divide (binaryfunc)vec_div<4, glm::i64>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<4, glm::i64>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<4, glm::i64>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -119,7 +119,7 @@ static PyTypeObject hi64vec4IterType = { static PyGLMTypeObject hi64vec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i64vec4", /* tp_name */ sizeof(vec<4, glm::i64>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int8/all.h b/PyGLM_lib/PyGLM/types/vec/int8/all.h similarity index 100% rename from PyGLM/types/vec/int8/all.h rename to PyGLM_lib/PyGLM/types/vec/int8/all.h diff --git a/PyGLM/types/vec/int8/vec1.h b/PyGLM_lib/PyGLM/types/vec/int8/vec1.h similarity index 97% rename from PyGLM/types/vec/int8/vec1.h rename to PyGLM_lib/PyGLM/types/vec/int8/vec1.h index 8c4d3c46..ad3a0ffb 100644 --- a/PyGLM/types/vec/int8/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/int8/vec1.h @@ -65,9 +65,9 @@ static PyNumberMethods hi8vec1NumMethods = { (binaryfunc)vec_iand<1, glm::i8>, //nb_inplace_and (binaryfunc)vec_ixor<1, glm::i8>, //nb_inplace_xor (binaryfunc)vec_ior<1, glm::i8>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<1, glm::i8>, //nb_floor_divide (binaryfunc)vec_div<1, glm::i8>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<1, glm::i8>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<1, glm::i8>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -116,7 +116,7 @@ static PyTypeObject hi8vec1IterType = { static PyGLMTypeObject hi8vec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i8vec1", /* tp_name */ sizeof(vec<1, glm::i8>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int8/vec2.h b/PyGLM_lib/PyGLM/types/vec/int8/vec2.h similarity index 97% rename from PyGLM/types/vec/int8/vec2.h rename to PyGLM_lib/PyGLM/types/vec/int8/vec2.h index f88e8b07..ee19ff3e 100644 --- a/PyGLM/types/vec/int8/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/int8/vec2.h @@ -66,9 +66,9 @@ static PyNumberMethods hi8vec2NumMethods = { (binaryfunc)vec_iand<2, glm::i8>, //nb_inplace_and (binaryfunc)vec_ixor<2, glm::i8>, //nb_inplace_xor (binaryfunc)vec_ior<2, glm::i8>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<2, glm::i8>, //nb_floor_divide (binaryfunc)vec_div<2, glm::i8>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<2, glm::i8>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<2, glm::i8>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -117,7 +117,7 @@ static PyTypeObject hi8vec2IterType = { static PyGLMTypeObject hi8vec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i8vec2", /* tp_name */ sizeof(vec<2, glm::i8>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int8/vec3.h b/PyGLM_lib/PyGLM/types/vec/int8/vec3.h similarity index 97% rename from PyGLM/types/vec/int8/vec3.h rename to PyGLM_lib/PyGLM/types/vec/int8/vec3.h index cee6c360..caf6397b 100644 --- a/PyGLM/types/vec/int8/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/int8/vec3.h @@ -67,9 +67,9 @@ static PyNumberMethods hi8vec3NumMethods = { (binaryfunc)vec_iand<3, glm::i8>, //nb_inplace_and (binaryfunc)vec_ixor<3, glm::i8>, //nb_inplace_xor (binaryfunc)vec_ior<3, glm::i8>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<3, glm::i8>, //nb_floor_divide (binaryfunc)vec_div<3, glm::i8>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<3, glm::i8>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<3, glm::i8>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -118,7 +118,7 @@ static PyTypeObject hi8vec3IterType = { static PyGLMTypeObject hi8vec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i8vec3", /* tp_name */ sizeof(vec<3, glm::i8>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/int8/vec4.h b/PyGLM_lib/PyGLM/types/vec/int8/vec4.h similarity index 97% rename from PyGLM/types/vec/int8/vec4.h rename to PyGLM_lib/PyGLM/types/vec/int8/vec4.h index a94af4a6..f0369d5e 100644 --- a/PyGLM/types/vec/int8/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/int8/vec4.h @@ -68,9 +68,9 @@ static PyNumberMethods hi8vec4NumMethods = { (binaryfunc)vec_iand<4, glm::i8>, //nb_inplace_and (binaryfunc)vec_ixor<4, glm::i8>, //nb_inplace_xor (binaryfunc)vec_ior<4, glm::i8>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)ivec_floordiv<4, glm::i8>, //nb_floor_divide (binaryfunc)vec_div<4, glm::i8>, - 0, //nb_inplace_floor_divide + (binaryfunc)ivec_ifloordiv<4, glm::i8>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<4, glm::i8>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -119,7 +119,7 @@ static PyTypeObject hi8vec4IterType = { static PyGLMTypeObject hi8vec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.i8vec4", /* tp_name */ sizeof(vec<4, glm::i8>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint16/all.h b/PyGLM_lib/PyGLM/types/vec/uint16/all.h similarity index 100% rename from PyGLM/types/vec/uint16/all.h rename to PyGLM_lib/PyGLM/types/vec/uint16/all.h diff --git a/PyGLM/types/vec/uint16/vec1.h b/PyGLM_lib/PyGLM/types/vec/uint16/vec1.h similarity index 97% rename from PyGLM/types/vec/uint16/vec1.h rename to PyGLM_lib/PyGLM/types/vec/uint16/vec1.h index 41ffc473..2ed2fe45 100644 --- a/PyGLM/types/vec/uint16/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/uint16/vec1.h @@ -65,9 +65,9 @@ static PyNumberMethods hu16vec1NumMethods = { (binaryfunc)vec_iand<1, glm::u16>, //nb_inplace_and (binaryfunc)vec_ixor<1, glm::u16>, //nb_inplace_xor (binaryfunc)vec_ior<1, glm::u16>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<1, glm::u16>, //nb_floor_divide (binaryfunc)vec_div<1, glm::u16>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<1, glm::u16>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<1, glm::u16>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -116,7 +116,7 @@ static PyTypeObject hu16vec1IterType = { static PyGLMTypeObject hu16vec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u16vec1", /* tp_name */ sizeof(vec<1, glm::u16>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint16/vec2.h b/PyGLM_lib/PyGLM/types/vec/uint16/vec2.h similarity index 98% rename from PyGLM/types/vec/uint16/vec2.h rename to PyGLM_lib/PyGLM/types/vec/uint16/vec2.h index 448e1095..252edd30 100644 --- a/PyGLM/types/vec/uint16/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/uint16/vec2.h @@ -66,9 +66,9 @@ static PyNumberMethods hu16vec2NumMethods = { (binaryfunc)vec_iand<2, glm::u16>, //nb_inplace_and (binaryfunc)vec_ixor<2, glm::u16>, //nb_inplace_xor (binaryfunc)vec_ior<2, glm::u16>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<2, glm::u16>, //nb_floor_divide (binaryfunc)vec_div<2, glm::u16>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<2, glm::u16>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<2, glm::u16>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -117,7 +117,7 @@ static PyTypeObject hu16vec2IterType = { static PyGLMTypeObject hu16vec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u16vec2", /* tp_name */ sizeof(vec<2, glm::u16>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint16/vec3.h b/PyGLM_lib/PyGLM/types/vec/uint16/vec3.h similarity index 98% rename from PyGLM/types/vec/uint16/vec3.h rename to PyGLM_lib/PyGLM/types/vec/uint16/vec3.h index 8271d33f..ffa63aca 100644 --- a/PyGLM/types/vec/uint16/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/uint16/vec3.h @@ -67,9 +67,9 @@ static PyNumberMethods hu16vec3NumMethods = { (binaryfunc)vec_iand<3, glm::u16>, //nb_inplace_and (binaryfunc)vec_ixor<3, glm::u16>, //nb_inplace_xor (binaryfunc)vec_ior<3, glm::u16>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<3, glm::u16>, //nb_floor_divide (binaryfunc)vec_div<3, glm::u16>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<3, glm::u16>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<3, glm::u16>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -118,7 +118,7 @@ static PyTypeObject hu16vec3IterType = { static PyGLMTypeObject hu16vec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u16vec3", /* tp_name */ sizeof(vec<3, glm::u16>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint16/vec4.h b/PyGLM_lib/PyGLM/types/vec/uint16/vec4.h similarity index 98% rename from PyGLM/types/vec/uint16/vec4.h rename to PyGLM_lib/PyGLM/types/vec/uint16/vec4.h index 25c32cce..83a980c4 100644 --- a/PyGLM/types/vec/uint16/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/uint16/vec4.h @@ -68,9 +68,9 @@ static PyNumberMethods hu16vec4NumMethods = { (binaryfunc)vec_iand<4, glm::u16>, //nb_inplace_and (binaryfunc)vec_ixor<4, glm::u16>, //nb_inplace_xor (binaryfunc)vec_ior<4, glm::u16>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<4, glm::u16>, //nb_floor_divide (binaryfunc)vec_div<4, glm::u16>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<4, glm::u16>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<4, glm::u16>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -119,7 +119,7 @@ static PyTypeObject hu16vec4IterType = { static PyGLMTypeObject hu16vec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u16vec4", /* tp_name */ sizeof(vec<4, glm::u16>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint32/all.h b/PyGLM_lib/PyGLM/types/vec/uint32/all.h similarity index 100% rename from PyGLM/types/vec/uint32/all.h rename to PyGLM_lib/PyGLM/types/vec/uint32/all.h diff --git a/PyGLM/types/vec/uint32/vec1.h b/PyGLM_lib/PyGLM/types/vec/uint32/vec1.h similarity index 97% rename from PyGLM/types/vec/uint32/vec1.h rename to PyGLM_lib/PyGLM/types/vec/uint32/vec1.h index 0dd0982f..3444ebb7 100644 --- a/PyGLM/types/vec/uint32/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/uint32/vec1.h @@ -65,9 +65,9 @@ static PyNumberMethods huvec1NumMethods = { (binaryfunc)vec_iand<1, glm::u32>, //nb_inplace_and (binaryfunc)vec_ixor<1, glm::u32>, //nb_inplace_xor (binaryfunc)vec_ior<1, glm::u32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<1, glm::u32>, //nb_floor_divide (binaryfunc)vec_div<1, glm::u32>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<1, glm::u32>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<1, glm::u32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -116,7 +116,7 @@ static PyTypeObject huvec1IterType = { static PyGLMTypeObject huvec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.uvec1", /* tp_name */ sizeof(vec<1, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint32/vec2.h b/PyGLM_lib/PyGLM/types/vec/uint32/vec2.h similarity index 98% rename from PyGLM/types/vec/uint32/vec2.h rename to PyGLM_lib/PyGLM/types/vec/uint32/vec2.h index 2485f14a..9e9ca8f8 100644 --- a/PyGLM/types/vec/uint32/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/uint32/vec2.h @@ -66,9 +66,9 @@ static PyNumberMethods huvec2NumMethods = { (binaryfunc)vec_iand<2, glm::u32>, //nb_inplace_and (binaryfunc)vec_ixor<2, glm::u32>, //nb_inplace_xor (binaryfunc)vec_ior<2, glm::u32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<2, glm::u32>, //nb_floor_divide (binaryfunc)vec_div<2, glm::u32>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<2, glm::u32>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<2, glm::u32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -117,7 +117,7 @@ static PyTypeObject huvec2IterType = { static PyGLMTypeObject huvec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.uvec2", /* tp_name */ sizeof(vec<2, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint32/vec3.h b/PyGLM_lib/PyGLM/types/vec/uint32/vec3.h similarity index 98% rename from PyGLM/types/vec/uint32/vec3.h rename to PyGLM_lib/PyGLM/types/vec/uint32/vec3.h index e93b390d..e1a0bcb8 100644 --- a/PyGLM/types/vec/uint32/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/uint32/vec3.h @@ -67,9 +67,9 @@ static PyNumberMethods huvec3NumMethods = { (binaryfunc)vec_iand<3, glm::u32>, //nb_inplace_and (binaryfunc)vec_ixor<3, glm::u32>, //nb_inplace_xor (binaryfunc)vec_ior<3, glm::u32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<3, glm::u32>, //nb_floor_divide (binaryfunc)vec_div<3, glm::u32>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<3, glm::u32>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<3, glm::u32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -118,7 +118,7 @@ static PyTypeObject huvec3IterType = { static PyGLMTypeObject huvec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.uvec3", /* tp_name */ sizeof(vec<3, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint32/vec4.h b/PyGLM_lib/PyGLM/types/vec/uint32/vec4.h similarity index 98% rename from PyGLM/types/vec/uint32/vec4.h rename to PyGLM_lib/PyGLM/types/vec/uint32/vec4.h index 4daad5bd..597f0996 100644 --- a/PyGLM/types/vec/uint32/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/uint32/vec4.h @@ -68,9 +68,9 @@ static PyNumberMethods huvec4NumMethods = { (binaryfunc)vec_iand<4, glm::u32>, //nb_inplace_and (binaryfunc)vec_ixor<4, glm::u32>, //nb_inplace_xor (binaryfunc)vec_ior<4, glm::u32>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<4, glm::u32>, //nb_floor_divide (binaryfunc)vec_div<4, glm::u32>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<4, glm::u32>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<4, glm::u32>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -119,7 +119,7 @@ static PyTypeObject huvec4IterType = { static PyGLMTypeObject huvec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.uvec4", /* tp_name */ sizeof(vec<4, glm::u32>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint64/all.h b/PyGLM_lib/PyGLM/types/vec/uint64/all.h similarity index 100% rename from PyGLM/types/vec/uint64/all.h rename to PyGLM_lib/PyGLM/types/vec/uint64/all.h diff --git a/PyGLM/types/vec/uint64/vec1.h b/PyGLM_lib/PyGLM/types/vec/uint64/vec1.h similarity index 97% rename from PyGLM/types/vec/uint64/vec1.h rename to PyGLM_lib/PyGLM/types/vec/uint64/vec1.h index a526885a..81485a95 100644 --- a/PyGLM/types/vec/uint64/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/uint64/vec1.h @@ -65,9 +65,9 @@ static PyNumberMethods hu64vec1NumMethods = { (binaryfunc)vec_iand<1, glm::u64>, //nb_inplace_and (binaryfunc)vec_ixor<1, glm::u64>, //nb_inplace_xor (binaryfunc)vec_ior<1, glm::u64>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<1, glm::u64>, //nb_floor_divide (binaryfunc)vec_div<1, glm::u64>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<1, glm::u64>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<1, glm::u64>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -116,7 +116,7 @@ static PyTypeObject hu64vec1IterType = { static PyGLMTypeObject hu64vec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u64vec1", /* tp_name */ sizeof(vec<1, glm::u64>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint64/vec2.h b/PyGLM_lib/PyGLM/types/vec/uint64/vec2.h similarity index 98% rename from PyGLM/types/vec/uint64/vec2.h rename to PyGLM_lib/PyGLM/types/vec/uint64/vec2.h index ded9b7e9..78aafd0f 100644 --- a/PyGLM/types/vec/uint64/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/uint64/vec2.h @@ -66,9 +66,9 @@ static PyNumberMethods hu64vec2NumMethods = { (binaryfunc)vec_iand<2, glm::u64>, //nb_inplace_and (binaryfunc)vec_ixor<2, glm::u64>, //nb_inplace_xor (binaryfunc)vec_ior<2, glm::u64>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<2, glm::u64>, //nb_floor_divide (binaryfunc)vec_div<2, glm::u64>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<2, glm::u64>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<2, glm::u64>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -117,7 +117,7 @@ static PyTypeObject hu64vec2IterType = { static PyGLMTypeObject hu64vec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u64vec2", /* tp_name */ sizeof(vec<2, glm::u64>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint64/vec3.h b/PyGLM_lib/PyGLM/types/vec/uint64/vec3.h similarity index 98% rename from PyGLM/types/vec/uint64/vec3.h rename to PyGLM_lib/PyGLM/types/vec/uint64/vec3.h index 932aa2bb..559cd5da 100644 --- a/PyGLM/types/vec/uint64/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/uint64/vec3.h @@ -67,9 +67,9 @@ static PyNumberMethods hu64vec3NumMethods = { (binaryfunc)vec_iand<3, glm::u64>, //nb_inplace_and (binaryfunc)vec_ixor<3, glm::u64>, //nb_inplace_xor (binaryfunc)vec_ior<3, glm::u64>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<3, glm::u64>, //nb_floor_divide (binaryfunc)vec_div<3, glm::u64>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<3, glm::u64>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<3, glm::u64>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -118,7 +118,7 @@ static PyTypeObject hu64vec3IterType = { static PyGLMTypeObject hu64vec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u64vec3", /* tp_name */ sizeof(vec<3, glm::u64>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint64/vec4.h b/PyGLM_lib/PyGLM/types/vec/uint64/vec4.h similarity index 98% rename from PyGLM/types/vec/uint64/vec4.h rename to PyGLM_lib/PyGLM/types/vec/uint64/vec4.h index 4b69f1d8..dbdcc705 100644 --- a/PyGLM/types/vec/uint64/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/uint64/vec4.h @@ -68,9 +68,9 @@ static PyNumberMethods hu64vec4NumMethods = { (binaryfunc)vec_iand<4, glm::u64>, //nb_inplace_and (binaryfunc)vec_ixor<4, glm::u64>, //nb_inplace_xor (binaryfunc)vec_ior<4, glm::u64>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<4, glm::u64>, //nb_floor_divide (binaryfunc)vec_div<4, glm::u64>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<4, glm::u64>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<4, glm::u64>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -119,7 +119,7 @@ static PyTypeObject hu64vec4IterType = { static PyGLMTypeObject hu64vec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u64vec4", /* tp_name */ sizeof(vec<4, glm::u64>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint8/all.h b/PyGLM_lib/PyGLM/types/vec/uint8/all.h similarity index 100% rename from PyGLM/types/vec/uint8/all.h rename to PyGLM_lib/PyGLM/types/vec/uint8/all.h diff --git a/PyGLM/types/vec/uint8/vec1.h b/PyGLM_lib/PyGLM/types/vec/uint8/vec1.h similarity index 98% rename from PyGLM/types/vec/uint8/vec1.h rename to PyGLM_lib/PyGLM/types/vec/uint8/vec1.h index e8a32d85..d7b52271 100644 --- a/PyGLM/types/vec/uint8/vec1.h +++ b/PyGLM_lib/PyGLM/types/vec/uint8/vec1.h @@ -65,9 +65,9 @@ static PyNumberMethods hu8vec1NumMethods = { (binaryfunc)vec_iand<1, glm::u8>, //nb_inplace_and (binaryfunc)vec_ixor<1, glm::u8>, //nb_inplace_xor (binaryfunc)vec_ior<1, glm::u8>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<1, glm::u8>, //nb_floor_divide (binaryfunc)vec_div<1, glm::u8>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<1, glm::u8>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<1, glm::u8>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -116,7 +116,7 @@ static PyTypeObject hu8vec1IterType = { static PyGLMTypeObject hu8vec1GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u8vec1", /* tp_name */ sizeof(vec<1, glm::u8>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint8/vec2.h b/PyGLM_lib/PyGLM/types/vec/uint8/vec2.h similarity index 98% rename from PyGLM/types/vec/uint8/vec2.h rename to PyGLM_lib/PyGLM/types/vec/uint8/vec2.h index ede2612a..3ef212bc 100644 --- a/PyGLM/types/vec/uint8/vec2.h +++ b/PyGLM_lib/PyGLM/types/vec/uint8/vec2.h @@ -66,9 +66,9 @@ static PyNumberMethods hu8vec2NumMethods = { (binaryfunc)vec_iand<2, glm::u8>, //nb_inplace_and (binaryfunc)vec_ixor<2, glm::u8>, //nb_inplace_xor (binaryfunc)vec_ior<2, glm::u8>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<2, glm::u8>, //nb_floor_divide (binaryfunc)vec_div<2, glm::u8>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<2, glm::u8>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<2, glm::u8>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -117,7 +117,7 @@ static PyTypeObject hu8vec2IterType = { static PyGLMTypeObject hu8vec2GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u8vec2", /* tp_name */ sizeof(vec<2, glm::u8>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint8/vec3.h b/PyGLM_lib/PyGLM/types/vec/uint8/vec3.h similarity index 98% rename from PyGLM/types/vec/uint8/vec3.h rename to PyGLM_lib/PyGLM/types/vec/uint8/vec3.h index 4d00f363..aff07f7b 100644 --- a/PyGLM/types/vec/uint8/vec3.h +++ b/PyGLM_lib/PyGLM/types/vec/uint8/vec3.h @@ -67,9 +67,9 @@ static PyNumberMethods hu8vec3NumMethods = { (binaryfunc)vec_iand<3, glm::u8>, //nb_inplace_and (binaryfunc)vec_ixor<3, glm::u8>, //nb_inplace_xor (binaryfunc)vec_ior<3, glm::u8>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<3, glm::u8>, //nb_floor_divide (binaryfunc)vec_div<3, glm::u8>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<3, glm::u8>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<3, glm::u8>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -118,7 +118,7 @@ static PyTypeObject hu8vec3IterType = { static PyGLMTypeObject hu8vec3GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u8vec3", /* tp_name */ sizeof(vec<3, glm::u8>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/PyGLM/types/vec/uint8/vec4.h b/PyGLM_lib/PyGLM/types/vec/uint8/vec4.h similarity index 98% rename from PyGLM/types/vec/uint8/vec4.h rename to PyGLM_lib/PyGLM/types/vec/uint8/vec4.h index c051500f..611f77da 100644 --- a/PyGLM/types/vec/uint8/vec4.h +++ b/PyGLM_lib/PyGLM/types/vec/uint8/vec4.h @@ -68,9 +68,9 @@ static PyNumberMethods hu8vec4NumMethods = { (binaryfunc)vec_iand<4, glm::u8>, //nb_inplace_and (binaryfunc)vec_ixor<4, glm::u8>, //nb_inplace_xor (binaryfunc)vec_ior<4, glm::u8>, //nb_inplace_or - 0, //nb_floor_divide + (binaryfunc)vec_div<4, glm::u8>, //nb_floor_divide (binaryfunc)vec_div<4, glm::u8>, - 0, //nb_inplace_floor_divide + (binaryfunc)vec_idiv<4, glm::u8>, //nb_inplace_floor_divide (binaryfunc)vec_idiv<4, glm::u8>, //nb_inplace_true_divide 0, //nb_index (binaryfunc)vec_matmul, //nb_matrix_multiply @@ -119,7 +119,7 @@ static PyTypeObject hu8vec4IterType = { static PyGLMTypeObject hu8vec4GLMType = { { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) "glm.u8vec4", /* tp_name */ sizeof(vec<4, glm::u8>), /* tp_basicsize */ 0, /* tp_itemsize */ diff --git a/build_options.h b/PyGLM_lib/build_options.h similarity index 100% rename from build_options.h rename to PyGLM_lib/build_options.h diff --git a/PyGLM_lib/glm b/PyGLM_lib/glm new file mode 160000 index 00000000..37bd3750 --- /dev/null +++ b/PyGLM_lib/glm @@ -0,0 +1 @@ +Subproject commit 37bd375018f5c54bf91a863e846e21862148d058 diff --git a/license.h b/PyGLM_lib/license.h similarity index 100% rename from license.h rename to PyGLM_lib/license.h diff --git a/PyGLM_lib/version.h b/PyGLM_lib/version.h new file mode 100644 index 00000000..31226c55 --- /dev/null +++ b/PyGLM_lib/version.h @@ -0,0 +1,8 @@ +#define _TO_STRING(x) #x +#define TO_STRING(x) _TO_STRING(x) + +#ifdef PyGLM_DEBUG +#define VERSION 2.dev1 +#endif + +#define PyGLM_VERSION TO_STRING(VERSION) \ No newline at end of file diff --git a/README.md b/README.md index 222e350b..28c484d3 100644 --- a/README.md +++ b/README.md @@ -20,25 +20,34 @@ It has a lot of possible use cases, including **3D\-Graphics** \(OpenGL, DirectX At the same time, it has **great performance**, usually being **a lot faster than numpy\!** \(see [end of page](#speed-comparison-to-numpy)\) \(*depending on the individual function*\) ### Installation -**PyGLM** supports **Windows**, **Linux**, **MacOS** and other operating systems with either x86 \(**32\-bit**\) or x64 \(**64\-bit**\) architecture, -running **Python 3**\.5 or higher\. \(Prior versions of Python \- such as Python 2 \- were supported up to PyGLM version 0\.4\.8b1\) +**PyGLM** supports **Windows**, **Linux**, **MacOS** and other operating systems\. It can be installed from the [PyPI](https://pypi.python.org/pypi/PyGLM) using [pip](https://pip.pypa.io/en/stable/): ``` batch -pip install PyGLM -# please make sure to install "PyGLM" and not "glm", which is a different module +pip install pyglm ``` And finally imported and used: ``` python -import glm +from pyglm import glm ``` +*Changed in version 2\.8* +When using PyGLM version *2\.7\.3* or earlier, use +``` python +try: + from pyglm import glm +except ImportError: + import glm + ``` + +**Attention: Using ``` import glm ``` will be deprecated in PyGLM 3\.0\.** ### Using PyGLM PyGLM's syntax is very similar to the original GLM's syntax\. -There is no need to import anything but **glm**, as it already contains the entire package\. +The module ``` glm ``` contains all of PyGLM's types and functions\. +[Typing stubs](https://github.com/esoma/pyglm-typing) by [@esoma](https://github.com/esoma) are available in the ``` glm_typing ``` module\. For more information, take a look at the [wiki](https://github.com/Zuzu-Typ/PyGLM/wiki)\. #### License requirements -Please make sure to **include the license for GLM** in your project when you use PyGLM\! +Please make sure to **include COPYING** in your project when you use PyGLM\! \(this is especially relevant for **binary distributions**, e\.g\. \*\.exe\) You can do so by copying the ``` COPYING ``` file \(or it's contents\) to your project\. @@ -87,13 +96,13 @@ Supplying an id of 0 will silence all warnings\. ### FAQ #### How to pass the matrices generated by PyGLM to OpenGL functions? -You will find an overview on the \[[Passing data to external libs](wiki/Passing-data-to-external-libs.md)\] page\. +You will find an overview on the \[[Passing data to external libs](https://github.com/Zuzu-Typ/PyGLM/wiki/Passing-data-to-external-libs/)\] page\. -#### Types and functions are not available after installing from the PyPI using ``` pip install glm ``` -Most likely you've installed [glm](https://pypi.org/project/glm/), a JSON parser and not [PyGLM](https://pypi.org/project/PyGLM/) \(or a very early version of PyGLM\)\.   +#### Types and functions are not available after installing from the PyPI using ``` pip install glm ``` +Most likely you've installed [glm](https://pypi.org/project/glm/), a JSON parser and not [PyGLM](https://pypi.org/project/PyGLM/) \(or a very early version of PyGLM\)\. The correct install command is: -``` -pip install PyGLM +``` batch +pip install pyglm ``` #### Why is *<experimental extension name here>* not supported? @@ -101,50 +110,77 @@ I prefer not to add too many experimental extensions to PyGLM, especially as the If you **need a specific experimental extension**, feel free to **submit a feature request** on the [issue tracker](https://github.com/Zuzu-Typ/PyGLM/issues)\.   I try adding them on a one\-by\-one basis\. -#### Why are Python versions prior to 3\.5 no longer supported? -Starting with version [0\.5\.0b1](https://github.com/Zuzu-Typ/PyGLM/releases/tag/0.5.0b1) I decided to use C\+\+ to build PyGLM, using [glm](https://glm.g-truc.net/) under the hood \- which requires C\+\+ 11 or upwards\.   -Only Python versions 3\.5\+ support C\+\+ 11, thus I was forced to stop supporting older versions\.   -The last version to support Python 2 and <3\.5 is [0\.4\.8b1](https://github.com/Zuzu-Typ/PyGLM/releases/tag/0.4.8b1)\. - ### Short example ``` Python ->>> import glm ->>> v = glm.vec3() ->>> v.x = 7 ->>> print(v.xxy) -vec3( 7, 7, 0 ) +from pyglm import glm + +# Create a 3D vector +v1 = glm.vec3(1, 2, 3) +v2 = glm.vec3(4, 5, 6) + +# Vector addition +v3 = v1 + v2 +print(f"Vector addition: {v3}") +# Vector addition: vec3( 5, 7, 9 ) + +# Vector cross product +# -> The resulting vector is perpendicular to v1 and v2. +cross_product = glm.cross(v1, v2) +print(f"Cross product: {cross_product}") +# Cross product: vec3( -3, 6, -3 ) + +# Vector dot product +# -> If the dot product is equal to 0, the two inputs are perpendicular. +dot_product = glm.dot(v1, cross_product) +print(f"Dot product: {dot_product}") +# Dot product: 0.0 + +# Create a 4x4 identity matrix +matrix = glm.mat4() +print(f"Identity matrix:\n{matrix}") +# Identity matrix: +# [ 1 ][ 0 ][ 0 ][ 0 ] +# [ 0 ][ 1 ][ 0 ][ 0 ] +# [ 0 ][ 0 ][ 1 ][ 0 ] +# [ 0 ][ 0 ][ 0 ][ 1 ] ->>> m = glm.mat4() ->>> print(m) -[ 1 | 0 | 0 | 0 ] -[ 0 | 1 | 0 | 0 ] -[ 0 | 0 | 1 | 0 ] -[ 0 | 0 | 0 | 1 ] +# Rotate the matrix around the Z-axis +angle_in_radians = glm.radians(45) # Convert 45 degrees to radians +rotation_matrix = glm.rotate(matrix, angle_in_radians, glm.vec3(0, 0, 1)) +print(f"Rotation matrix (45 degrees around Z-axis):\n{rotation_matrix}") +# Rotation matrix (45 degrees around Z-axis): +# [ 0.707107 ][ -0.707107 ][ 0 ][ 0 ] +# [ 0.707107 ][ 0.707107 ][ 0 ][ 0 ] +# [ 0 ][ 0 ][ 1 ][ 0 ] +# [ 0 ][ 0 ][ 0 ][ 1 ] ->>> v = glm.vec4(1, 2, 3, 4) ->>> print(v + (8, 7, 6, 5)) -vec4( 9, 9, 9, 9 ) +# Apply the rotation to a vector +# -> We use a vec4 with the w-component (given vec4(x, y, z, w)) set to 1, +# to put v1 into homogenous coordinates. +rotated_vector = rotation_matrix * glm.vec4(v1, 1) +print(f"Rotated vector: {rotated_vector}") +# Rotated vector: vec4( -0.707107, 2.12132, 3, 1 ) ``` ### PyGLM in action -Wanna see what PyGLM can do? +Want to see what PyGLM can do? Take a look at the [examples](https://github.com/Zuzu-Typ/LearnOpenGL-Python) from the popular LearnOpenGL tutorials by Joey De Vries running in Python using PyGLM\. ![LearnOpenGL](https://raw.githubusercontent.com/Zuzu-Typ/PyGLM/master/LearnOpenGL.png) ### Speed comparison to numpy -The following is the output generated by [test/PyGLM vs Numpy\.py](https://github.com/Zuzu-Typ/PyGLM/blob/master/test/PyGLM%20vs%20NumPy.py) +The following is the output generated by [test/PyGLM vs Numpy\.py](https://github.com/Zuzu-Typ/PyGLM/blob/master/test/PyGLM_vs_NumPy.py) ``` Evaluating performance of PyGLM compared to NumPy. Running on platform 'win32'. Python version: -3.10.0 (tags/v3.10.0:b494f59, Oct 4 2021, 19:00:18) [MSC v.1929 64 bit (AMD64)] +3.14.0 (tags/v3.14.0:ebf955d, Oct 7 2025, 10:15:03) [MSC v.1944 64 bit (AMD64)] Comparing the following module versions: -PyGLM (DEFAULT) version 2.5.2 +PyGLM (DEFAULT) version 2.8.3 vs -NumPy version 1.21.3 +NumPy version 2.3.5 ________________________________________________________________________________ The following table shows information about a task to be achieved and the time @@ -157,42 +193,42 @@ value. | Description | PyGLM time | NumPy time | ratio | +----------------------------------------+------------+------------+-----------+ | 3 component vector creation | | | | -| (100,000 times) | 8ms | 21ms | 2.69x | +| (100,000 times) | 4ms | 17ms | 4.54x | +----------------------------------------+------------+------------+-----------+ | 3 component vector creation with | | | | | custom components | | | | -| (50,000 times) | 8ms | 34ms | 4.32x | +| (50,000 times) | 4ms | 16ms | 3.82x | +----------------------------------------+------------+------------+-----------+ | dot product | | | | -| (50,000 times) | 4ms | 49ms | 10.93x | +| (50,000 times) | 2ms | 22ms | 10.17x | +----------------------------------------+------------+------------+-----------+ | cross product | | | | -| (25,000 times) | 2ms | 548ms | 234.34x | +| (25,000 times) | 1ms | 327ms | 252.59x | +----------------------------------------+------------+------------+-----------+ | L2-Norm of 3 component vector | | | | -| (100,000 times) | 7ms | 310ms | 44.49x | +| (100,000 times) | 4ms | 155ms | 39.04x | +----------------------------------------+------------+------------+-----------+ | 4x4 matrix creation | | | | -| (50,000 times) | 5ms | 11ms | 2.32x | +| (50,000 times) | 3ms | 11ms | 4.18x | +----------------------------------------+------------+------------+-----------+ | 4x4 identity matrix creation | | | | -| (100,000 times) | 7ms | 176ms | 24.05x | +| (100,000 times) | 4ms | 140ms | 37.98x | +----------------------------------------+------------+------------+-----------+ | 4x4 matrix transposition | | | | -| (50,000 times) | 5ms | 32ms | 6.19x | +| (50,000 times) | 3ms | 18ms | 6.93x | +----------------------------------------+------------+------------+-----------+ | 4x4 multiplicative inverse | | | | -| (50,000 times) | 4ms | 1925ms | 470.77x | +| (50,000 times) | 3ms | 216ms | 80.67x | +----------------------------------------+------------+------------+-----------+ | 3 component vector addition | | | | -| (100,000 times) | 5ms | 38ms | 7.17x | +| (100,000 times) | 3ms | 35ms | 11.13x | +----------------------------------------+------------+------------+-----------+ | 4x4 matrix multiplication | | | | -| (100,000 times) | 7ms | 39ms | 5.36x | +| (100,000 times) | 5ms | 37ms | 8.17x | +----------------------------------------+------------+------------+-----------+ | 4x4 matrix x vector multiplication | | | | -| (100,000 times) | 6ms | 116ms | 20.01x | +| (100,000 times) | 4ms | 107ms | 27.98x | +----------------------------------------+------------+------------+-----------+ -| TOTAL | 0.07s | 3.30s | 47.78x | +| TOTAL | 0.04s | 1.10s | 28.50x | +----------------------------------------+------------+------------+-----------+ - ``` \ No newline at end of file + ``` diff --git a/README.sb b/README.sb index ee2dd024..ce5857a8 100644 --- a/README.sb +++ b/README.sb @@ -18,25 +18,34 @@ It has a lot of possible use cases, including \b \3D-Graphics\ b\ (OpenGL, Direc At the same time, it has \b \great performance\ b\, usually being \b \a lot faster than numpy!\ b\ (see \url #speed-comparison-to-numpy \end of page\ url\) (\i \depending on the individual function\ i\) \h3 \Installation\ h3\ -\b \PyGLM\ b\ supports \b \Windows\ b\, \b \Linux\ b\, \b \MacOS\ b\ and other operating systems with either x86 (\b \32-bit\ b\) or x64 (\b \64-bit\ b\) architecture, -running \b \Python 3\ b\.5 or higher. (Prior versions of Python - such as Python 2 - were supported up to PyGLM version 0.4.8b1) +\b \PyGLM\ b\ supports \b \Windows\ b\, \b \Linux\ b\, \b \MacOS\ b\ and other operating systems. It can be installed from the \url https://pypi.python.org/pypi/PyGLM \PyPI\ url\ using \url https://pip.pypa.io/en/stable/ \pip\ url\: \code batch\ -pip install PyGLM -# please make sure to install "PyGLM" and not "glm", which is a different module +pip install pyglm \ code\ And finally imported and used: \code python \ -import glm +from pyglm import glm \ code\ +\i\Changed in version 2.8\i\ +When using PyGLM version \i \2.7.3\ i\ or earlier, use +\code python \ +try: + from pyglm import glm +except ImportError: + import glm +\ code\ + +\b \Attention: Using \code \import glm\ code\ will be deprecated in PyGLM 3.0.\ b\ \h3 \Using PyGLM\ h3\ PyGLM's syntax is very similar to the original GLM's syntax. -There is no need to import anything but \b \glm\ b\, as it already contains the entire package. +The module \code \glm\ code\ contains all of PyGLM's types and functions. +\url https://github.com/esoma/pyglm-typing \Typing stubs\ url\ by \url https://github.com/esoma \@esoma\ url\ are available in the \code \glm_typing\ code\ module. For more information, take a look at the \url https://github.com/Zuzu-Typ/PyGLM/wiki \wiki\ url\. \h4 \License requirements\ h4\ -Please make sure to \b \include the license for GLM\ b\ in your project when you use PyGLM! +Please make sure to \b \include COPYING\ b\ in your project when you use PyGLM! (this is especially relevant for \b \binary distributions\ b\, e.g. *.exe) You can do so by copying the \code \COPYING\ code\ file (or it's contents) to your project. @@ -85,64 +94,91 @@ Supplying an id of 0 will silence all warnings. \h3\FAQ\h3\ \h4\How to pass the matrices generated by PyGLM to OpenGL functions?\h4\ -You will find an overview on the [\url wiki/Passing-data-to-external-libs.md \Passing data to external libs\ url\] page. +You will find an overview on the [\url https://github.com/Zuzu-Typ/PyGLM/wiki/Passing-data-to-external-libs/ \Passing data to external libs\ url\] page. -\h4\Types and functions are not available after installing from the PyPI using \code\pip install glm\code\\h4\ -Most likely you've installed \url https://pypi.org/project/glm/ \glm\ url\, a JSON parser and not \url https://pypi.org/project/PyGLM/ \PyGLM\ url\ (or a very early version of PyGLM). +\h4\Types and functions are not available after installing from the PyPI using \code \pip install glm\ code\\h4\ +Most likely you've installed \url https://pypi.org/project/glm/ \glm\ url\, a JSON parser and not \url https://pypi.org/project/PyGLM/ \PyGLM\ url\ (or a very early version of PyGLM). The correct install command is: -\code\ -pip install PyGLM -\code\ +\code batch \ +pip install pyglm +\ code\ \h4\Why is \i\\i\ not supported?\h4\ I prefer not to add too many experimental extensions to PyGLM, especially as they might change or be removed in the future and it is simply too much effort for me to keep up with all that. If you \b\need a specific experimental extension\b\, feel free to \b\submit a feature request\b\ on the \url https://github.com/Zuzu-Typ/PyGLM/issues \issue tracker\ url\. I try adding them on a one-by-one basis. -\h4\Why are Python versions prior to 3.5 no longer supported?\h4\ -Starting with version \url https://github.com/Zuzu-Typ/PyGLM/releases/tag/0.5.0b1 \0.5.0b1\ url\ I decided to use C++ to build PyGLM, using \url https://glm.g-truc.net/ \glm\ url\ under the hood - which requires C++ 11 or upwards. -Only Python versions 3.5+ support C++ 11, thus I was forced to stop supporting older versions. -The last version to support Python 2 and <3.5 is \url https://github.com/Zuzu-Typ/PyGLM/releases/tag/0.4.8b1 \0.4.8b1\ url\. - \h3 \Short example\ h3\ \code Python \ ->>> import glm ->>> v = glm.vec3() ->>> v.x = 7 ->>> print(v.xxy) -vec3( 7, 7, 0 ) - ->>> m = glm.mat4() ->>> print(m) -[ 1 | 0 | 0 | 0 ] -[ 0 | 1 | 0 | 0 ] -[ 0 | 0 | 1 | 0 ] -[ 0 | 0 | 0 | 1 ] - ->>> v = glm.vec4(1, 2, 3, 4) ->>> print(v + (8, 7, 6, 5)) -vec4( 9, 9, 9, 9 ) +from pyglm import glm + +# Create a 3D vector +v1 = glm.vec3(1, 2, 3) +v2 = glm.vec3(4, 5, 6) + +# Vector addition +v3 = v1 + v2 +print(f"Vector addition: {v3}") +# Vector addition: vec3( 5, 7, 9 ) + +# Vector cross product +# -> The resulting vector is perpendicular to v1 and v2. +cross_product = glm.cross(v1, v2) +print(f"Cross product: {cross_product}") +# Cross product: vec3( -3, 6, -3 ) + +# Vector dot product +# -> If the dot product is equal to 0, the two inputs are perpendicular. +dot_product = glm.dot(v1, cross_product) +print(f"Dot product: {dot_product}") +# Dot product: 0.0 + +# Create a 4x4 identity matrix +matrix = glm.mat4() +print(f"Identity matrix:\\n{matrix}") +# Identity matrix: +# [ 1 ][ 0 ][ 0 ][ 0 ] +# [ 0 ][ 1 ][ 0 ][ 0 ] +# [ 0 ][ 0 ][ 1 ][ 0 ] +# [ 0 ][ 0 ][ 0 ][ 1 ] + +# Rotate the matrix around the Z-axis +angle_in_radians = glm.radians(45) # Convert 45 degrees to radians +rotation_matrix = glm.rotate(matrix, angle_in_radians, glm.vec3(0, 0, 1)) +print(f"Rotation matrix (45 degrees around Z-axis):\\n{rotation_matrix}") +# Rotation matrix (45 degrees around Z-axis): +# [ 0.707107 ][ -0.707107 ][ 0 ][ 0 ] +# [ 0.707107 ][ 0.707107 ][ 0 ][ 0 ] +# [ 0 ][ 0 ][ 1 ][ 0 ] +# [ 0 ][ 0 ][ 0 ][ 1 ] + +# Apply the rotation to a vector +# -> We use a vec4 with the w-component (given vec4(x, y, z, w)) set to 1, +# to put v1 into homogenous coordinates. +rotated_vector = rotation_matrix * glm.vec4(v1, 1) +print(f"Rotated vector: {rotated_vector}") +# Rotated vector: vec4( -0.707107, 2.12132, 3, 1 ) \ code\ \h3\PyGLM in action\h3\ -Wanna see what PyGLM can do? +Want to see what PyGLM can do? Take a look at the \url https://github.com/Zuzu-Typ/LearnOpenGL-Python\examples\ url\ from the popular LearnOpenGL tutorials by Joey De Vries running in Python using PyGLM. \raw\![LearnOpenGL](https://raw.githubusercontent.com/Zuzu-Typ/PyGLM/master/LearnOpenGL.png)\raw\ \h3 \Speed comparison to numpy\ h3\ -The following is the output generated by \url https://github.com/Zuzu-Typ/PyGLM/blob/master/test/PyGLM%20vs%20NumPy.py \test/PyGLM vs Numpy.py\ url\ +The following is the output generated by \url https://github.com/Zuzu-Typ/PyGLM/blob/master/test/PyGLM_vs_NumPy.py \test/PyGLM vs Numpy.py\ url\ \code \ Evaluating performance of PyGLM compared to NumPy. Running on platform 'win32'. Python version: -3.10.0 (tags/v3.10.0:b494f59, Oct 4 2021, 19:00:18) [MSC v.1929 64 bit (AMD64)] +3.13.0 (tags/v3.13.0:60403a5, Oct 7 2024, 09:38:07) [MSC v.1941 64 bit (AMD64)] Comparing the following module versions: -PyGLM (DEFAULT) version 2.5.2 +PyGLM (DEFAULT) version 2.7.2 vs -NumPy version 1.21.3 +NumPy version 2.1.2 ________________________________________________________________________________ The following table shows information about a task to be achieved and the time @@ -155,42 +191,42 @@ value. | Description | PyGLM time | NumPy time | ratio | +----------------------------------------+------------+------------+-----------+ | 3 component vector creation | | | | -| (100,000 times) | 8ms | 21ms | 2.69x | +| (100,000 times) | 8ms | 30ms | 3.78x | +----------------------------------------+------------+------------+-----------+ | 3 component vector creation with | | | | | custom components | | | | -| (50,000 times) | 8ms | 34ms | 4.32x | +| (50,000 times) | 8ms | 33ms | 4.05x | +----------------------------------------+------------+------------+-----------+ | dot product | | | | -| (50,000 times) | 4ms | 49ms | 10.93x | +| (50,000 times) | 3ms | 46ms | 13.53x | +----------------------------------------+------------+------------+-----------+ | cross product | | | | -| (25,000 times) | 2ms | 548ms | 234.34x | +| (25,000 times) | 2ms | 523ms | 288.77x | +----------------------------------------+------------+------------+-----------+ | L2-Norm of 3 component vector | | | | -| (100,000 times) | 7ms | 310ms | 44.49x | +| (100,000 times) | 5ms | 249ms | 49.05x | +----------------------------------------+------------+------------+-----------+ | 4x4 matrix creation | | | | -| (50,000 times) | 5ms | 11ms | 2.32x | +| (50,000 times) | 5ms | 15ms | 3.03x | +----------------------------------------+------------+------------+-----------+ | 4x4 identity matrix creation | | | | -| (100,000 times) | 7ms | 176ms | 24.05x | +| (100,000 times) | 6ms | 222ms | 36.61x | +----------------------------------------+------------+------------+-----------+ | 4x4 matrix transposition | | | | -| (50,000 times) | 5ms | 32ms | 6.19x | +| (50,000 times) | 3ms | 23ms | 6.73x | +----------------------------------------+------------+------------+-----------+ | 4x4 multiplicative inverse | | | | -| (50,000 times) | 4ms | 1925ms | 470.77x | +| (50,000 times) | 4ms | 336ms | 90.30x | +----------------------------------------+------------+------------+-----------+ | 3 component vector addition | | | | -| (100,000 times) | 5ms | 38ms | 7.17x | +| (100,000 times) | 5ms | 52ms | 10.11x | +----------------------------------------+------------+------------+-----------+ | 4x4 matrix multiplication | | | | -| (100,000 times) | 7ms | 39ms | 5.36x | +| (100,000 times) | 8ms | 55ms | 6.85x | +----------------------------------------+------------+------------+-----------+ | 4x4 matrix x vector multiplication | | | | -| (100,000 times) | 6ms | 116ms | 20.01x | +| (100,000 times) | 6ms | 152ms | 23.39x | +----------------------------------------+------------+------------+-----------+ -| TOTAL | 0.07s | 3.30s | 47.78x | +| TOTAL | 0.06s | 1.74s | 26.97x | +----------------------------------------+------------+------------+-----------+ \ code\ \ No newline at end of file diff --git a/Update README.bat b/Update README.bat new file mode 100644 index 00000000..02b9a1f3 --- /dev/null +++ b/Update README.bat @@ -0,0 +1,2 @@ +python "vs-project/SlashBack.py" README.sb +PAUSE \ No newline at end of file diff --git a/VERSION b/VERSION new file mode 100644 index 00000000..9f8d8a91 --- /dev/null +++ b/VERSION @@ -0,0 +1 @@ +2.8.3 diff --git a/glm b/glm deleted file mode 160000 index fcda03b5..00000000 --- a/glm +++ /dev/null @@ -1 +0,0 @@ -Subproject commit fcda03b54596adda543bcdccc6c1879e380c86a7 diff --git a/glm/__init__.py b/glm/__init__.py new file mode 100644 index 00000000..db87dbb3 --- /dev/null +++ b/glm/__init__.py @@ -0,0 +1,6 @@ +from pyglm.glm import * +from pyglm import glm_typing, typing, __version__ + +import warnings as __warnings + +__warnings.warn("Importing PyGLM via \"import glm\" is going to be deprecated in the future.\nUse \"from pyglm import glm\" instead", PendingDeprecationWarning, stacklevel=2) diff --git a/glm/py.typed b/glm/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/pyglm-stubs/LICENSE b/pyglm-stubs/LICENSE new file mode 100644 index 00000000..a9266221 --- /dev/null +++ b/pyglm-stubs/LICENSE @@ -0,0 +1,7 @@ +Copyright 2021 Erik Soma + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/pyglm-stubs/__init__.py b/pyglm-stubs/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/pyglm-stubs/glm/__init__.py b/pyglm-stubs/glm/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/pyglm-stubs/glm/__init__.pyi b/pyglm-stubs/glm/__init__.pyi new file mode 100644 index 00000000..575429ed --- /dev/null +++ b/pyglm-stubs/glm/__init__.pyi @@ -0,0 +1,19284 @@ + +# generated by tools/generate.py +# https://github.com/esoma/pyglm-typing/ + +import ctypes +from typing import (Any, Callable, Generator, Generic, Iterable, List, Literal, + Optional, SupportsInt, Tuple, Type, TypeVar, Union, + overload) + +from PyGLM import glm_typing + +_T = TypeVar('_T') +_VT = TypeVar('_VT', bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, mvec2, mvec3, mvec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4, vec1, vec2, vec3, vec4) +_NF32VT = TypeVar('_NF32VT', bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4) +_FDVT = TypeVar('_FDVT', dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, mvec2, mvec3, mvec4, vec1, vec2, vec3, vec4) +_NF32DFVT = TypeVar('_NF32DFVT', dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4) +_NF32DFV1T = TypeVar('_NF32DFV1T', bound=dvec1) +_NF32DFV2T = TypeVar('_NF32DFV2T', dmvec2, dvec2) +_NF32DFV3T = TypeVar('_NF32DFV3T', dmvec3, dvec3) +_NF32DFV4T = TypeVar('_NF32DFV4T', dmvec4, dvec4) +_NF32V1T = TypeVar('_NF32V1T', bvec1, dvec1, i16vec1, i64vec1, i8vec1, ivec1, u16vec1, u64vec1, u8vec1, uvec1) +_NF32V2T = TypeVar('_NF32V2T', bvec2, dmvec2, dvec2, i16vec2, i64vec2, i8vec2, imvec2, ivec2, u16vec2, u64vec2, u8vec2, umvec2, uvec2) +_NF32V3T = TypeVar('_NF32V3T', bvec3, dmvec3, dvec3, i16vec3, i64vec3, i8vec3, imvec3, ivec3, u16vec3, u64vec3, u8vec3, umvec3, uvec3) +_NF32V4T = TypeVar('_NF32V4T', bvec4, dmvec4, dvec4, i16vec4, i64vec4, i8vec4, imvec4, ivec4, u16vec4, u64vec4, u8vec4, umvec4, uvec4) +_IVT = TypeVar('_IVT', i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4) +_UVT = TypeVar('_UVT', u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4) +_NI32IVT = TypeVar('_NI32IVT', i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4) +_NI32IUVT = TypeVar('_NI32IUVT', i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4) +_NI32IUV1T = TypeVar('_NI32IUV1T', i16vec1, i64vec1, i8vec1, u16vec1, u64vec1, u8vec1, uvec1) +_NI32IUV2T = TypeVar('_NI32IUV2T', i16vec2, i64vec2, i8vec2, u16vec2, u64vec2, u8vec2, umvec2, uvec2) +_NI32IUV3T = TypeVar('_NI32IUV3T', i16vec3, i64vec3, i8vec3, u16vec3, u64vec3, u8vec3, umvec3, uvec3) +_NI32IUV4T = TypeVar('_NI32IUV4T', i16vec4, i64vec4, i8vec4, u16vec4, u64vec4, u8vec4, umvec4, uvec4) +_MT = TypeVar('_MT', dmat2x2, dmat2x3, dmat2x4, dmat3x2, dmat3x3, dmat3x4, dmat4x2, dmat4x3, dmat4x4, imat2x2, imat2x3, imat2x4, imat3x2, imat3x3, imat3x4, imat4x2, imat4x3, imat4x4, mat2x2, mat2x3, mat2x4, mat3x2, mat3x3, mat3x4, mat4x2, mat4x3, mat4x4, umat2x2, umat2x3, umat2x4, umat3x2, umat3x3, umat3x4, umat4x2, umat4x3, umat4x4) +_NF32FDMSQRT = TypeVar('_NF32FDMSQRT', dmat2x2, dmat3x3, dmat4x4) +_NF32M2XNT = TypeVar('_NF32M2XNT', dmat2x2, dmat2x3, dmat2x4, imat2x2, imat2x3, imat2x4, umat2x2, umat2x3, umat2x4) +_NF32M3XNT = TypeVar('_NF32M3XNT', dmat3x2, dmat3x3, dmat3x4, imat3x2, imat3x3, imat3x4, umat3x2, umat3x3, umat3x4) +_NF32M4XNT = TypeVar('_NF32M4XNT', dmat4x2, dmat4x3, dmat4x4, imat4x2, imat4x3, imat4x4, umat4x2, umat4x3, umat4x4) +_NF32M2X2T = TypeVar('_NF32M2X2T', dmat2x2, imat2x2, umat2x2) +_NF32M2X3T = TypeVar('_NF32M2X3T', dmat2x3, imat2x3, umat2x3) +_NF32M2X4T = TypeVar('_NF32M2X4T', dmat2x4, imat2x4, umat2x4) +_NF32M3X2T = TypeVar('_NF32M3X2T', dmat3x2, imat3x2, umat3x2) +_NF32M3X3T = TypeVar('_NF32M3X3T', dmat3x3, imat3x3, umat3x3) +_NF32M3X4T = TypeVar('_NF32M3X4T', dmat3x4, imat3x4, umat3x4) +_NF32M4X2T = TypeVar('_NF32M4X2T', dmat4x2, imat4x2, umat4x2) +_NF32M4X3T = TypeVar('_NF32M4X3T', dmat4x3, imat4x3, umat4x3) +_NF32M4X4T = TypeVar('_NF32M4X4T', dmat4x4, imat4x4, umat4x4) +_QT = TypeVar('_QT', dquat, quat) +_NF32QT = TypeVar('_NF32QT', bound=dquat) + +bool_ = ctypes.c_bool +c_int16 = ctypes.c_short +int16 = ctypes.c_short +c_int32 = ctypes.c_long +int32 = ctypes.c_long +c_int64 = ctypes.c_longlong +int64 = ctypes.c_longlong +c_int8 = ctypes.c_byte +int8 = ctypes.c_byte +c_uint16 = ctypes.c_ushort +uint16 = ctypes.c_ushort +c_uint32 = ctypes.c_ulong +uint32 = ctypes.c_ulong +c_uint64 = ctypes.c_ulonglong +uint64 = ctypes.c_ulonglong +c_uint8 = ctypes.c_ubyte +uint8 = ctypes.c_ubyte +double = ctypes.c_double +float64 = ctypes.c_double +float32 = ctypes.c_float +float_ = ctypes.c_float + + +class bvec1: + x: bool + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.BAnyVector2, glm_typing.BAnyVector3, glm_typing.BAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> bool: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[bool, None, None]: ... + + def __neg__(self) -> bvec1: ... + def __pos__(self) -> bvec1: ... + def __abs__(self) -> bvec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[bool]: ... + def to_tuple(self) -> Tuple[bool]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> bvec1: ... + + def __add__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __radd__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __iadd__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + def __sub__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rsub__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __isub__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __mul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __rmul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __imul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + + def __mod__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rmod__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __imod__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + def __pow__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rpow__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __ipow__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + def __truediv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rtruediv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __itruediv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + def __floordiv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rfloordiv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __ifloordiv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __matmul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __imatmul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + + def __divmod__(self, other: bvec1) -> Tuple[bvec1, bvec1]: ... + + + +class bvec2: + x: bool + y: bool + + + @property + def xy(self) -> b8vec2: ... + @xy.setter + def xy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yx(self) -> b8vec2: ... + @yx.setter + def yx(self, value: glm_typing.B8Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.BAnyVector3, glm_typing.BAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> bool: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[bool, None, None]: ... + + def __neg__(self) -> bvec2: ... + def __pos__(self) -> bvec2: ... + def __abs__(self) -> bvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[bool]: ... + def to_tuple(self) -> Tuple[bool, bool]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> bvec2: ... + + def __add__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __radd__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __iadd__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + def __sub__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rsub__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __isub__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __mul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __rmul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __imul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + + def __mod__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rmod__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __imod__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + def __pow__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rpow__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __ipow__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + def __truediv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rtruediv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __itruediv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + def __floordiv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __matmul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __imatmul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + + def __divmod__(self, other: bvec2) -> Tuple[bvec2, bvec2]: ... + + + +class bvec3: + x: bool + y: bool + z: bool + + + @property + def xy(self) -> b8vec2: ... + @xy.setter + def xy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yx(self) -> b8vec2: ... + @yx.setter + def yx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xz(self) -> b8vec2: ... + @xz.setter + def xz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zx(self) -> b8vec2: ... + @zx.setter + def zx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yz(self) -> b8vec2: ... + @yz.setter + def yz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zy(self) -> b8vec2: ... + @zy.setter + def zy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xyz(self) -> b8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xzy(self) -> b8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yxz(self) -> b8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yzx(self) -> b8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zxy(self) -> b8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zyx(self) -> b8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.B8Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.BAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> bool: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[bool, None, None]: ... + + def __neg__(self) -> bvec3: ... + def __pos__(self) -> bvec3: ... + def __abs__(self) -> bvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[bool]: ... + def to_tuple(self) -> Tuple[bool, bool, bool]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> bvec3: ... + + def __add__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __radd__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __iadd__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + def __sub__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rsub__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __isub__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __mul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __rmul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __imul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + + def __mod__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rmod__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __imod__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + def __pow__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rpow__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __ipow__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + def __truediv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rtruediv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __itruediv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + def __floordiv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __matmul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __imatmul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + + def __divmod__(self, other: bvec3) -> Tuple[bvec3, bvec3]: ... + + + +class bvec4: + x: bool + y: bool + z: bool + w: bool + + + @property + def xy(self) -> b8vec2: ... + @xy.setter + def xy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yx(self) -> b8vec2: ... + @yx.setter + def yx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xz(self) -> b8vec2: ... + @xz.setter + def xz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zx(self) -> b8vec2: ... + @zx.setter + def zx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xw(self) -> b8vec2: ... + @xw.setter + def xw(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def wx(self) -> b8vec2: ... + @wx.setter + def wx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yz(self) -> b8vec2: ... + @yz.setter + def yz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zy(self) -> b8vec2: ... + @zy.setter + def zy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yw(self) -> b8vec2: ... + @yw.setter + def yw(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def wy(self) -> b8vec2: ... + @wy.setter + def wy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zw(self) -> b8vec2: ... + @zw.setter + def zw(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def wz(self) -> b8vec2: ... + @wz.setter + def wz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xyz(self) -> b8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xzy(self) -> b8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yxz(self) -> b8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yzx(self) -> b8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zxy(self) -> b8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zyx(self) -> b8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xyw(self) -> b8vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xwy(self) -> b8vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yxw(self) -> b8vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def ywx(self) -> b8vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wxy(self) -> b8vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wyx(self) -> b8vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xzw(self) -> b8vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xwz(self) -> b8vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zxw(self) -> b8vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zwx(self) -> b8vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wxz(self) -> b8vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wzx(self) -> b8vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yzw(self) -> b8vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def ywz(self) -> b8vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zyw(self) -> b8vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zwy(self) -> b8vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wyz(self) -> b8vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wzy(self) -> b8vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xyzw(self) -> b8vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xywz(self) -> b8vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xzyw(self) -> b8vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xzwy(self) -> b8vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xwyz(self) -> b8vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xwzy(self) -> b8vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def yxzw(self) -> b8vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def yxwz(self) -> b8vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def yzxw(self) -> b8vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def yzwx(self) -> b8vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def ywxz(self) -> b8vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def ywzx(self) -> b8vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zxyw(self) -> b8vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zxwy(self) -> b8vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zyxw(self) -> b8vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zywx(self) -> b8vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zwxy(self) -> b8vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zwyx(self) -> b8vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wxyz(self) -> b8vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wxzy(self) -> b8vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wyxz(self) -> b8vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wyzx(self) -> b8vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wzxy(self) -> b8vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wzyx(self) -> b8vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.B8Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> bool: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[bool, None, None]: ... + + def __neg__(self) -> bvec4: ... + def __pos__(self) -> bvec4: ... + def __abs__(self) -> bvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[bool]: ... + def to_tuple(self) -> Tuple[bool, bool, bool, bool]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> bvec4: ... + + def __add__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __radd__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __iadd__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + def __sub__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rsub__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __isub__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __mul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __rmul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __imul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + + def __mod__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rmod__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __imod__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + def __pow__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rpow__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __ipow__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + def __truediv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rtruediv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __itruediv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + def __floordiv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __matmul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __imatmul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + + def __divmod__(self, other: bvec4) -> Tuple[bvec4, bvec4]: ... + + + +class dmvec2: + x: float + y: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.DAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dmvec2: ... + def __pos__(self) -> dmvec2: ... + def __abs__(self) -> dmvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmvec2: ... + + def __add__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __radd__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __iadd__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + def __sub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rsub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __isub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rmod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __imod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + def __pow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rpow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __ipow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dmvec2) -> Tuple[dmvec2, dmvec2]: ... + + + +class dmvec3: + x: float + y: float + z: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xz(self) -> d64vec2: ... + @xz.setter + def xz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zx(self) -> d64vec2: ... + @zx.setter + def zx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yz(self) -> d64vec2: ... + @yz.setter + def yz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zy(self) -> d64vec2: ... + @zy.setter + def zy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xyz(self) -> d64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzy(self) -> d64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxz(self) -> d64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzx(self) -> d64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxy(self) -> d64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyx(self) -> d64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.D64Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dmvec3: ... + def __pos__(self) -> dmvec3: ... + def __abs__(self) -> dmvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmvec3: ... + + def __add__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __radd__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __iadd__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + def __sub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rsub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __isub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rmod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __imod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + def __pow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rpow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __ipow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dmvec3) -> Tuple[dmvec3, dmvec3]: ... + + + +class dmvec4: + x: float + y: float + z: float + w: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xz(self) -> d64vec2: ... + @xz.setter + def xz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zx(self) -> d64vec2: ... + @zx.setter + def zx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xw(self) -> d64vec2: ... + @xw.setter + def xw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wx(self) -> d64vec2: ... + @wx.setter + def wx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yz(self) -> d64vec2: ... + @yz.setter + def yz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zy(self) -> d64vec2: ... + @zy.setter + def zy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yw(self) -> d64vec2: ... + @yw.setter + def yw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wy(self) -> d64vec2: ... + @wy.setter + def wy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zw(self) -> d64vec2: ... + @zw.setter + def zw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wz(self) -> d64vec2: ... + @wz.setter + def wz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xyz(self) -> d64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzy(self) -> d64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxz(self) -> d64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzx(self) -> d64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxy(self) -> d64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyx(self) -> d64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xyw(self) -> d64vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xwy(self) -> d64vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxw(self) -> d64vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def ywx(self) -> d64vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wxy(self) -> d64vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wyx(self) -> d64vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzw(self) -> d64vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xwz(self) -> d64vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxw(self) -> d64vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zwx(self) -> d64vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wxz(self) -> d64vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wzx(self) -> d64vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzw(self) -> d64vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def ywz(self) -> d64vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyw(self) -> d64vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zwy(self) -> d64vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wyz(self) -> d64vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wzy(self) -> d64vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xyzw(self) -> d64vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xywz(self) -> d64vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xzyw(self) -> d64vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xzwy(self) -> d64vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xwyz(self) -> d64vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xwzy(self) -> d64vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yxzw(self) -> d64vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yxwz(self) -> d64vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yzxw(self) -> d64vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yzwx(self) -> d64vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def ywxz(self) -> d64vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def ywzx(self) -> d64vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zxyw(self) -> d64vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zxwy(self) -> d64vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zyxw(self) -> d64vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zywx(self) -> d64vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zwxy(self) -> d64vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zwyx(self) -> d64vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wxyz(self) -> d64vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wxzy(self) -> d64vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wyxz(self) -> d64vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wyzx(self) -> d64vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wzxy(self) -> d64vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wzyx(self) -> d64vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.D64Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dmvec4: ... + def __pos__(self) -> dmvec4: ... + def __abs__(self) -> dmvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmvec4: ... + + def __add__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __radd__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __iadd__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + def __sub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rsub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __isub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rmod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __imod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + def __pow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rpow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __ipow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dmvec4) -> Tuple[dmvec4, dmvec4]: ... + + +f64vec1 = dvec1 + +class dvec1: + x: float + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.DAnyVector2, glm_typing.DAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dvec1: ... + def __pos__(self) -> dvec1: ... + def __abs__(self) -> dvec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dvec1: ... + + def __add__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __radd__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __iadd__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + def __sub__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rsub__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __isub__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __mul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __imul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rmod__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __imod__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + def __pow__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rpow__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __ipow__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dvec1) -> Tuple[dvec1, dvec1]: ... + + +f64vec2 = dvec2 + +class dvec2: + x: float + y: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.DAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dvec2: ... + def __pos__(self) -> dvec2: ... + def __abs__(self) -> dvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dvec2: ... + + def __add__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __radd__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __iadd__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + def __sub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rsub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __isub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rmod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __imod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + def __pow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rpow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __ipow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dvec2) -> Tuple[dvec2, dvec2]: ... + + +f64vec3 = dvec3 + +class dvec3: + x: float + y: float + z: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xz(self) -> d64vec2: ... + @xz.setter + def xz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zx(self) -> d64vec2: ... + @zx.setter + def zx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yz(self) -> d64vec2: ... + @yz.setter + def yz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zy(self) -> d64vec2: ... + @zy.setter + def zy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xyz(self) -> d64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzy(self) -> d64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxz(self) -> d64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzx(self) -> d64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxy(self) -> d64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyx(self) -> d64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.D64Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dvec3: ... + def __pos__(self) -> dvec3: ... + def __abs__(self) -> dvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dvec3: ... + + def __add__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __radd__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __iadd__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + def __sub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rsub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __isub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rmod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __imod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + def __pow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rpow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __ipow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dvec3) -> Tuple[dvec3, dvec3]: ... + + +f64vec4 = dvec4 + +class dvec4: + x: float + y: float + z: float + w: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xz(self) -> d64vec2: ... + @xz.setter + def xz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zx(self) -> d64vec2: ... + @zx.setter + def zx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xw(self) -> d64vec2: ... + @xw.setter + def xw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wx(self) -> d64vec2: ... + @wx.setter + def wx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yz(self) -> d64vec2: ... + @yz.setter + def yz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zy(self) -> d64vec2: ... + @zy.setter + def zy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yw(self) -> d64vec2: ... + @yw.setter + def yw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wy(self) -> d64vec2: ... + @wy.setter + def wy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zw(self) -> d64vec2: ... + @zw.setter + def zw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wz(self) -> d64vec2: ... + @wz.setter + def wz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xyz(self) -> d64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzy(self) -> d64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxz(self) -> d64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzx(self) -> d64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxy(self) -> d64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyx(self) -> d64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xyw(self) -> d64vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xwy(self) -> d64vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxw(self) -> d64vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def ywx(self) -> d64vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wxy(self) -> d64vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wyx(self) -> d64vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzw(self) -> d64vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xwz(self) -> d64vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxw(self) -> d64vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zwx(self) -> d64vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wxz(self) -> d64vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wzx(self) -> d64vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzw(self) -> d64vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def ywz(self) -> d64vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyw(self) -> d64vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zwy(self) -> d64vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wyz(self) -> d64vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wzy(self) -> d64vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xyzw(self) -> d64vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xywz(self) -> d64vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xzyw(self) -> d64vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xzwy(self) -> d64vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xwyz(self) -> d64vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xwzy(self) -> d64vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yxzw(self) -> d64vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yxwz(self) -> d64vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yzxw(self) -> d64vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yzwx(self) -> d64vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def ywxz(self) -> d64vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def ywzx(self) -> d64vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zxyw(self) -> d64vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zxwy(self) -> d64vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zyxw(self) -> d64vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zywx(self) -> d64vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zwxy(self) -> d64vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zwyx(self) -> d64vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wxyz(self) -> d64vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wxzy(self) -> d64vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wyxz(self) -> d64vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wyzx(self) -> d64vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wzxy(self) -> d64vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wzyx(self) -> d64vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.D64Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dvec4: ... + def __pos__(self) -> dvec4: ... + def __abs__(self) -> dvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dvec4: ... + + def __add__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __radd__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __iadd__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + def __sub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rsub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __isub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rmod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __imod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + def __pow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rpow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __ipow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dvec4) -> Tuple[dvec4, dvec4]: ... + + + +class i16vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.IAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i16vec1: ... + def __pos__(self) -> i16vec1: ... + def __abs__(self) -> i16vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i16vec1: ... + + def __add__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __radd__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __iadd__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + def __sub__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rsub__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __isub__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __mul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __rmul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __imul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + + def __mod__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rmod__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __imod__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + def __pow__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rpow__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __ipow__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + def __truediv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rtruediv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __itruediv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + def __floordiv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __matmul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __imatmul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + + def __divmod__(self, other: i16vec1) -> Tuple[i16vec1, i16vec1]: ... + + + +class i16vec2: + x: int + y: int + + + @property + def xy(self) -> i16vec2: ... + @xy.setter + def xy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yx(self) -> i16vec2: ... + @yx.setter + def yx(self, value: glm_typing.I16Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i16vec2: ... + def __pos__(self) -> i16vec2: ... + def __abs__(self) -> i16vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i16vec2: ... + + def __add__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __radd__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __iadd__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + def __sub__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rsub__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __isub__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __mul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __rmul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __imul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + + def __mod__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rmod__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __imod__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + def __pow__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rpow__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __ipow__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + def __truediv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rtruediv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __itruediv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + def __floordiv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __matmul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + + def __divmod__(self, other: i16vec2) -> Tuple[i16vec2, i16vec2]: ... + + + +class i16vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i16vec2: ... + @xy.setter + def xy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yx(self) -> i16vec2: ... + @yx.setter + def yx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xz(self) -> i16vec2: ... + @xz.setter + def xz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zx(self) -> i16vec2: ... + @zx.setter + def zx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yz(self) -> i16vec2: ... + @yz.setter + def yz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zy(self) -> i16vec2: ... + @zy.setter + def zy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xyz(self) -> i16vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xzy(self) -> i16vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yxz(self) -> i16vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yzx(self) -> i16vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zxy(self) -> i16vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zyx(self) -> i16vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I16Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i16vec3: ... + def __pos__(self) -> i16vec3: ... + def __abs__(self) -> i16vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i16vec3: ... + + def __add__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __radd__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __iadd__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + def __sub__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rsub__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __isub__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __mul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __rmul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __imul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + + def __mod__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rmod__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __imod__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + def __pow__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rpow__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __ipow__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + def __truediv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rtruediv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __itruediv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + def __floordiv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __matmul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + + def __divmod__(self, other: i16vec3) -> Tuple[i16vec3, i16vec3]: ... + + + +class i16vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i16vec2: ... + @xy.setter + def xy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yx(self) -> i16vec2: ... + @yx.setter + def yx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xz(self) -> i16vec2: ... + @xz.setter + def xz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zx(self) -> i16vec2: ... + @zx.setter + def zx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xw(self) -> i16vec2: ... + @xw.setter + def xw(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def wx(self) -> i16vec2: ... + @wx.setter + def wx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yz(self) -> i16vec2: ... + @yz.setter + def yz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zy(self) -> i16vec2: ... + @zy.setter + def zy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yw(self) -> i16vec2: ... + @yw.setter + def yw(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def wy(self) -> i16vec2: ... + @wy.setter + def wy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zw(self) -> i16vec2: ... + @zw.setter + def zw(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def wz(self) -> i16vec2: ... + @wz.setter + def wz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xyz(self) -> i16vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xzy(self) -> i16vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yxz(self) -> i16vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yzx(self) -> i16vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zxy(self) -> i16vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zyx(self) -> i16vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xyw(self) -> i16vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xwy(self) -> i16vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yxw(self) -> i16vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def ywx(self) -> i16vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wxy(self) -> i16vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wyx(self) -> i16vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xzw(self) -> i16vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xwz(self) -> i16vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zxw(self) -> i16vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zwx(self) -> i16vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wxz(self) -> i16vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wzx(self) -> i16vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yzw(self) -> i16vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def ywz(self) -> i16vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zyw(self) -> i16vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zwy(self) -> i16vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wyz(self) -> i16vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wzy(self) -> i16vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xyzw(self) -> i16vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xywz(self) -> i16vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xzyw(self) -> i16vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xzwy(self) -> i16vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xwyz(self) -> i16vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xwzy(self) -> i16vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def yxzw(self) -> i16vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def yxwz(self) -> i16vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def yzxw(self) -> i16vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def yzwx(self) -> i16vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def ywxz(self) -> i16vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def ywzx(self) -> i16vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zxyw(self) -> i16vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zxwy(self) -> i16vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zyxw(self) -> i16vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zywx(self) -> i16vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zwxy(self) -> i16vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zwyx(self) -> i16vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wxyz(self) -> i16vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wxzy(self) -> i16vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wyxz(self) -> i16vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wyzx(self) -> i16vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wzxy(self) -> i16vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wzyx(self) -> i16vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I16Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i16vec4: ... + def __pos__(self) -> i16vec4: ... + def __abs__(self) -> i16vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i16vec4: ... + + def __add__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __radd__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __iadd__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + def __sub__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rsub__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __isub__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __mul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __rmul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __imul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + + def __mod__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rmod__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __imod__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + def __pow__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rpow__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __ipow__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + def __truediv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rtruediv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __itruediv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + def __floordiv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __matmul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __imatmul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + + def __divmod__(self, other: i16vec4) -> Tuple[i16vec4, i16vec4]: ... + + + +class i64vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.IAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i64vec1: ... + def __pos__(self) -> i64vec1: ... + def __abs__(self) -> i64vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i64vec1: ... + + def __add__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __radd__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __iadd__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + def __sub__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rsub__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __isub__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __mul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __rmul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __imul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + + def __mod__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rmod__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __imod__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + def __pow__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rpow__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __ipow__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + def __truediv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rtruediv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __itruediv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + def __floordiv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __matmul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __imatmul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + + def __divmod__(self, other: i64vec1) -> Tuple[i64vec1, i64vec1]: ... + + + +class i64vec2: + x: int + y: int + + + @property + def xy(self) -> i64vec2: ... + @xy.setter + def xy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yx(self) -> i64vec2: ... + @yx.setter + def yx(self, value: glm_typing.I64Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i64vec2: ... + def __pos__(self) -> i64vec2: ... + def __abs__(self) -> i64vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i64vec2: ... + + def __add__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __radd__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __iadd__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + def __sub__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rsub__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __isub__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __mul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __rmul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __imul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + + def __mod__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rmod__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __imod__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + def __pow__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rpow__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __ipow__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + def __truediv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rtruediv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __itruediv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + def __floordiv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __matmul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + + def __divmod__(self, other: i64vec2) -> Tuple[i64vec2, i64vec2]: ... + + + +class i64vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i64vec2: ... + @xy.setter + def xy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yx(self) -> i64vec2: ... + @yx.setter + def yx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xz(self) -> i64vec2: ... + @xz.setter + def xz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zx(self) -> i64vec2: ... + @zx.setter + def zx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yz(self) -> i64vec2: ... + @yz.setter + def yz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zy(self) -> i64vec2: ... + @zy.setter + def zy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xyz(self) -> i64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xzy(self) -> i64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yxz(self) -> i64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yzx(self) -> i64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zxy(self) -> i64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zyx(self) -> i64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I64Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i64vec3: ... + def __pos__(self) -> i64vec3: ... + def __abs__(self) -> i64vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i64vec3: ... + + def __add__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __radd__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __iadd__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + def __sub__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rsub__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __isub__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __mul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __rmul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __imul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + + def __mod__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rmod__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __imod__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + def __pow__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rpow__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __ipow__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + def __truediv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rtruediv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __itruediv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + def __floordiv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __matmul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + + def __divmod__(self, other: i64vec3) -> Tuple[i64vec3, i64vec3]: ... + + + +class i64vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i64vec2: ... + @xy.setter + def xy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yx(self) -> i64vec2: ... + @yx.setter + def yx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xz(self) -> i64vec2: ... + @xz.setter + def xz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zx(self) -> i64vec2: ... + @zx.setter + def zx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xw(self) -> i64vec2: ... + @xw.setter + def xw(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def wx(self) -> i64vec2: ... + @wx.setter + def wx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yz(self) -> i64vec2: ... + @yz.setter + def yz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zy(self) -> i64vec2: ... + @zy.setter + def zy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yw(self) -> i64vec2: ... + @yw.setter + def yw(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def wy(self) -> i64vec2: ... + @wy.setter + def wy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zw(self) -> i64vec2: ... + @zw.setter + def zw(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def wz(self) -> i64vec2: ... + @wz.setter + def wz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xyz(self) -> i64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xzy(self) -> i64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yxz(self) -> i64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yzx(self) -> i64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zxy(self) -> i64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zyx(self) -> i64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xyw(self) -> i64vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xwy(self) -> i64vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yxw(self) -> i64vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def ywx(self) -> i64vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wxy(self) -> i64vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wyx(self) -> i64vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xzw(self) -> i64vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xwz(self) -> i64vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zxw(self) -> i64vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zwx(self) -> i64vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wxz(self) -> i64vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wzx(self) -> i64vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yzw(self) -> i64vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def ywz(self) -> i64vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zyw(self) -> i64vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zwy(self) -> i64vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wyz(self) -> i64vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wzy(self) -> i64vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xyzw(self) -> i64vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xywz(self) -> i64vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xzyw(self) -> i64vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xzwy(self) -> i64vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xwyz(self) -> i64vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xwzy(self) -> i64vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def yxzw(self) -> i64vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def yxwz(self) -> i64vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def yzxw(self) -> i64vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def yzwx(self) -> i64vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def ywxz(self) -> i64vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def ywzx(self) -> i64vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zxyw(self) -> i64vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zxwy(self) -> i64vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zyxw(self) -> i64vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zywx(self) -> i64vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zwxy(self) -> i64vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zwyx(self) -> i64vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wxyz(self) -> i64vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wxzy(self) -> i64vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wyxz(self) -> i64vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wyzx(self) -> i64vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wzxy(self) -> i64vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wzyx(self) -> i64vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I64Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i64vec4: ... + def __pos__(self) -> i64vec4: ... + def __abs__(self) -> i64vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i64vec4: ... + + def __add__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __radd__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __iadd__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + def __sub__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rsub__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __isub__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __mul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __rmul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __imul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + + def __mod__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rmod__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __imod__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + def __pow__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rpow__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __ipow__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + def __truediv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rtruediv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __itruediv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + def __floordiv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __matmul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __imatmul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + + def __divmod__(self, other: i64vec4) -> Tuple[i64vec4, i64vec4]: ... + + + +class i8vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.IAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i8vec1: ... + def __pos__(self) -> i8vec1: ... + def __abs__(self) -> i8vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i8vec1: ... + + def __add__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __radd__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __iadd__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + def __sub__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rsub__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __isub__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __mul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __rmul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __imul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + + def __mod__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rmod__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __imod__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + def __pow__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rpow__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __ipow__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + def __truediv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rtruediv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __itruediv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + def __floordiv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __matmul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __imatmul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + + def __divmod__(self, other: i8vec1) -> Tuple[i8vec1, i8vec1]: ... + + + +class i8vec2: + x: int + y: int + + + @property + def xy(self) -> i8vec2: ... + @xy.setter + def xy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yx(self) -> i8vec2: ... + @yx.setter + def yx(self, value: glm_typing.I8Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i8vec2: ... + def __pos__(self) -> i8vec2: ... + def __abs__(self) -> i8vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i8vec2: ... + + def __add__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __radd__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __iadd__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + def __sub__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rsub__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __isub__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __mul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __rmul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __imul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + + def __mod__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rmod__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __imod__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + def __pow__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rpow__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __ipow__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + def __truediv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rtruediv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __itruediv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + def __floordiv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __matmul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + + def __divmod__(self, other: i8vec2) -> Tuple[i8vec2, i8vec2]: ... + + + +class i8vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i8vec2: ... + @xy.setter + def xy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yx(self) -> i8vec2: ... + @yx.setter + def yx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xz(self) -> i8vec2: ... + @xz.setter + def xz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zx(self) -> i8vec2: ... + @zx.setter + def zx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yz(self) -> i8vec2: ... + @yz.setter + def yz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zy(self) -> i8vec2: ... + @zy.setter + def zy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xyz(self) -> i8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xzy(self) -> i8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yxz(self) -> i8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yzx(self) -> i8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zxy(self) -> i8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zyx(self) -> i8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I8Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i8vec3: ... + def __pos__(self) -> i8vec3: ... + def __abs__(self) -> i8vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i8vec3: ... + + def __add__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __radd__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __iadd__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + def __sub__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rsub__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __isub__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __mul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __rmul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __imul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + + def __mod__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rmod__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __imod__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + def __pow__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rpow__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __ipow__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + def __truediv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rtruediv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __itruediv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + def __floordiv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __matmul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + + def __divmod__(self, other: i8vec3) -> Tuple[i8vec3, i8vec3]: ... + + + +class i8vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i8vec2: ... + @xy.setter + def xy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yx(self) -> i8vec2: ... + @yx.setter + def yx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xz(self) -> i8vec2: ... + @xz.setter + def xz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zx(self) -> i8vec2: ... + @zx.setter + def zx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xw(self) -> i8vec2: ... + @xw.setter + def xw(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def wx(self) -> i8vec2: ... + @wx.setter + def wx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yz(self) -> i8vec2: ... + @yz.setter + def yz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zy(self) -> i8vec2: ... + @zy.setter + def zy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yw(self) -> i8vec2: ... + @yw.setter + def yw(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def wy(self) -> i8vec2: ... + @wy.setter + def wy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zw(self) -> i8vec2: ... + @zw.setter + def zw(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def wz(self) -> i8vec2: ... + @wz.setter + def wz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xyz(self) -> i8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xzy(self) -> i8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yxz(self) -> i8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yzx(self) -> i8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zxy(self) -> i8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zyx(self) -> i8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xyw(self) -> i8vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xwy(self) -> i8vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yxw(self) -> i8vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def ywx(self) -> i8vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wxy(self) -> i8vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wyx(self) -> i8vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xzw(self) -> i8vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xwz(self) -> i8vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zxw(self) -> i8vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zwx(self) -> i8vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wxz(self) -> i8vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wzx(self) -> i8vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yzw(self) -> i8vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def ywz(self) -> i8vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zyw(self) -> i8vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zwy(self) -> i8vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wyz(self) -> i8vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wzy(self) -> i8vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xyzw(self) -> i8vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xywz(self) -> i8vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xzyw(self) -> i8vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xzwy(self) -> i8vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xwyz(self) -> i8vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xwzy(self) -> i8vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def yxzw(self) -> i8vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def yxwz(self) -> i8vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def yzxw(self) -> i8vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def yzwx(self) -> i8vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def ywxz(self) -> i8vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def ywzx(self) -> i8vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zxyw(self) -> i8vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zxwy(self) -> i8vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zyxw(self) -> i8vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zywx(self) -> i8vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zwxy(self) -> i8vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zwyx(self) -> i8vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wxyz(self) -> i8vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wxzy(self) -> i8vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wyxz(self) -> i8vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wyzx(self) -> i8vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wzxy(self) -> i8vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wzyx(self) -> i8vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I8Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i8vec4: ... + def __pos__(self) -> i8vec4: ... + def __abs__(self) -> i8vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i8vec4: ... + + def __add__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __radd__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __iadd__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + def __sub__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rsub__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __isub__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __mul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __rmul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __imul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + + def __mod__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rmod__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __imod__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + def __pow__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rpow__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __ipow__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + def __truediv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rtruediv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __itruediv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + def __floordiv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __matmul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __imatmul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + + def __divmod__(self, other: i8vec4) -> Tuple[i8vec4, i8vec4]: ... + + + +class imvec2: + x: int + y: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> imvec2: ... + def __pos__(self) -> imvec2: ... + def __abs__(self) -> imvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imvec2: ... + + def __add__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __radd__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __iadd__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + def __sub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rsub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __isub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rmod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __imod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + def __pow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rpow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __ipow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: imvec2) -> Tuple[imvec2, imvec2]: ... + + + +class imvec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xz(self) -> i32vec2: ... + @xz.setter + def xz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zx(self) -> i32vec2: ... + @zx.setter + def zx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yz(self) -> i32vec2: ... + @yz.setter + def yz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zy(self) -> i32vec2: ... + @zy.setter + def zy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xyz(self) -> i32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzy(self) -> i32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxz(self) -> i32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzx(self) -> i32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxy(self) -> i32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyx(self) -> i32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> imvec3: ... + def __pos__(self) -> imvec3: ... + def __abs__(self) -> imvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imvec3: ... + + def __add__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __radd__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __iadd__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + def __sub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rsub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __isub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rmod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __imod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + def __pow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rpow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __ipow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: imvec3) -> Tuple[imvec3, imvec3]: ... + + + +class imvec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xz(self) -> i32vec2: ... + @xz.setter + def xz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zx(self) -> i32vec2: ... + @zx.setter + def zx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xw(self) -> i32vec2: ... + @xw.setter + def xw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wx(self) -> i32vec2: ... + @wx.setter + def wx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yz(self) -> i32vec2: ... + @yz.setter + def yz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zy(self) -> i32vec2: ... + @zy.setter + def zy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yw(self) -> i32vec2: ... + @yw.setter + def yw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wy(self) -> i32vec2: ... + @wy.setter + def wy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zw(self) -> i32vec2: ... + @zw.setter + def zw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wz(self) -> i32vec2: ... + @wz.setter + def wz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xyz(self) -> i32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzy(self) -> i32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxz(self) -> i32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzx(self) -> i32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxy(self) -> i32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyx(self) -> i32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xyw(self) -> i32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xwy(self) -> i32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxw(self) -> i32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def ywx(self) -> i32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wxy(self) -> i32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wyx(self) -> i32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzw(self) -> i32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xwz(self) -> i32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxw(self) -> i32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zwx(self) -> i32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wxz(self) -> i32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wzx(self) -> i32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzw(self) -> i32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def ywz(self) -> i32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyw(self) -> i32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zwy(self) -> i32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wyz(self) -> i32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wzy(self) -> i32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xyzw(self) -> i32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xywz(self) -> i32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xzyw(self) -> i32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xzwy(self) -> i32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xwyz(self) -> i32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xwzy(self) -> i32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yxzw(self) -> i32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yxwz(self) -> i32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yzxw(self) -> i32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yzwx(self) -> i32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def ywxz(self) -> i32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def ywzx(self) -> i32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zxyw(self) -> i32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zxwy(self) -> i32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zyxw(self) -> i32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zywx(self) -> i32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zwxy(self) -> i32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zwyx(self) -> i32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wxyz(self) -> i32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wxzy(self) -> i32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wyxz(self) -> i32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wyzx(self) -> i32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wzxy(self) -> i32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wzyx(self) -> i32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> imvec4: ... + def __pos__(self) -> imvec4: ... + def __abs__(self) -> imvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imvec4: ... + + def __add__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __radd__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __iadd__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + def __sub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rsub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __isub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rmod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __imod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + def __pow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rpow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __ipow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: imvec4) -> Tuple[imvec4, imvec4]: ... + + +i32vec1 = ivec1 + +class ivec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.IAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> ivec1: ... + def __pos__(self) -> ivec1: ... + def __abs__(self) -> ivec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> ivec1: ... + + def __add__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __radd__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __iadd__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + def __sub__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rsub__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __isub__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __mul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __imul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rmod__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __imod__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + def __pow__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rpow__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __ipow__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: ivec1) -> Tuple[ivec1, ivec1]: ... + + +i32vec2 = ivec2 + +class ivec2: + x: int + y: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> ivec2: ... + def __pos__(self) -> ivec2: ... + def __abs__(self) -> ivec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> ivec2: ... + + def __add__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __radd__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __iadd__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + def __sub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rsub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __isub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rmod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __imod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + def __pow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rpow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __ipow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: ivec2) -> Tuple[ivec2, ivec2]: ... + + +i32vec3 = ivec3 + +class ivec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xz(self) -> i32vec2: ... + @xz.setter + def xz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zx(self) -> i32vec2: ... + @zx.setter + def zx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yz(self) -> i32vec2: ... + @yz.setter + def yz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zy(self) -> i32vec2: ... + @zy.setter + def zy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xyz(self) -> i32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzy(self) -> i32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxz(self) -> i32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzx(self) -> i32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxy(self) -> i32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyx(self) -> i32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> ivec3: ... + def __pos__(self) -> ivec3: ... + def __abs__(self) -> ivec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> ivec3: ... + + def __add__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __radd__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __iadd__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + def __sub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rsub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __isub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rmod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __imod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + def __pow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rpow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __ipow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: ivec3) -> Tuple[ivec3, ivec3]: ... + + +i32vec4 = ivec4 + +class ivec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xz(self) -> i32vec2: ... + @xz.setter + def xz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zx(self) -> i32vec2: ... + @zx.setter + def zx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xw(self) -> i32vec2: ... + @xw.setter + def xw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wx(self) -> i32vec2: ... + @wx.setter + def wx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yz(self) -> i32vec2: ... + @yz.setter + def yz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zy(self) -> i32vec2: ... + @zy.setter + def zy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yw(self) -> i32vec2: ... + @yw.setter + def yw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wy(self) -> i32vec2: ... + @wy.setter + def wy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zw(self) -> i32vec2: ... + @zw.setter + def zw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wz(self) -> i32vec2: ... + @wz.setter + def wz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xyz(self) -> i32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzy(self) -> i32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxz(self) -> i32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzx(self) -> i32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxy(self) -> i32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyx(self) -> i32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xyw(self) -> i32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xwy(self) -> i32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxw(self) -> i32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def ywx(self) -> i32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wxy(self) -> i32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wyx(self) -> i32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzw(self) -> i32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xwz(self) -> i32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxw(self) -> i32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zwx(self) -> i32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wxz(self) -> i32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wzx(self) -> i32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzw(self) -> i32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def ywz(self) -> i32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyw(self) -> i32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zwy(self) -> i32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wyz(self) -> i32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wzy(self) -> i32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xyzw(self) -> i32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xywz(self) -> i32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xzyw(self) -> i32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xzwy(self) -> i32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xwyz(self) -> i32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xwzy(self) -> i32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yxzw(self) -> i32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yxwz(self) -> i32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yzxw(self) -> i32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yzwx(self) -> i32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def ywxz(self) -> i32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def ywzx(self) -> i32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zxyw(self) -> i32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zxwy(self) -> i32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zyxw(self) -> i32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zywx(self) -> i32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zwxy(self) -> i32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zwyx(self) -> i32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wxyz(self) -> i32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wxzy(self) -> i32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wyxz(self) -> i32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wyzx(self) -> i32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wzxy(self) -> i32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wzyx(self) -> i32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> ivec4: ... + def __pos__(self) -> ivec4: ... + def __abs__(self) -> ivec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> ivec4: ... + + def __add__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __radd__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __iadd__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + def __sub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rsub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __isub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rmod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __imod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + def __pow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rpow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __ipow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: ivec4) -> Tuple[ivec4, ivec4]: ... + + + +class mvec2: + x: float + y: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.FAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> mvec2: ... + def __pos__(self) -> mvec2: ... + def __abs__(self) -> mvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mvec2: ... + + def __add__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __radd__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __iadd__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + def __sub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rsub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __isub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rmod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __imod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + def __pow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rpow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __ipow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: mvec2) -> Tuple[mvec2, mvec2]: ... + + + +class mvec3: + x: float + y: float + z: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xz(self) -> f32vec2: ... + @xz.setter + def xz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zx(self) -> f32vec2: ... + @zx.setter + def zx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yz(self) -> f32vec2: ... + @yz.setter + def yz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zy(self) -> f32vec2: ... + @zy.setter + def zy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xyz(self) -> f32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzy(self) -> f32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxz(self) -> f32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzx(self) -> f32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxy(self) -> f32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyx(self) -> f32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.F32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> mvec3: ... + def __pos__(self) -> mvec3: ... + def __abs__(self) -> mvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mvec3: ... + + def __add__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __radd__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __iadd__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + def __sub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rsub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __isub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rmod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __imod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + def __pow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rpow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __ipow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: mvec3) -> Tuple[mvec3, mvec3]: ... + + + +class mvec4: + x: float + y: float + z: float + w: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xz(self) -> f32vec2: ... + @xz.setter + def xz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zx(self) -> f32vec2: ... + @zx.setter + def zx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xw(self) -> f32vec2: ... + @xw.setter + def xw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wx(self) -> f32vec2: ... + @wx.setter + def wx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yz(self) -> f32vec2: ... + @yz.setter + def yz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zy(self) -> f32vec2: ... + @zy.setter + def zy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yw(self) -> f32vec2: ... + @yw.setter + def yw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wy(self) -> f32vec2: ... + @wy.setter + def wy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zw(self) -> f32vec2: ... + @zw.setter + def zw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wz(self) -> f32vec2: ... + @wz.setter + def wz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xyz(self) -> f32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzy(self) -> f32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxz(self) -> f32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzx(self) -> f32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxy(self) -> f32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyx(self) -> f32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xyw(self) -> f32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xwy(self) -> f32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxw(self) -> f32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def ywx(self) -> f32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wxy(self) -> f32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wyx(self) -> f32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzw(self) -> f32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xwz(self) -> f32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxw(self) -> f32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zwx(self) -> f32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wxz(self) -> f32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wzx(self) -> f32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzw(self) -> f32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def ywz(self) -> f32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyw(self) -> f32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zwy(self) -> f32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wyz(self) -> f32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wzy(self) -> f32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xyzw(self) -> f32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xywz(self) -> f32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xzyw(self) -> f32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xzwy(self) -> f32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xwyz(self) -> f32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xwzy(self) -> f32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yxzw(self) -> f32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yxwz(self) -> f32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yzxw(self) -> f32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yzwx(self) -> f32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def ywxz(self) -> f32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def ywzx(self) -> f32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zxyw(self) -> f32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zxwy(self) -> f32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zyxw(self) -> f32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zywx(self) -> f32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zwxy(self) -> f32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zwyx(self) -> f32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wxyz(self) -> f32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wxzy(self) -> f32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wyxz(self) -> f32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wyzx(self) -> f32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wzxy(self) -> f32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wzyx(self) -> f32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.F32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> mvec4: ... + def __pos__(self) -> mvec4: ... + def __abs__(self) -> mvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mvec4: ... + + def __add__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __radd__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __iadd__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + def __sub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rsub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __isub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rmod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __imod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + def __pow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rpow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __ipow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: mvec4) -> Tuple[mvec4, mvec4]: ... + + + +class u16vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.UAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u16vec1: ... + def __pos__(self) -> u16vec1: ... + def __abs__(self) -> u16vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u16vec1: ... + + def __add__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __radd__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __iadd__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + def __sub__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rsub__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __isub__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __mul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __rmul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __imul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + + def __mod__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rmod__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __imod__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + def __pow__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rpow__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __ipow__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + def __truediv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rtruediv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __itruediv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + def __floordiv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __matmul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __imatmul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + + def __divmod__(self, other: u16vec1) -> Tuple[u16vec1, u16vec1]: ... + + + +class u16vec2: + x: int + y: int + + + @property + def xy(self) -> u16vec2: ... + @xy.setter + def xy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yx(self) -> u16vec2: ... + @yx.setter + def yx(self, value: glm_typing.U16Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u16vec2: ... + def __pos__(self) -> u16vec2: ... + def __abs__(self) -> u16vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u16vec2: ... + + def __add__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __radd__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __iadd__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + def __sub__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rsub__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __isub__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __mul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __rmul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __imul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + + def __mod__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rmod__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __imod__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + def __pow__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rpow__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __ipow__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + def __truediv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rtruediv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __itruediv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + def __floordiv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __matmul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + + def __divmod__(self, other: u16vec2) -> Tuple[u16vec2, u16vec2]: ... + + + +class u16vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u16vec2: ... + @xy.setter + def xy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yx(self) -> u16vec2: ... + @yx.setter + def yx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xz(self) -> u16vec2: ... + @xz.setter + def xz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zx(self) -> u16vec2: ... + @zx.setter + def zx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yz(self) -> u16vec2: ... + @yz.setter + def yz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zy(self) -> u16vec2: ... + @zy.setter + def zy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xyz(self) -> u16vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xzy(self) -> u16vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yxz(self) -> u16vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yzx(self) -> u16vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zxy(self) -> u16vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zyx(self) -> u16vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U16Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u16vec3: ... + def __pos__(self) -> u16vec3: ... + def __abs__(self) -> u16vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u16vec3: ... + + def __add__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __radd__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __iadd__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + def __sub__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rsub__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __isub__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __mul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __rmul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __imul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + + def __mod__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rmod__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __imod__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + def __pow__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rpow__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __ipow__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + def __truediv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rtruediv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __itruediv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + def __floordiv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __matmul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + + def __divmod__(self, other: u16vec3) -> Tuple[u16vec3, u16vec3]: ... + + + +class u16vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u16vec2: ... + @xy.setter + def xy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yx(self) -> u16vec2: ... + @yx.setter + def yx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xz(self) -> u16vec2: ... + @xz.setter + def xz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zx(self) -> u16vec2: ... + @zx.setter + def zx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xw(self) -> u16vec2: ... + @xw.setter + def xw(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def wx(self) -> u16vec2: ... + @wx.setter + def wx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yz(self) -> u16vec2: ... + @yz.setter + def yz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zy(self) -> u16vec2: ... + @zy.setter + def zy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yw(self) -> u16vec2: ... + @yw.setter + def yw(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def wy(self) -> u16vec2: ... + @wy.setter + def wy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zw(self) -> u16vec2: ... + @zw.setter + def zw(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def wz(self) -> u16vec2: ... + @wz.setter + def wz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xyz(self) -> u16vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xzy(self) -> u16vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yxz(self) -> u16vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yzx(self) -> u16vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zxy(self) -> u16vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zyx(self) -> u16vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xyw(self) -> u16vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xwy(self) -> u16vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yxw(self) -> u16vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def ywx(self) -> u16vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wxy(self) -> u16vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wyx(self) -> u16vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xzw(self) -> u16vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xwz(self) -> u16vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zxw(self) -> u16vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zwx(self) -> u16vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wxz(self) -> u16vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wzx(self) -> u16vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yzw(self) -> u16vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def ywz(self) -> u16vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zyw(self) -> u16vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zwy(self) -> u16vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wyz(self) -> u16vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wzy(self) -> u16vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xyzw(self) -> u16vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xywz(self) -> u16vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xzyw(self) -> u16vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xzwy(self) -> u16vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xwyz(self) -> u16vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xwzy(self) -> u16vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def yxzw(self) -> u16vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def yxwz(self) -> u16vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def yzxw(self) -> u16vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def yzwx(self) -> u16vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def ywxz(self) -> u16vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def ywzx(self) -> u16vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zxyw(self) -> u16vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zxwy(self) -> u16vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zyxw(self) -> u16vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zywx(self) -> u16vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zwxy(self) -> u16vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zwyx(self) -> u16vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wxyz(self) -> u16vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wxzy(self) -> u16vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wyxz(self) -> u16vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wyzx(self) -> u16vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wzxy(self) -> u16vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wzyx(self) -> u16vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U16Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u16vec4: ... + def __pos__(self) -> u16vec4: ... + def __abs__(self) -> u16vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u16vec4: ... + + def __add__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __radd__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __iadd__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + def __sub__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rsub__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __isub__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __mul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __rmul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __imul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + + def __mod__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rmod__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __imod__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + def __pow__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rpow__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __ipow__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + def __truediv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rtruediv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __itruediv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + def __floordiv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __matmul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __imatmul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + + def __divmod__(self, other: u16vec4) -> Tuple[u16vec4, u16vec4]: ... + + + +class u64vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.UAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u64vec1: ... + def __pos__(self) -> u64vec1: ... + def __abs__(self) -> u64vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u64vec1: ... + + def __add__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __radd__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __iadd__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + def __sub__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rsub__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __isub__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __mul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __rmul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __imul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + + def __mod__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rmod__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __imod__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + def __pow__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rpow__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __ipow__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + def __truediv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rtruediv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __itruediv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + def __floordiv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __matmul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __imatmul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + + def __divmod__(self, other: u64vec1) -> Tuple[u64vec1, u64vec1]: ... + + + +class u64vec2: + x: int + y: int + + + @property + def xy(self) -> u64vec2: ... + @xy.setter + def xy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yx(self) -> u64vec2: ... + @yx.setter + def yx(self, value: glm_typing.U64Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u64vec2: ... + def __pos__(self) -> u64vec2: ... + def __abs__(self) -> u64vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u64vec2: ... + + def __add__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __radd__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __iadd__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + def __sub__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rsub__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __isub__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __mul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __rmul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __imul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + + def __mod__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rmod__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __imod__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + def __pow__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rpow__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __ipow__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + def __truediv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rtruediv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __itruediv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + def __floordiv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __matmul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + + def __divmod__(self, other: u64vec2) -> Tuple[u64vec2, u64vec2]: ... + + + +class u64vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u64vec2: ... + @xy.setter + def xy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yx(self) -> u64vec2: ... + @yx.setter + def yx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xz(self) -> u64vec2: ... + @xz.setter + def xz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zx(self) -> u64vec2: ... + @zx.setter + def zx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yz(self) -> u64vec2: ... + @yz.setter + def yz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zy(self) -> u64vec2: ... + @zy.setter + def zy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xyz(self) -> u64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xzy(self) -> u64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yxz(self) -> u64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yzx(self) -> u64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zxy(self) -> u64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zyx(self) -> u64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U64Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u64vec3: ... + def __pos__(self) -> u64vec3: ... + def __abs__(self) -> u64vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u64vec3: ... + + def __add__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __radd__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __iadd__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + def __sub__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rsub__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __isub__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __mul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __rmul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __imul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + + def __mod__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rmod__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __imod__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + def __pow__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rpow__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __ipow__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + def __truediv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rtruediv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __itruediv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + def __floordiv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __matmul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + + def __divmod__(self, other: u64vec3) -> Tuple[u64vec3, u64vec3]: ... + + + +class u64vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u64vec2: ... + @xy.setter + def xy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yx(self) -> u64vec2: ... + @yx.setter + def yx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xz(self) -> u64vec2: ... + @xz.setter + def xz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zx(self) -> u64vec2: ... + @zx.setter + def zx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xw(self) -> u64vec2: ... + @xw.setter + def xw(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def wx(self) -> u64vec2: ... + @wx.setter + def wx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yz(self) -> u64vec2: ... + @yz.setter + def yz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zy(self) -> u64vec2: ... + @zy.setter + def zy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yw(self) -> u64vec2: ... + @yw.setter + def yw(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def wy(self) -> u64vec2: ... + @wy.setter + def wy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zw(self) -> u64vec2: ... + @zw.setter + def zw(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def wz(self) -> u64vec2: ... + @wz.setter + def wz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xyz(self) -> u64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xzy(self) -> u64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yxz(self) -> u64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yzx(self) -> u64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zxy(self) -> u64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zyx(self) -> u64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xyw(self) -> u64vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xwy(self) -> u64vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yxw(self) -> u64vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def ywx(self) -> u64vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wxy(self) -> u64vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wyx(self) -> u64vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xzw(self) -> u64vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xwz(self) -> u64vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zxw(self) -> u64vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zwx(self) -> u64vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wxz(self) -> u64vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wzx(self) -> u64vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yzw(self) -> u64vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def ywz(self) -> u64vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zyw(self) -> u64vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zwy(self) -> u64vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wyz(self) -> u64vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wzy(self) -> u64vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xyzw(self) -> u64vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xywz(self) -> u64vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xzyw(self) -> u64vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xzwy(self) -> u64vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xwyz(self) -> u64vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xwzy(self) -> u64vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def yxzw(self) -> u64vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def yxwz(self) -> u64vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def yzxw(self) -> u64vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def yzwx(self) -> u64vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def ywxz(self) -> u64vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def ywzx(self) -> u64vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zxyw(self) -> u64vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zxwy(self) -> u64vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zyxw(self) -> u64vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zywx(self) -> u64vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zwxy(self) -> u64vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zwyx(self) -> u64vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wxyz(self) -> u64vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wxzy(self) -> u64vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wyxz(self) -> u64vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wyzx(self) -> u64vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wzxy(self) -> u64vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wzyx(self) -> u64vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U64Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u64vec4: ... + def __pos__(self) -> u64vec4: ... + def __abs__(self) -> u64vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u64vec4: ... + + def __add__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __radd__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __iadd__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + def __sub__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rsub__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __isub__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __mul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __rmul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __imul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + + def __mod__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rmod__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __imod__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + def __pow__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rpow__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __ipow__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + def __truediv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rtruediv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __itruediv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + def __floordiv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __matmul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __imatmul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + + def __divmod__(self, other: u64vec4) -> Tuple[u64vec4, u64vec4]: ... + + + +class u8vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.UAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u8vec1: ... + def __pos__(self) -> u8vec1: ... + def __abs__(self) -> u8vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u8vec1: ... + + def __add__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __radd__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __iadd__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + def __sub__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rsub__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __isub__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __mul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __rmul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __imul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + + def __mod__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rmod__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __imod__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + def __pow__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rpow__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __ipow__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + def __truediv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rtruediv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __itruediv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + def __floordiv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __matmul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __imatmul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + + def __divmod__(self, other: u8vec1) -> Tuple[u8vec1, u8vec1]: ... + + + +class u8vec2: + x: int + y: int + + + @property + def xy(self) -> u8vec2: ... + @xy.setter + def xy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yx(self) -> u8vec2: ... + @yx.setter + def yx(self, value: glm_typing.U8Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u8vec2: ... + def __pos__(self) -> u8vec2: ... + def __abs__(self) -> u8vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u8vec2: ... + + def __add__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __radd__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __iadd__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + def __sub__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rsub__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __isub__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __mul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __rmul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __imul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + + def __mod__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rmod__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __imod__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + def __pow__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rpow__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __ipow__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + def __truediv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rtruediv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __itruediv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + def __floordiv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __matmul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + + def __divmod__(self, other: u8vec2) -> Tuple[u8vec2, u8vec2]: ... + + + +class u8vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u8vec2: ... + @xy.setter + def xy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yx(self) -> u8vec2: ... + @yx.setter + def yx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xz(self) -> u8vec2: ... + @xz.setter + def xz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zx(self) -> u8vec2: ... + @zx.setter + def zx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yz(self) -> u8vec2: ... + @yz.setter + def yz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zy(self) -> u8vec2: ... + @zy.setter + def zy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xyz(self) -> u8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xzy(self) -> u8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yxz(self) -> u8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yzx(self) -> u8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zxy(self) -> u8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zyx(self) -> u8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U8Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u8vec3: ... + def __pos__(self) -> u8vec3: ... + def __abs__(self) -> u8vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u8vec3: ... + + def __add__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __radd__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __iadd__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + def __sub__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rsub__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __isub__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __mul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __rmul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __imul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + + def __mod__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rmod__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __imod__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + def __pow__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rpow__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __ipow__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + def __truediv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rtruediv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __itruediv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + def __floordiv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __matmul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + + def __divmod__(self, other: u8vec3) -> Tuple[u8vec3, u8vec3]: ... + + + +class u8vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u8vec2: ... + @xy.setter + def xy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yx(self) -> u8vec2: ... + @yx.setter + def yx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xz(self) -> u8vec2: ... + @xz.setter + def xz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zx(self) -> u8vec2: ... + @zx.setter + def zx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xw(self) -> u8vec2: ... + @xw.setter + def xw(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def wx(self) -> u8vec2: ... + @wx.setter + def wx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yz(self) -> u8vec2: ... + @yz.setter + def yz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zy(self) -> u8vec2: ... + @zy.setter + def zy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yw(self) -> u8vec2: ... + @yw.setter + def yw(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def wy(self) -> u8vec2: ... + @wy.setter + def wy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zw(self) -> u8vec2: ... + @zw.setter + def zw(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def wz(self) -> u8vec2: ... + @wz.setter + def wz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xyz(self) -> u8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xzy(self) -> u8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yxz(self) -> u8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yzx(self) -> u8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zxy(self) -> u8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zyx(self) -> u8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xyw(self) -> u8vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xwy(self) -> u8vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yxw(self) -> u8vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def ywx(self) -> u8vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wxy(self) -> u8vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wyx(self) -> u8vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xzw(self) -> u8vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xwz(self) -> u8vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zxw(self) -> u8vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zwx(self) -> u8vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wxz(self) -> u8vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wzx(self) -> u8vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yzw(self) -> u8vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def ywz(self) -> u8vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zyw(self) -> u8vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zwy(self) -> u8vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wyz(self) -> u8vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wzy(self) -> u8vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xyzw(self) -> u8vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xywz(self) -> u8vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xzyw(self) -> u8vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xzwy(self) -> u8vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xwyz(self) -> u8vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xwzy(self) -> u8vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def yxzw(self) -> u8vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def yxwz(self) -> u8vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def yzxw(self) -> u8vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def yzwx(self) -> u8vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def ywxz(self) -> u8vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def ywzx(self) -> u8vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zxyw(self) -> u8vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zxwy(self) -> u8vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zyxw(self) -> u8vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zywx(self) -> u8vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zwxy(self) -> u8vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zwyx(self) -> u8vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wxyz(self) -> u8vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wxzy(self) -> u8vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wyxz(self) -> u8vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wyzx(self) -> u8vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wzxy(self) -> u8vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wzyx(self) -> u8vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U8Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u8vec4: ... + def __pos__(self) -> u8vec4: ... + def __abs__(self) -> u8vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u8vec4: ... + + def __add__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __radd__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __iadd__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + def __sub__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rsub__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __isub__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __mul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __rmul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __imul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + + def __mod__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rmod__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __imod__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + def __pow__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rpow__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __ipow__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + def __truediv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rtruediv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __itruediv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + def __floordiv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __matmul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __imatmul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + + def __divmod__(self, other: u8vec4) -> Tuple[u8vec4, u8vec4]: ... + + + +class umvec2: + x: int + y: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> umvec2: ... + def __pos__(self) -> umvec2: ... + def __abs__(self) -> umvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umvec2: ... + + def __add__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __radd__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __iadd__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + def __sub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rsub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __isub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rmod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __imod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + def __pow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rpow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __ipow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: umvec2) -> Tuple[umvec2, umvec2]: ... + + + +class umvec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xz(self) -> u32vec2: ... + @xz.setter + def xz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zx(self) -> u32vec2: ... + @zx.setter + def zx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yz(self) -> u32vec2: ... + @yz.setter + def yz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zy(self) -> u32vec2: ... + @zy.setter + def zy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xyz(self) -> u32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzy(self) -> u32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxz(self) -> u32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzx(self) -> u32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxy(self) -> u32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyx(self) -> u32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> umvec3: ... + def __pos__(self) -> umvec3: ... + def __abs__(self) -> umvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umvec3: ... + + def __add__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __radd__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __iadd__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + def __sub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rsub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __isub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rmod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __imod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + def __pow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rpow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __ipow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: umvec3) -> Tuple[umvec3, umvec3]: ... + + + +class umvec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xz(self) -> u32vec2: ... + @xz.setter + def xz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zx(self) -> u32vec2: ... + @zx.setter + def zx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xw(self) -> u32vec2: ... + @xw.setter + def xw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wx(self) -> u32vec2: ... + @wx.setter + def wx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yz(self) -> u32vec2: ... + @yz.setter + def yz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zy(self) -> u32vec2: ... + @zy.setter + def zy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yw(self) -> u32vec2: ... + @yw.setter + def yw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wy(self) -> u32vec2: ... + @wy.setter + def wy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zw(self) -> u32vec2: ... + @zw.setter + def zw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wz(self) -> u32vec2: ... + @wz.setter + def wz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xyz(self) -> u32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzy(self) -> u32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxz(self) -> u32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzx(self) -> u32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxy(self) -> u32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyx(self) -> u32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xyw(self) -> u32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xwy(self) -> u32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxw(self) -> u32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def ywx(self) -> u32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wxy(self) -> u32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wyx(self) -> u32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzw(self) -> u32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xwz(self) -> u32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxw(self) -> u32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zwx(self) -> u32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wxz(self) -> u32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wzx(self) -> u32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzw(self) -> u32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def ywz(self) -> u32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyw(self) -> u32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zwy(self) -> u32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wyz(self) -> u32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wzy(self) -> u32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xyzw(self) -> u32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xywz(self) -> u32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xzyw(self) -> u32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xzwy(self) -> u32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xwyz(self) -> u32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xwzy(self) -> u32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yxzw(self) -> u32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yxwz(self) -> u32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yzxw(self) -> u32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yzwx(self) -> u32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def ywxz(self) -> u32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def ywzx(self) -> u32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zxyw(self) -> u32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zxwy(self) -> u32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zyxw(self) -> u32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zywx(self) -> u32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zwxy(self) -> u32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zwyx(self) -> u32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wxyz(self) -> u32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wxzy(self) -> u32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wyxz(self) -> u32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wyzx(self) -> u32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wzxy(self) -> u32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wzyx(self) -> u32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> umvec4: ... + def __pos__(self) -> umvec4: ... + def __abs__(self) -> umvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umvec4: ... + + def __add__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __radd__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __iadd__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + def __sub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rsub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __isub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rmod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __imod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + def __pow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rpow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __ipow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: umvec4) -> Tuple[umvec4, umvec4]: ... + + +u32vec1 = uvec1 + +class uvec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.UAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> uvec1: ... + def __pos__(self) -> uvec1: ... + def __abs__(self) -> uvec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> uvec1: ... + + def __add__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __radd__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __iadd__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + def __sub__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rsub__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __isub__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __mul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __imul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rmod__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __imod__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + def __pow__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rpow__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __ipow__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: uvec1) -> Tuple[uvec1, uvec1]: ... + + +u32vec2 = uvec2 + +class uvec2: + x: int + y: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> uvec2: ... + def __pos__(self) -> uvec2: ... + def __abs__(self) -> uvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> uvec2: ... + + def __add__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __radd__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __iadd__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + def __sub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rsub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __isub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rmod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __imod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + def __pow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rpow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __ipow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: uvec2) -> Tuple[uvec2, uvec2]: ... + + +u32vec3 = uvec3 + +class uvec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xz(self) -> u32vec2: ... + @xz.setter + def xz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zx(self) -> u32vec2: ... + @zx.setter + def zx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yz(self) -> u32vec2: ... + @yz.setter + def yz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zy(self) -> u32vec2: ... + @zy.setter + def zy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xyz(self) -> u32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzy(self) -> u32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxz(self) -> u32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzx(self) -> u32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxy(self) -> u32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyx(self) -> u32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> uvec3: ... + def __pos__(self) -> uvec3: ... + def __abs__(self) -> uvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> uvec3: ... + + def __add__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __radd__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __iadd__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + def __sub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rsub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __isub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rmod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __imod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + def __pow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rpow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __ipow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: uvec3) -> Tuple[uvec3, uvec3]: ... + + +u32vec4 = uvec4 + +class uvec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xz(self) -> u32vec2: ... + @xz.setter + def xz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zx(self) -> u32vec2: ... + @zx.setter + def zx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xw(self) -> u32vec2: ... + @xw.setter + def xw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wx(self) -> u32vec2: ... + @wx.setter + def wx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yz(self) -> u32vec2: ... + @yz.setter + def yz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zy(self) -> u32vec2: ... + @zy.setter + def zy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yw(self) -> u32vec2: ... + @yw.setter + def yw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wy(self) -> u32vec2: ... + @wy.setter + def wy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zw(self) -> u32vec2: ... + @zw.setter + def zw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wz(self) -> u32vec2: ... + @wz.setter + def wz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xyz(self) -> u32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzy(self) -> u32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxz(self) -> u32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzx(self) -> u32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxy(self) -> u32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyx(self) -> u32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xyw(self) -> u32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xwy(self) -> u32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxw(self) -> u32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def ywx(self) -> u32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wxy(self) -> u32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wyx(self) -> u32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzw(self) -> u32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xwz(self) -> u32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxw(self) -> u32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zwx(self) -> u32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wxz(self) -> u32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wzx(self) -> u32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzw(self) -> u32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def ywz(self) -> u32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyw(self) -> u32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zwy(self) -> u32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wyz(self) -> u32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wzy(self) -> u32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xyzw(self) -> u32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xywz(self) -> u32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xzyw(self) -> u32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xzwy(self) -> u32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xwyz(self) -> u32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xwzy(self) -> u32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yxzw(self) -> u32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yxwz(self) -> u32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yzxw(self) -> u32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yzwx(self) -> u32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def ywxz(self) -> u32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def ywzx(self) -> u32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zxyw(self) -> u32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zxwy(self) -> u32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zyxw(self) -> u32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zywx(self) -> u32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zwxy(self) -> u32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zwyx(self) -> u32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wxyz(self) -> u32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wxzy(self) -> u32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wyxz(self) -> u32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wyzx(self) -> u32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wzxy(self) -> u32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wzyx(self) -> u32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> uvec4: ... + def __pos__(self) -> uvec4: ... + def __abs__(self) -> uvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> uvec4: ... + + def __add__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __radd__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __iadd__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + def __sub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rsub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __isub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rmod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __imod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + def __pow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rpow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __ipow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: uvec4) -> Tuple[uvec4, uvec4]: ... + + +f32vec1 = vec1 +fvec1 = vec1 + +class vec1: + x: float + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.FAnyVector2, glm_typing.FAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> vec1: ... + def __pos__(self) -> vec1: ... + def __abs__(self) -> vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> vec1: ... + + def __add__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __radd__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __iadd__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + def __sub__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rsub__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __isub__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __mul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __imul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rmod__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __imod__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + def __pow__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rpow__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __ipow__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: vec1) -> Tuple[vec1, vec1]: ... + + +f32vec2 = vec2 +fvec2 = vec2 + +class vec2: + x: float + y: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.FAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> vec2: ... + def __pos__(self) -> vec2: ... + def __abs__(self) -> vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> vec2: ... + + def __add__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __radd__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __iadd__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + def __sub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rsub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __isub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rmod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __imod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + def __pow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rpow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __ipow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: vec2) -> Tuple[vec2, vec2]: ... + + +f32vec3 = vec3 +fvec3 = vec3 + +class vec3: + x: float + y: float + z: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xz(self) -> f32vec2: ... + @xz.setter + def xz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zx(self) -> f32vec2: ... + @zx.setter + def zx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yz(self) -> f32vec2: ... + @yz.setter + def yz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zy(self) -> f32vec2: ... + @zy.setter + def zy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xyz(self) -> f32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzy(self) -> f32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxz(self) -> f32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzx(self) -> f32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxy(self) -> f32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyx(self) -> f32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.F32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> vec3: ... + def __pos__(self) -> vec3: ... + def __abs__(self) -> vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> vec3: ... + + def __add__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __radd__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __iadd__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + def __sub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rsub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __isub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rmod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __imod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + def __pow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rpow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __ipow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: vec3) -> Tuple[vec3, vec3]: ... + + +f32vec4 = vec4 +fvec4 = vec4 + +class vec4: + x: float + y: float + z: float + w: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xz(self) -> f32vec2: ... + @xz.setter + def xz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zx(self) -> f32vec2: ... + @zx.setter + def zx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xw(self) -> f32vec2: ... + @xw.setter + def xw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wx(self) -> f32vec2: ... + @wx.setter + def wx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yz(self) -> f32vec2: ... + @yz.setter + def yz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zy(self) -> f32vec2: ... + @zy.setter + def zy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yw(self) -> f32vec2: ... + @yw.setter + def yw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wy(self) -> f32vec2: ... + @wy.setter + def wy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zw(self) -> f32vec2: ... + @zw.setter + def zw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wz(self) -> f32vec2: ... + @wz.setter + def wz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xyz(self) -> f32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzy(self) -> f32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxz(self) -> f32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzx(self) -> f32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxy(self) -> f32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyx(self) -> f32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xyw(self) -> f32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xwy(self) -> f32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxw(self) -> f32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def ywx(self) -> f32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wxy(self) -> f32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wyx(self) -> f32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzw(self) -> f32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xwz(self) -> f32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxw(self) -> f32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zwx(self) -> f32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wxz(self) -> f32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wzx(self) -> f32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzw(self) -> f32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def ywz(self) -> f32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyw(self) -> f32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zwy(self) -> f32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wyz(self) -> f32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wzy(self) -> f32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xyzw(self) -> f32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xywz(self) -> f32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xzyw(self) -> f32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xzwy(self) -> f32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xwyz(self) -> f32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xwzy(self) -> f32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yxzw(self) -> f32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yxwz(self) -> f32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yzxw(self) -> f32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yzwx(self) -> f32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def ywxz(self) -> f32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def ywzx(self) -> f32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zxyw(self) -> f32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zxwy(self) -> f32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zyxw(self) -> f32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zywx(self) -> f32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zwxy(self) -> f32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zwyx(self) -> f32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wxyz(self) -> f32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wxzy(self) -> f32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wyxz(self) -> f32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wyzx(self) -> f32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wzxy(self) -> f32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wzyx(self) -> f32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.F32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> vec4: ... + def __pos__(self) -> vec4: ... + def __abs__(self) -> vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> vec4: ... + + def __add__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __radd__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __iadd__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + def __sub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rsub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __isub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rmod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __imod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + def __pow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rpow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __ipow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: vec4) -> Tuple[vec4, vec4]: ... + + +dmat2 = dmat2x2 +f64mat2 = dmat2x2 +f64mat2x2 = dmat2x2 + +class dmat2x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x2, glm_typing.DAnyMatrix2x2, glm_typing.DAnyMatrix2x3, glm_typing.DAnyMatrix2x4, glm_typing.DAnyMatrix3x2, glm_typing.DAnyMatrix3x3, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x2, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec2, dmvec2]) -> None: ... + + def __neg__(self) -> dmat2x2: ... + def __pos__(self) -> dmat2x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat2x2: ... + + def __add__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + def __radd__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + def __iadd__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + + def __sub__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + def __rsub__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + def __isub__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + + @overload + def __truediv__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __truediv__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rtruediv__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rtruediv__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __itruediv__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __itruediv__(self, other: glm_typing.D64Vector2) -> dvec2: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + + +f64mat2x3 = dmat2x3 + +class dmat2x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x3, glm_typing.DAnyMatrix2x3, glm_typing.DAnyMatrix2x4, glm_typing.DAnyMatrix3x3, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec3, dmvec3]) -> None: ... + + def __neg__(self) -> dmat2x3: ... + def __pos__(self) -> dmat2x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat2x3: ... + + def __add__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + def __radd__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + def __iadd__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + + def __sub__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + def __rsub__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + def __isub__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + + +f64mat2x4 = dmat2x4 + +class dmat2x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x4, glm_typing.DAnyMatrix2x4, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec4, dmvec4]) -> None: ... + + def __neg__(self) -> dmat2x4: ... + def __pos__(self) -> dmat2x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat2x4: ... + + def __add__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + def __radd__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + def __iadd__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + + def __sub__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + def __rsub__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + def __isub__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + + +f64mat3x2 = dmat3x2 + +class dmat3x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x2, glm_typing.DAnyMatrix3x2, glm_typing.DAnyMatrix3x3, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x2, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec2, dmvec2]) -> None: ... + + def __neg__(self) -> dmat3x2: ... + def __pos__(self) -> dmat3x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat3x2: ... + + def __add__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + def __radd__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + def __iadd__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + + def __sub__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + def __rsub__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + def __isub__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + + +dmat3 = dmat3x3 +f64mat3 = dmat3x3 +f64mat3x3 = dmat3x3 + +class dmat3x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x3, glm_typing.DAnyMatrix3x3, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec3, dmvec3]) -> None: ... + + def __neg__(self) -> dmat3x3: ... + def __pos__(self) -> dmat3x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat3x3: ... + + def __add__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + def __radd__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + def __iadd__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + + def __sub__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + def __rsub__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + def __isub__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + + @overload + def __truediv__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __truediv__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rtruediv__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rtruediv__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __itruediv__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __itruediv__(self, other: glm_typing.D64Vector3) -> dvec3: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + + +f64mat3x4 = dmat3x4 + +class dmat3x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x4, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec4, dmvec4]) -> None: ... + + def __neg__(self) -> dmat3x4: ... + def __pos__(self) -> dmat3x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat3x4: ... + + def __add__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + def __radd__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + def __iadd__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + + def __sub__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + def __rsub__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + def __isub__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + + +f64mat4x2 = dmat4x2 + +class dmat4x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x2, glm_typing.DAnyMatrix4x2, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec2, dmvec2]) -> None: ... + + def __neg__(self) -> dmat4x2: ... + def __pos__(self) -> dmat4x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat4x2: ... + + def __add__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + def __radd__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + def __iadd__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + + def __sub__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + def __rsub__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + def __isub__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + + +f64mat4x3 = dmat4x3 + +class dmat4x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x3, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec3, dmvec3]) -> None: ... + + def __neg__(self) -> dmat4x3: ... + def __pos__(self) -> dmat4x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat4x3: ... + + def __add__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + def __radd__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + def __iadd__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + + def __sub__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + def __rsub__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + def __isub__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + + +dmat4 = dmat4x4 +f64mat4 = dmat4x4 +f64mat4x4 = dmat4x4 + +class dmat4x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, _12: glm_typing.Number, _13: glm_typing.Number, _14: glm_typing.Number, _15: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x4, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec4, dmvec4]) -> None: ... + + def __neg__(self) -> dmat4x4: ... + def __pos__(self) -> dmat4x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat4x4: ... + + def __add__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + def __radd__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + def __iadd__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + + def __sub__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + def __rsub__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + def __isub__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + + @overload + def __truediv__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __truediv__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rtruediv__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rtruediv__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __itruediv__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __itruediv__(self, other: glm_typing.D64Vector4) -> dvec4: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + + +i32mat2 = imat2x2 +i32mat2x2 = imat2x2 +imat2 = imat2x2 + +class imat2x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x2, glm_typing.IAnyMatrix2x2, glm_typing.IAnyMatrix2x3, glm_typing.IAnyMatrix2x4, glm_typing.IAnyMatrix3x2, glm_typing.IAnyMatrix3x3, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x2, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec2, imvec2]) -> None: ... + + def __neg__(self) -> imat2x2: ... + def __pos__(self) -> imat2x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat2x2: ... + + def __add__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + def __radd__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + def __iadd__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + + def __sub__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + def __rsub__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + def __isub__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __mul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + + @overload + def __truediv__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __truediv__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rtruediv__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rtruediv__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __itruediv__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __itruediv__(self, other: glm_typing.I32Vector2) -> ivec2: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + + +i32mat2x3 = imat2x3 + +class imat2x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x3, glm_typing.IAnyMatrix2x3, glm_typing.IAnyMatrix2x4, glm_typing.IAnyMatrix3x3, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec3, imvec3]) -> None: ... + + def __neg__(self) -> imat2x3: ... + def __pos__(self) -> imat2x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat2x3: ... + + def __add__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + def __radd__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + def __iadd__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + + def __sub__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + def __rsub__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + def __isub__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + + +i32mat2x4 = imat2x4 + +class imat2x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x4, glm_typing.IAnyMatrix2x4, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec4, imvec4]) -> None: ... + + def __neg__(self) -> imat2x4: ... + def __pos__(self) -> imat2x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat2x4: ... + + def __add__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + def __radd__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + def __iadd__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + + def __sub__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + def __rsub__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + def __isub__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + + +i32mat3x2 = imat3x2 + +class imat3x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x2, glm_typing.IAnyMatrix3x2, glm_typing.IAnyMatrix3x3, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x2, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec2, imvec2]) -> None: ... + + def __neg__(self) -> imat3x2: ... + def __pos__(self) -> imat3x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat3x2: ... + + def __add__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + def __radd__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + def __iadd__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + + def __sub__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + def __rsub__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + def __isub__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + + +i32mat3 = imat3x3 +i32mat3x3 = imat3x3 +imat3 = imat3x3 + +class imat3x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x3, glm_typing.IAnyMatrix3x3, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec3, imvec3]) -> None: ... + + def __neg__(self) -> imat3x3: ... + def __pos__(self) -> imat3x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat3x3: ... + + def __add__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + def __radd__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + def __iadd__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + + def __sub__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + def __rsub__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + def __isub__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + + @overload + def __truediv__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __truediv__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rtruediv__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rtruediv__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __itruediv__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __itruediv__(self, other: glm_typing.I32Vector3) -> ivec3: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + + +i32mat3x4 = imat3x4 + +class imat3x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x4, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec4, imvec4]) -> None: ... + + def __neg__(self) -> imat3x4: ... + def __pos__(self) -> imat3x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat3x4: ... + + def __add__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + def __radd__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + def __iadd__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + + def __sub__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + def __rsub__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + def __isub__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + + +i32mat4x2 = imat4x2 + +class imat4x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x2, glm_typing.IAnyMatrix4x2, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec2, imvec2]) -> None: ... + + def __neg__(self) -> imat4x2: ... + def __pos__(self) -> imat4x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat4x2: ... + + def __add__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + def __radd__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + def __iadd__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + + def __sub__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + def __rsub__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + def __isub__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + + +i32mat4x3 = imat4x3 + +class imat4x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x3, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec3, imvec3]) -> None: ... + + def __neg__(self) -> imat4x3: ... + def __pos__(self) -> imat4x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat4x3: ... + + def __add__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + def __radd__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + def __iadd__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + + def __sub__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + def __rsub__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + def __isub__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + + +i32mat4 = imat4x4 +i32mat4x4 = imat4x4 +imat4 = imat4x4 + +class imat4x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, _12: glm_typing.Number, _13: glm_typing.Number, _14: glm_typing.Number, _15: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x4, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec4, imvec4]) -> None: ... + + def __neg__(self) -> imat4x4: ... + def __pos__(self) -> imat4x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat4x4: ... + + def __add__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + def __radd__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + def __iadd__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + + def __sub__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + def __rsub__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + def __isub__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + + @overload + def __truediv__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __truediv__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rtruediv__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rtruediv__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __itruediv__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __itruediv__(self, other: glm_typing.I32Vector4) -> ivec4: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + + +f32mat2 = mat2x2 +f32mat2x2 = mat2x2 +fmat2 = mat2x2 +fmat2x2 = mat2x2 +mat2 = mat2x2 + +class mat2x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x2, glm_typing.FAnyMatrix2x2, glm_typing.FAnyMatrix2x3, glm_typing.FAnyMatrix2x4, glm_typing.FAnyMatrix3x2, glm_typing.FAnyMatrix3x3, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x2, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec2, mvec2]) -> None: ... + + def __neg__(self) -> mat2x2: ... + def __pos__(self) -> mat2x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat2x2: ... + + def __add__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + def __radd__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + def __iadd__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + + def __sub__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + def __rsub__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + def __isub__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Vector1) -> vec1: ... + + @overload + def __truediv__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __truediv__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rtruediv__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rtruediv__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __itruediv__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __itruediv__(self, other: glm_typing.F32Vector2) -> vec2: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + + +f32mat2x3 = mat2x3 +fmat2x3 = mat2x3 + +class mat2x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x3, glm_typing.FAnyMatrix2x3, glm_typing.FAnyMatrix2x4, glm_typing.FAnyMatrix3x3, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec3, mvec3]) -> None: ... + + def __neg__(self) -> mat2x3: ... + def __pos__(self) -> mat2x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat2x3: ... + + def __add__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + def __radd__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + def __iadd__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + + def __sub__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + def __rsub__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + def __isub__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec3: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec3: ... + + +f32mat2x4 = mat2x4 +fmat2x4 = mat2x4 + +class mat2x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x4, glm_typing.FAnyMatrix2x4, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec4, mvec4]) -> None: ... + + def __neg__(self) -> mat2x4: ... + def __pos__(self) -> mat2x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat2x4: ... + + def __add__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + def __radd__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + def __iadd__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + + def __sub__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + def __rsub__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + def __isub__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec4: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec4: ... + + +f32mat3x2 = mat3x2 +fmat3x2 = mat3x2 + +class mat3x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x2, glm_typing.FAnyMatrix3x2, glm_typing.FAnyMatrix3x3, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x2, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec2, mvec2]) -> None: ... + + def __neg__(self) -> mat3x2: ... + def __pos__(self) -> mat3x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat3x2: ... + + def __add__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + def __radd__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + def __iadd__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + + def __sub__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + def __rsub__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + def __isub__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec2: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec2: ... + + +f32mat3 = mat3x3 +f32mat3x3 = mat3x3 +fmat3 = mat3x3 +fmat3x3 = mat3x3 +mat3 = mat3x3 + +class mat3x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x3, glm_typing.FAnyMatrix3x3, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec3, mvec3]) -> None: ... + + def __neg__(self) -> mat3x3: ... + def __pos__(self) -> mat3x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat3x3: ... + + def __add__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + def __radd__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + def __iadd__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + + def __sub__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + def __rsub__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + def __isub__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec2: ... + + @overload + def __truediv__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __truediv__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rtruediv__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rtruediv__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __itruediv__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __itruediv__(self, other: glm_typing.F32Vector3) -> vec3: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + + +f32mat3x4 = mat3x4 +fmat3x4 = mat3x4 + +class mat3x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x4, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec4, mvec4]) -> None: ... + + def __neg__(self) -> mat3x4: ... + def __pos__(self) -> mat3x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat3x4: ... + + def __add__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + def __radd__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + def __iadd__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + + def __sub__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + def __rsub__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + def __isub__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec4: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec4: ... + + +f32mat4x2 = mat4x2 +fmat4x2 = mat4x2 + +class mat4x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x2, glm_typing.FAnyMatrix4x2, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec2, mvec2]) -> None: ... + + def __neg__(self) -> mat4x2: ... + def __pos__(self) -> mat4x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat4x2: ... + + def __add__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + def __radd__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + def __iadd__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + + def __sub__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + def __rsub__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + def __isub__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec2: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec2: ... + + +f32mat4x3 = mat4x3 +fmat4x3 = mat4x3 + +class mat4x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x3, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec3, mvec3]) -> None: ... + + def __neg__(self) -> mat4x3: ... + def __pos__(self) -> mat4x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat4x3: ... + + def __add__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + def __radd__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + def __iadd__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + + def __sub__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + def __rsub__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + def __isub__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec3: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec3: ... + + +f32mat4 = mat4x4 +f32mat4x4 = mat4x4 +fmat4 = mat4x4 +fmat4x4 = mat4x4 +mat4 = mat4x4 + +class mat4x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, _12: glm_typing.Number, _13: glm_typing.Number, _14: glm_typing.Number, _15: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x4, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec4, mvec4]) -> None: ... + + def __neg__(self) -> mat4x4: ... + def __pos__(self) -> mat4x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat4x4: ... + + def __add__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + def __radd__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + def __iadd__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + + def __sub__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + def __rsub__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + def __isub__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec3: ... + + @overload + def __truediv__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __truediv__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rtruediv__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rtruediv__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __itruediv__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __itruediv__(self, other: glm_typing.F32Vector4) -> vec4: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + + +u32mat2 = umat2x2 +u32mat2x2 = umat2x2 +umat2 = umat2x2 + +class umat2x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x2, glm_typing.UAnyMatrix2x2, glm_typing.UAnyMatrix2x3, glm_typing.UAnyMatrix2x4, glm_typing.UAnyMatrix3x2, glm_typing.UAnyMatrix3x3, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x2, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec2, umvec2]) -> None: ... + + def __neg__(self) -> umat2x2: ... + def __pos__(self) -> umat2x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat2x2: ... + + def __add__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + def __radd__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + def __iadd__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + + def __sub__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + def __rsub__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + def __isub__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + + @overload + def __truediv__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __truediv__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rtruediv__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rtruediv__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __itruediv__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __itruediv__(self, other: glm_typing.U32Vector2) -> uvec2: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + + +u32mat2x3 = umat2x3 + +class umat2x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x3, glm_typing.UAnyMatrix2x3, glm_typing.UAnyMatrix2x4, glm_typing.UAnyMatrix3x3, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec3, umvec3]) -> None: ... + + def __neg__(self) -> umat2x3: ... + def __pos__(self) -> umat2x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat2x3: ... + + def __add__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + def __radd__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + def __iadd__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + + def __sub__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + def __rsub__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + def __isub__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + + +u32mat2x4 = umat2x4 + +class umat2x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x4, glm_typing.UAnyMatrix2x4, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec4, umvec4]) -> None: ... + + def __neg__(self) -> umat2x4: ... + def __pos__(self) -> umat2x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat2x4: ... + + def __add__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + def __radd__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + def __iadd__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + + def __sub__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + def __rsub__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + def __isub__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + + +u32mat3x2 = umat3x2 + +class umat3x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x2, glm_typing.UAnyMatrix3x2, glm_typing.UAnyMatrix3x3, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x2, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec2, umvec2]) -> None: ... + + def __neg__(self) -> umat3x2: ... + def __pos__(self) -> umat3x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat3x2: ... + + def __add__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + def __radd__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + def __iadd__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + + def __sub__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + def __rsub__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + def __isub__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + + +u32mat3 = umat3x3 +u32mat3x3 = umat3x3 +umat3 = umat3x3 + +class umat3x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x3, glm_typing.UAnyMatrix3x3, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec3, umvec3]) -> None: ... + + def __neg__(self) -> umat3x3: ... + def __pos__(self) -> umat3x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat3x3: ... + + def __add__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + def __radd__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + def __iadd__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + + def __sub__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + def __rsub__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + def __isub__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + + @overload + def __truediv__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __truediv__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rtruediv__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rtruediv__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __itruediv__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __itruediv__(self, other: glm_typing.U32Vector3) -> uvec3: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + + +u32mat3x4 = umat3x4 + +class umat3x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x4, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec4, umvec4]) -> None: ... + + def __neg__(self) -> umat3x4: ... + def __pos__(self) -> umat3x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat3x4: ... + + def __add__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + def __radd__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + def __iadd__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + + def __sub__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + def __rsub__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + def __isub__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + + +u32mat4x2 = umat4x2 + +class umat4x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x2, glm_typing.UAnyMatrix4x2, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec2, umvec2]) -> None: ... + + def __neg__(self) -> umat4x2: ... + def __pos__(self) -> umat4x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat4x2: ... + + def __add__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + def __radd__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + def __iadd__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + + def __sub__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + def __rsub__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + def __isub__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + + +u32mat4x3 = umat4x3 + +class umat4x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x3, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec3, umvec3]) -> None: ... + + def __neg__(self) -> umat4x3: ... + def __pos__(self) -> umat4x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat4x3: ... + + def __add__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + def __radd__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + def __iadd__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + + def __sub__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + def __rsub__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + def __isub__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + + +u32mat4 = umat4x4 +u32mat4x4 = umat4x4 +umat4 = umat4x4 + +class umat4x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, _12: glm_typing.Number, _13: glm_typing.Number, _14: glm_typing.Number, _15: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x4, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec4, umvec4]) -> None: ... + + def __neg__(self) -> umat4x4: ... + def __pos__(self) -> umat4x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat4x4: ... + + def __add__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + def __radd__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + def __iadd__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + + def __sub__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + def __rsub__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + def __isub__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + + @overload + def __truediv__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __truediv__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rtruediv__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rtruediv__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __itruediv__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __itruediv__(self, other: glm_typing.U32Vector4) -> uvec4: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + + +f64quat = dquat + +class dquat: + w: float + x: float + y: float + z: float + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, w: glm_typing.Number, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, w: Union[glm_typing.AnyAnyQuaternion, glm_typing.D64Matrix3x3, glm_typing.D64Matrix4x4, glm_typing.D64Vector3]) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dquat: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + @overload + def __mul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + + @overload + def __matmul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmatmul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imatmul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + + +f32quat = quat +fquat = quat + +class quat: + w: float + x: float + y: float + z: float + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, w: glm_typing.Number, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, w: Union[glm_typing.AnyAnyQuaternion, glm_typing.F32Matrix3x3, glm_typing.F32Matrix4x4, glm_typing.F32Vector3]) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> quat: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + @overload + def __mul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec4: ... + + @overload + def __matmul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmatmul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imatmul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + + + +_AT = TypeVar('_AT', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_float, ctypes.c_double, ctypes.c_longdouble, dmat2x2, dmat2x3, dmat2x4, dmat3x2, dmat3x3, dmat3x4, dmat4x2, dmat4x3, dmat4x4, imat2x2, imat2x3, imat2x4, imat3x2, imat3x3, imat3x4, imat4x2, imat4x3, imat4x4, mat2x2, mat2x3, mat2x4, mat3x2, mat3x3, mat3x4, mat4x2, mat4x3, mat4x4, umat2x2, umat2x3, umat2x4, umat3x2, umat3x3, umat3x4, umat4x2, umat4x3, umat4x4, dquat, quat, bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, mvec2, mvec3, mvec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4, vec1, vec2, vec3, vec4) +_AT2 = TypeVar('_AT2', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_float, ctypes.c_double, ctypes.c_longdouble, dmat2x2, dmat2x3, dmat2x4, dmat3x2, dmat3x3, dmat3x4, dmat4x2, dmat4x3, dmat4x4, imat2x2, imat2x3, imat2x4, imat3x2, imat3x3, imat3x4, imat4x2, imat4x3, imat4x4, mat2x2, mat2x3, mat2x4, mat3x2, mat3x3, mat3x4, mat4x2, mat4x3, mat4x4, umat2x2, umat2x3, umat2x4, umat3x2, umat3x3, umat3x4, umat4x2, umat4x3, umat4x4, dquat, quat, bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, mvec2, mvec3, mvec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4, vec1, vec2, vec3, vec4) +_GLMT = TypeVar('_GLMT', dmat2x2, dmat2x3, dmat2x4, dmat3x2, dmat3x3, dmat3x4, dmat4x2, dmat4x3, dmat4x4, imat2x2, imat2x3, imat2x4, imat3x2, imat3x3, imat3x4, imat4x2, imat4x3, imat4x4, mat2x2, mat2x3, mat2x4, mat3x2, mat3x3, mat3x4, mat4x2, mat4x3, mat4x4, umat2x2, umat2x3, umat2x4, umat3x2, umat3x3, umat3x4, umat4x2, umat4x3, umat4x4, dquat, quat, bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, mvec2, mvec3, mvec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4, vec1, vec2, vec3, vec4) +_CT = TypeVar('_CT', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_float, ctypes.c_double, ctypes.c_longdouble) +_ICT = TypeVar('_ICT', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t) +_FCT = TypeVar('_FCT', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t) + +class array(Generic[_AT]): + + nbytes: int + typecode: str + element_type: Type[_AT] + itemsize: int + dt_size: int + address: int + length: int + readonly: bool + reference: Any + + @property + def ptr(self) -> ctypes.c_void_p: ... + + @property + def dtype(self) -> str: ... + + @property + def ctype(self) -> Type[Union[ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_float, ctypes.c_double, ctypes.c_longdouble]]: ... + + @overload + def __init__(self, _1: _AT, /, *_: _AT) -> None: ... + @overload + def __init__(self, _: array[_AT], /) -> None: ... + @overload + def __init__(self, _: Iterable[_AT], /) -> None: ... + + def __len__(self) -> int: ... + def __contains__(self, value: Any) -> bool: ... + + @overload + def __iter__(self: Union[array[ctypes.c_bool], array[ctypes.c_byte], array[ctypes.c_int8], array[ctypes.c_ubyte], array[ctypes.c_uint8], array[ctypes.c_short], array[ctypes.c_int16], array[ctypes.c_ushort], array[ctypes.c_uint16], array[ctypes.c_int], array[ctypes.c_int32], array[ctypes.c_uint], array[ctypes.c_uint32], array[ctypes.c_long], array[ctypes.c_int64], array[ctypes.c_ulong], array[ctypes.c_uint64], array[ctypes.c_longlong], array[ctypes.c_ulonglong], array[ctypes.c_size_t], array[ctypes.c_ssize_t]]) -> Generator[int, None, None]: ... + @overload + def __iter__(self: Union[array[ctypes.c_float], array[ctypes.c_double], array[ctypes.c_longdouble]]) -> Generator[float, None, None]: ... + @overload + def __iter__(self: array[_GLMT]) -> Generator[_AT, None, None]: ... + + @overload + def __getitem__(self: Union[array[ctypes.c_bool], array[ctypes.c_byte], array[ctypes.c_int8], array[ctypes.c_ubyte], array[ctypes.c_uint8], array[ctypes.c_short], array[ctypes.c_int16], array[ctypes.c_ushort], array[ctypes.c_uint16], array[ctypes.c_int], array[ctypes.c_int32], array[ctypes.c_uint], array[ctypes.c_uint32], array[ctypes.c_long], array[ctypes.c_int64], array[ctypes.c_ulong], array[ctypes.c_uint64], array[ctypes.c_longlong], array[ctypes.c_ulonglong], array[ctypes.c_size_t], array[ctypes.c_ssize_t]], index: int) -> int: ... + @overload + def __getitem__(self: Union[array[ctypes.c_float], array[ctypes.c_double], array[ctypes.c_longdouble]], index: int) -> float: ... + @overload + def __getitem__(self: array[_GLMT], index: int) -> _AT: ... + @overload + def __getitem__(self, index: slice) -> array[_AT]: ... + + @overload + def __setitem__(self: array[_ICT], index: int, value: _ICT) -> None: ... + @overload + def __setitem__(self: array[_FCT], index: int, value: _FCT) -> None: ... + @overload + def __setitem__(self: array[_GLMT], index: int, value: _AT) -> None: ... + @overload + def __setitem__(self, index: slice, value: array[_AT]) -> None: ... + + @staticmethod + def from_bytes(bytes: bytes, type: Type[_AT], /) -> array[_AT]: ... + + @staticmethod + def from_numbers(type: Type[_CT], /, *numbers: glm_typing.Number) -> array[_CT]: ... + + @staticmethod + def zeros(length: int, type: Type[_AT], /) -> array[_AT]: ... + + @overload + def to_list(self: array[_GLMT]) -> List[_GLMT]: ... + @overload + def to_list(self: Union[array[ctypes.c_bool], array[ctypes.c_byte], array[ctypes.c_int8], array[ctypes.c_ubyte], array[ctypes.c_uint8], array[ctypes.c_short], array[ctypes.c_int16], array[ctypes.c_ushort], array[ctypes.c_uint16], array[ctypes.c_int], array[ctypes.c_int32], array[ctypes.c_uint], array[ctypes.c_uint32], array[ctypes.c_long], array[ctypes.c_int64], array[ctypes.c_ulong], array[ctypes.c_uint64], array[ctypes.c_longlong], array[ctypes.c_ulonglong], array[ctypes.c_size_t], array[ctypes.c_ssize_t]]) -> List[int]: ... + @overload + def to_list(self: Union[array[ctypes.c_float], array[ctypes.c_double], array[ctypes.c_longdouble]]) -> List[float]: ... + + @overload + def to_tuple(self: array[_GLMT]) -> Tuple[_GLMT, ...]: ... + @overload + def to_tuple(self: Union[array[ctypes.c_bool], array[ctypes.c_byte], array[ctypes.c_int8], array[ctypes.c_ubyte], array[ctypes.c_uint8], array[ctypes.c_short], array[ctypes.c_int16], array[ctypes.c_ushort], array[ctypes.c_uint16], array[ctypes.c_int], array[ctypes.c_int32], array[ctypes.c_uint], array[ctypes.c_uint32], array[ctypes.c_long], array[ctypes.c_int64], array[ctypes.c_ulong], array[ctypes.c_uint64], array[ctypes.c_longlong], array[ctypes.c_ulonglong], array[ctypes.c_size_t], array[ctypes.c_ssize_t]]) -> Tuple[int, ...]: ... + @overload + def to_tuple(self: Union[array[ctypes.c_float], array[ctypes.c_double], array[ctypes.c_longdouble]]) -> Tuple[float, ...]: ... + + @overload + def split_components(self: array[bvec1]) -> Tuple[array[ctypes.c_bool]]: ... + @overload + def split_components(self: array[bvec2]) -> Tuple[array[ctypes.c_bool], array[ctypes.c_bool]]: ... + @overload + def split_components(self: array[bvec3]) -> Tuple[array[ctypes.c_bool], array[ctypes.c_bool], array[ctypes.c_bool]]: ... + @overload + def split_components(self: array[bvec4]) -> Tuple[array[ctypes.c_bool], array[ctypes.c_bool], array[ctypes.c_bool], array[ctypes.c_bool]]: ... + @overload + def split_components(self: array[dmvec2]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dmvec3]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dmvec4]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dvec1]) -> Tuple[array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dvec2]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dvec3]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dvec4]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[i16vec1]) -> Tuple[array[ctypes.c_short]]: ... + @overload + def split_components(self: array[i16vec2]) -> Tuple[array[ctypes.c_short], array[ctypes.c_short]]: ... + @overload + def split_components(self: array[i16vec3]) -> Tuple[array[ctypes.c_short], array[ctypes.c_short], array[ctypes.c_short]]: ... + @overload + def split_components(self: array[i16vec4]) -> Tuple[array[ctypes.c_short], array[ctypes.c_short], array[ctypes.c_short], array[ctypes.c_short]]: ... + @overload + def split_components(self: array[i64vec1]) -> Tuple[array[ctypes.c_longlong]]: ... + @overload + def split_components(self: array[i64vec2]) -> Tuple[array[ctypes.c_longlong], array[ctypes.c_longlong]]: ... + @overload + def split_components(self: array[i64vec3]) -> Tuple[array[ctypes.c_longlong], array[ctypes.c_longlong], array[ctypes.c_longlong]]: ... + @overload + def split_components(self: array[i64vec4]) -> Tuple[array[ctypes.c_longlong], array[ctypes.c_longlong], array[ctypes.c_longlong], array[ctypes.c_longlong]]: ... + @overload + def split_components(self: array[i8vec1]) -> Tuple[array[ctypes.c_byte]]: ... + @overload + def split_components(self: array[i8vec2]) -> Tuple[array[ctypes.c_byte], array[ctypes.c_byte]]: ... + @overload + def split_components(self: array[i8vec3]) -> Tuple[array[ctypes.c_byte], array[ctypes.c_byte], array[ctypes.c_byte]]: ... + @overload + def split_components(self: array[i8vec4]) -> Tuple[array[ctypes.c_byte], array[ctypes.c_byte], array[ctypes.c_byte], array[ctypes.c_byte]]: ... + @overload + def split_components(self: array[imvec2]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[imvec3]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[imvec4]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[ivec1]) -> Tuple[array[ctypes.c_long]]: ... + @overload + def split_components(self: array[ivec2]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[ivec3]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[ivec4]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[mvec2]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[mvec3]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[mvec4]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[u16vec1]) -> Tuple[array[ctypes.c_ushort]]: ... + @overload + def split_components(self: array[u16vec2]) -> Tuple[array[ctypes.c_ushort], array[ctypes.c_ushort]]: ... + @overload + def split_components(self: array[u16vec3]) -> Tuple[array[ctypes.c_ushort], array[ctypes.c_ushort], array[ctypes.c_ushort]]: ... + @overload + def split_components(self: array[u16vec4]) -> Tuple[array[ctypes.c_ushort], array[ctypes.c_ushort], array[ctypes.c_ushort], array[ctypes.c_ushort]]: ... + @overload + def split_components(self: array[u64vec1]) -> Tuple[array[ctypes.c_ulonglong]]: ... + @overload + def split_components(self: array[u64vec2]) -> Tuple[array[ctypes.c_ulonglong], array[ctypes.c_ulonglong]]: ... + @overload + def split_components(self: array[u64vec3]) -> Tuple[array[ctypes.c_ulonglong], array[ctypes.c_ulonglong], array[ctypes.c_ulonglong]]: ... + @overload + def split_components(self: array[u64vec4]) -> Tuple[array[ctypes.c_ulonglong], array[ctypes.c_ulonglong], array[ctypes.c_ulonglong], array[ctypes.c_ulonglong]]: ... + @overload + def split_components(self: array[u8vec1]) -> Tuple[array[ctypes.c_ubyte]]: ... + @overload + def split_components(self: array[u8vec2]) -> Tuple[array[ctypes.c_ubyte], array[ctypes.c_ubyte]]: ... + @overload + def split_components(self: array[u8vec3]) -> Tuple[array[ctypes.c_ubyte], array[ctypes.c_ubyte], array[ctypes.c_ubyte]]: ... + @overload + def split_components(self: array[u8vec4]) -> Tuple[array[ctypes.c_ubyte], array[ctypes.c_ubyte], array[ctypes.c_ubyte], array[ctypes.c_ubyte]]: ... + @overload + def split_components(self: array[umvec2]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[umvec3]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[umvec4]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[uvec1]) -> Tuple[array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[uvec2]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[uvec3]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[uvec4]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[vec1]) -> Tuple[array[ctypes.c_float]]: ... + @overload + def split_components(self: array[vec2]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[vec3]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[vec4]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[dquat]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[quat]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[dmat2x2]) -> Tuple[array[dvec2], array[dvec2]]: ... + @overload + def split_components(self: array[dmat2x3]) -> Tuple[array[dvec3], array[dvec3]]: ... + @overload + def split_components(self: array[dmat2x4]) -> Tuple[array[dvec4], array[dvec4]]: ... + @overload + def split_components(self: array[dmat3x2]) -> Tuple[array[dvec2], array[dvec2], array[dvec2]]: ... + @overload + def split_components(self: array[dmat3x3]) -> Tuple[array[dvec3], array[dvec3], array[dvec3]]: ... + @overload + def split_components(self: array[dmat3x4]) -> Tuple[array[dvec4], array[dvec4], array[dvec4]]: ... + @overload + def split_components(self: array[dmat4x2]) -> Tuple[array[dvec2], array[dvec2], array[dvec2], array[dvec2]]: ... + @overload + def split_components(self: array[dmat4x3]) -> Tuple[array[dvec3], array[dvec3], array[dvec3], array[dvec3]]: ... + @overload + def split_components(self: array[dmat4x4]) -> Tuple[array[dvec4], array[dvec4], array[dvec4], array[dvec4]]: ... + @overload + def split_components(self: array[imat2x2]) -> Tuple[array[ivec2], array[ivec2]]: ... + @overload + def split_components(self: array[imat2x3]) -> Tuple[array[ivec3], array[ivec3]]: ... + @overload + def split_components(self: array[imat2x4]) -> Tuple[array[ivec4], array[ivec4]]: ... + @overload + def split_components(self: array[imat3x2]) -> Tuple[array[ivec2], array[ivec2], array[ivec2]]: ... + @overload + def split_components(self: array[imat3x3]) -> Tuple[array[ivec3], array[ivec3], array[ivec3]]: ... + @overload + def split_components(self: array[imat3x4]) -> Tuple[array[ivec4], array[ivec4], array[ivec4]]: ... + @overload + def split_components(self: array[imat4x2]) -> Tuple[array[ivec2], array[ivec2], array[ivec2], array[ivec2]]: ... + @overload + def split_components(self: array[imat4x3]) -> Tuple[array[ivec3], array[ivec3], array[ivec3], array[ivec3]]: ... + @overload + def split_components(self: array[imat4x4]) -> Tuple[array[ivec4], array[ivec4], array[ivec4], array[ivec4]]: ... + @overload + def split_components(self: array[mat2x2]) -> Tuple[array[vec2], array[vec2]]: ... + @overload + def split_components(self: array[mat2x3]) -> Tuple[array[vec3], array[vec3]]: ... + @overload + def split_components(self: array[mat2x4]) -> Tuple[array[vec4], array[vec4]]: ... + @overload + def split_components(self: array[mat3x2]) -> Tuple[array[vec2], array[vec2], array[vec2]]: ... + @overload + def split_components(self: array[mat3x3]) -> Tuple[array[vec3], array[vec3], array[vec3]]: ... + @overload + def split_components(self: array[mat3x4]) -> Tuple[array[vec4], array[vec4], array[vec4]]: ... + @overload + def split_components(self: array[mat4x2]) -> Tuple[array[vec2], array[vec2], array[vec2], array[vec2]]: ... + @overload + def split_components(self: array[mat4x3]) -> Tuple[array[vec3], array[vec3], array[vec3], array[vec3]]: ... + @overload + def split_components(self: array[mat4x4]) -> Tuple[array[vec4], array[vec4], array[vec4], array[vec4]]: ... + @overload + def split_components(self: array[umat2x2]) -> Tuple[array[uvec2], array[uvec2]]: ... + @overload + def split_components(self: array[umat2x3]) -> Tuple[array[uvec3], array[uvec3]]: ... + @overload + def split_components(self: array[umat2x4]) -> Tuple[array[uvec4], array[uvec4]]: ... + @overload + def split_components(self: array[umat3x2]) -> Tuple[array[uvec2], array[uvec2], array[uvec2]]: ... + @overload + def split_components(self: array[umat3x3]) -> Tuple[array[uvec3], array[uvec3], array[uvec3]]: ... + @overload + def split_components(self: array[umat3x4]) -> Tuple[array[uvec4], array[uvec4], array[uvec4]]: ... + @overload + def split_components(self: array[umat4x2]) -> Tuple[array[uvec2], array[uvec2], array[uvec2], array[uvec2]]: ... + @overload + def split_components(self: array[umat4x3]) -> Tuple[array[uvec3], array[uvec3], array[uvec3], array[uvec3]]: ... + @overload + def split_components(self: array[umat4x4]) -> Tuple[array[uvec4], array[uvec4], array[uvec4], array[uvec4]]: ... + + def to_bytes(self) -> bytes: ... + + def reduce(self, func: Callable[[_AT, _AT], _AT], init: Optional[_AT] = ..., /) -> _AT: ... + def filter(self, _: Callable[[_AT], Any], /) -> array[_AT]: ... + def map(self, _: Callable[[_AT], _AT2], /) -> array[_AT2]: ... + def sort(self, _: Callable[[_AT], SupportsInt], /) -> array[_AT]: ... + def concat(self, other: array[_AT], /) -> array[_AT]: ... + def iconcat(self, other: array[_AT], /) -> None: ... + def repeat(self, count: int, /) -> array[_AT]: ... + def irepeat(self, count: int, /) -> None: ... + + @overload + @staticmethod + def as_reference(array: array[_AT], /) -> array[_AT]: ... + @overload + @staticmethod + def as_reference(obj: _GLMT, /) -> array[_GLMT]: ... + + def reinterpret_cast(self, type: Type[_AT], /) -> array[_AT]: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def __add__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __radd__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __iadd__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __sub__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rsub__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __isub__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __mul__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rmul__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __imul__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __mod__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rmod__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __imod__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __pow__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rpow__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ipow__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __lshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rlshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ilshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rrshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __irshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __and__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rand__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __iand__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __xor__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rxor__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ixor__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __or__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ror__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ior__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __truediv__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rtruediv__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __itruediv__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + + def __neg__(self) -> array[_AT]: ... + def __pos__(self) -> array[_AT]: ... + def __abs__(self) -> array[_AT]: ... + def __inv__(self) -> array[_AT]: ... + + +@overload +def abs(x: glm_typing.Number, /) -> float: ... +@overload +def abs(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def abs(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def abs(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def abs(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def abs(x: _VT, /) -> _VT: ... + +@overload +def ceil(x: glm_typing.Number, /) -> float: ... +@overload +def ceil(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def ceil(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def ceil(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def ceil(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def ceil(x: _VT, /) -> _VT: ... + +@overload +def clamp(x: glm_typing.Number, min: glm_typing.Number, max: glm_typing.Number, /) -> glm_typing.Number: ... +@overload +def clamp(x: glm_typing.F32Vector1, min: glm_typing.Number, max: glm_typing.Number, /) -> vec1: ... +@overload +def clamp(x: glm_typing.F32Vector1, min: glm_typing.F32Vector1, max: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def clamp(x: glm_typing.F32Vector2, min: glm_typing.Number, max: glm_typing.Number, /) -> vec2: ... +@overload +def clamp(x: glm_typing.F32Vector2, min: glm_typing.F32Vector2, max: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def clamp(x: glm_typing.F32Vector3, min: glm_typing.Number, max: glm_typing.Number, /) -> vec3: ... +@overload +def clamp(x: glm_typing.F32Vector3, min: glm_typing.F32Vector3, max: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def clamp(x: glm_typing.F32Vector4, min: glm_typing.Number, max: glm_typing.Number, /) -> vec4: ... +@overload +def clamp(x: glm_typing.F32Vector4, min: glm_typing.F32Vector4, max: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def clamp(x: _NF32VT, min: glm_typing.Number, max: glm_typing.Number, /) -> _NF32VT: ... +@overload +def clamp(x: _NF32VT, min: _NF32VT, max: _NF32VT, /) -> _NF32VT: ... + +@overload +def floatBitsToInt(x: float, /) -> int: ... +@overload +def floatBitsToInt(x: glm_typing.F32Vector2, /) -> ivec2: ... +@overload +def floatBitsToInt(x: glm_typing.F32Vector3, /) -> ivec3: ... +@overload +def floatBitsToInt(x: glm_typing.F32Vector4, /) -> ivec4: ... +@overload +def floatBitsToInt(x: glm_typing.F32Vector1, /) -> ivec1: ... + +@overload +def floatBitsToUint(x: float, /) -> int: ... +@overload +def floatBitsToUint(x: glm_typing.F32Vector2, /) -> uvec2: ... +@overload +def floatBitsToUint(x: glm_typing.F32Vector3, /) -> uvec3: ... +@overload +def floatBitsToUint(x: glm_typing.F32Vector4, /) -> uvec4: ... +@overload +def floatBitsToUint(x: glm_typing.F32Vector1, /) -> uvec1: ... + +@overload +def floor(x: glm_typing.Number, /) -> float: ... +@overload +def floor(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def floor(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def floor(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def floor(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def floor(x: _VT, /) -> _VT: ... + +def fma(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... + +@overload +def fmax(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def fmax(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... +@overload +def fmax(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, d: glm_typing.Number, /) -> float: ... +@overload +def fmax(x: glm_typing.F32Vector1, y: glm_typing.Number, /) -> vec1: ... +@overload +def fmax(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmax(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmax(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, d: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmax(x: glm_typing.F32Vector2, y: glm_typing.Number, /) -> vec2: ... +@overload +def fmax(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmax(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmax(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, d: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmax(x: glm_typing.F32Vector3, y: glm_typing.Number, /) -> vec3: ... +@overload +def fmax(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmax(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmax(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, d: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmax(x: glm_typing.F32Vector4, y: glm_typing.Number, /) -> vec4: ... +@overload +def fmax(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmax(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmax(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, d: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmax(x: _NF32VT, y: glm_typing.Number, /) -> _NF32VT: ... +@overload +def fmax(x: _NF32VT, y: _NF32VT, /) -> _NF32VT: ... +@overload +def fmax(a: _NF32VT, b: _NF32VT, c: _NF32VT, /) -> _NF32VT: ... +@overload +def fmax(a: _NF32VT, b: _NF32VT, c: _NF32VT, d: _NF32VT, /) -> _NF32VT: ... + +@overload +def fmin(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def fmin(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... +@overload +def fmin(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, d: glm_typing.Number, /) -> float: ... +@overload +def fmin(x: glm_typing.F32Vector1, y: glm_typing.Number, /) -> vec1: ... +@overload +def fmin(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmin(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmin(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, d: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmin(x: glm_typing.F32Vector2, y: glm_typing.Number, /) -> vec2: ... +@overload +def fmin(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmin(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmin(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, d: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmin(x: glm_typing.F32Vector3, y: glm_typing.Number, /) -> vec3: ... +@overload +def fmin(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmin(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmin(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, d: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmin(x: glm_typing.F32Vector4, y: glm_typing.Number, /) -> vec4: ... +@overload +def fmin(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmin(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmin(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, d: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmin(x: _NF32VT, y: glm_typing.Number, /) -> _NF32VT: ... +@overload +def fmin(x: _NF32VT, y: _NF32VT, /) -> _NF32VT: ... +@overload +def fmin(a: _NF32VT, b: _NF32VT, c: _NF32VT, /) -> _NF32VT: ... +@overload +def fmin(a: _NF32VT, b: _NF32VT, c: _NF32VT, d: _NF32VT, /) -> _NF32VT: ... + +@overload +def fract(x: glm_typing.Number, /) -> float: ... +@overload +def fract(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def fract(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def fract(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def fract(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def fract(x: _VT, /) -> _VT: ... + +@overload +def frexp(x: glm_typing.Number, /) -> Tuple[float, int]: ... +@overload +def frexp(x: dvec1, exp: ivec1, /) -> dvec1: ... +@overload +def frexp(x: dvec2, exp: ivec2, /) -> dvec2: ... +@overload +def frexp(x: dvec3, exp: ivec3, /) -> dvec3: ... +@overload +def frexp(x: dvec4, exp: ivec4, /) -> dvec4: ... +@overload +def frexp(x: glm_typing.F32Vector1, exp: ivec1, /) -> vec1: ... +@overload +def frexp(x: glm_typing.F32Vector2, exp: ivec2, /) -> vec2: ... +@overload +def frexp(x: glm_typing.F32Vector3, exp: ivec3, /) -> vec3: ... +@overload +def frexp(x: glm_typing.F32Vector4, exp: ivec4, /) -> vec4: ... + +@overload +def intBitsToFloat(x: int, /) -> float: ... +@overload +def intBitsToFloat(x: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def intBitsToFloat(x: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def intBitsToFloat(x: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def intBitsToFloat(x: glm_typing.I32Vector1, /) -> vec1: ... + +@overload +def isinf(x: glm_typing.Number, /) -> bool: ... +@overload +def isinf(x: glm_typing.FDAnyVector1, /) -> bvec1: ... +@overload +def isinf(x: glm_typing.FDAnyVector2, /) -> bvec2: ... +@overload +def isinf(x: glm_typing.FDAnyVector3, /) -> bvec3: ... +@overload +def isinf(x: glm_typing.FDAnyQuaternionVector4, /) -> bvec4: ... + +@overload +def isnan(x: glm_typing.Number, /) -> bool: ... +@overload +def isnan(x: glm_typing.FDAnyVector1, /) -> bvec1: ... +@overload +def isnan(x: glm_typing.FDAnyVector2, /) -> bvec2: ... +@overload +def isnan(x: glm_typing.FDAnyVector3, /) -> bvec3: ... +@overload +def isnan(x: glm_typing.FDAnyQuaternionVector4, /) -> bvec4: ... + +@overload +def ldexp(x: glm_typing.Number, exp: glm_typing.Number, /) -> float: ... +@overload +def ldexp(x: dmvec2, exp: ivec2, /) -> dmvec2: ... +@overload +def ldexp(x: dmvec3, exp: ivec3, /) -> dmvec3: ... +@overload +def ldexp(x: dmvec4, exp: ivec4, /) -> dmvec4: ... +@overload +def ldexp(x: dvec1, exp: ivec1, /) -> dvec1: ... +@overload +def ldexp(x: dvec2, exp: ivec2, /) -> dvec2: ... +@overload +def ldexp(x: dvec3, exp: ivec3, /) -> dvec3: ... +@overload +def ldexp(x: dvec4, exp: ivec4, /) -> dvec4: ... +@overload +def ldexp(x: mvec2, exp: ivec2, /) -> mvec2: ... +@overload +def ldexp(x: mvec3, exp: ivec3, /) -> mvec3: ... +@overload +def ldexp(x: mvec4, exp: ivec4, /) -> mvec4: ... +@overload +def ldexp(x: Union[vec1, Tuple[glm_typing.Number]], exp: ivec1, /) -> vec1: ... +@overload +def ldexp(x: Union[vec2, Tuple[glm_typing.Number, glm_typing.Number]], exp: ivec2, /) -> vec2: ... +@overload +def ldexp(x: Union[vec3, Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number]], exp: ivec3, /) -> vec3: ... +@overload +def ldexp(x: Union[vec4, Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number]], exp: ivec4, /) -> vec4: ... + +@overload +def max(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def max(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... +@overload +def max(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, d: glm_typing.Number, /) -> float: ... +@overload +def max(x: glm_typing.F32Vector1, y: glm_typing.Number, /) -> vec1: ... +@overload +def max(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def max(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def max(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, d: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def max(x: glm_typing.F32Vector2, y: glm_typing.Number, /) -> vec2: ... +@overload +def max(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def max(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def max(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, d: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def max(x: glm_typing.F32Vector3, y: glm_typing.Number, /) -> vec3: ... +@overload +def max(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def max(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def max(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, d: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def max(x: glm_typing.F32Vector4, y: glm_typing.Number, /) -> vec4: ... +@overload +def max(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def max(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def max(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, d: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def max(x: _NF32VT, y: glm_typing.Number, /) -> _NF32VT: ... +@overload +def max(x: _NF32VT, y: _NF32VT, /) -> _NF32VT: ... +@overload +def max(a: _NF32VT, b: _NF32VT, c: _NF32VT, /) -> _NF32VT: ... +@overload +def max(a: _NF32VT, b: _NF32VT, c: _NF32VT, d: _NF32VT, /) -> _NF32VT: ... +@overload +def max(_: Iterable[_T], /) -> _T: ... + +@overload +def min(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def min(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... +@overload +def min(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, d: glm_typing.Number, /) -> float: ... +@overload +def min(x: glm_typing.F32Vector1, y: glm_typing.Number, /) -> vec1: ... +@overload +def min(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def min(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def min(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, d: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def min(x: glm_typing.F32Vector2, y: glm_typing.Number, /) -> vec2: ... +@overload +def min(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def min(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def min(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, d: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def min(x: glm_typing.F32Vector3, y: glm_typing.Number, /) -> vec3: ... +@overload +def min(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def min(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def min(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, d: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def min(x: glm_typing.F32Vector4, y: glm_typing.Number, /) -> vec4: ... +@overload +def min(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def min(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def min(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, d: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def min(x: _NF32VT, y: glm_typing.Number, /) -> _NF32VT: ... +@overload +def min(x: _NF32VT, y: _NF32VT, /) -> _NF32VT: ... +@overload +def min(a: _NF32VT, b: _NF32VT, c: _NF32VT, /) -> _NF32VT: ... +@overload +def min(a: _NF32VT, b: _NF32VT, c: _NF32VT, d: _NF32VT, /) -> _NF32VT: ... +@overload +def min(_: Iterable[_T], /) -> _T: ... + +@overload +def mix(x: glm_typing.Number, y: glm_typing.Number, a: glm_typing.Number, /) -> float: ... +@overload +def mix(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, a: Union[glm_typing.FDAnyVector1, glm_typing.BAnyVector1, glm_typing.Number], /) -> vec1: ... +@overload +def mix(x: _NF32V1T, y: _NF32V1T, a: Union[glm_typing.FDAnyVector1, glm_typing.BAnyVector1, glm_typing.Number], /) -> _NF32V1T: ... +@overload +def mix(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, a: Union[glm_typing.FDAnyVector2, glm_typing.BAnyVector2, glm_typing.Number], /) -> vec2: ... +@overload +def mix(x: _NF32V2T, y: _NF32V2T, a: Union[glm_typing.FDAnyVector2, glm_typing.BAnyVector2, glm_typing.Number], /) -> _NF32V2T: ... +@overload +def mix(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, a: Union[glm_typing.FDAnyVector3, glm_typing.BAnyVector3, glm_typing.Number], /) -> vec3: ... +@overload +def mix(x: _NF32V3T, y: _NF32V3T, a: Union[glm_typing.FDAnyVector3, glm_typing.BAnyVector3, glm_typing.Number], /) -> _NF32V3T: ... +@overload +def mix(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, a: Union[glm_typing.FDAnyVector4, glm_typing.BAnyVector4, glm_typing.Number], /) -> vec4: ... +@overload +def mix(x: _NF32V4T, y: _NF32V4T, a: Union[glm_typing.FDAnyVector4, glm_typing.BAnyVector4, glm_typing.Number], /) -> _NF32V4T: ... +@overload +def mix(x: glm_typing.F32Matrix2x2, y: glm_typing.F32Matrix2x2, a: Union[glm_typing.FAnyMatrix2x2, glm_typing.Number], /) -> mat2x2: ... +@overload +def mix(x: _NF32M2X2T, y: _NF32M2X2T, a: Union[glm_typing.FAnyMatrix2x2, glm_typing.Number], /) -> _NF32M2X2T: ... +@overload +def mix(x: glm_typing.F32Matrix2x3, y: glm_typing.F32Matrix2x3, a: Union[glm_typing.FAnyMatrix2x3, glm_typing.Number], /) -> mat2x3: ... +@overload +def mix(x: _NF32M2X3T, y: _NF32M2X3T, a: Union[glm_typing.FAnyMatrix2x3, glm_typing.Number], /) -> _NF32M2X3T: ... +@overload +def mix(x: glm_typing.F32Matrix2x4, y: glm_typing.F32Matrix2x4, a: Union[glm_typing.FAnyMatrix2x4, glm_typing.Number], /) -> mat2x4: ... +@overload +def mix(x: _NF32M2X4T, y: _NF32M2X4T, a: Union[glm_typing.FAnyMatrix2x4, glm_typing.Number], /) -> _NF32M2X4T: ... +@overload +def mix(x: glm_typing.F32Matrix3x2, y: glm_typing.F32Matrix3x2, a: Union[glm_typing.FAnyMatrix3x2, glm_typing.Number], /) -> mat3x2: ... +@overload +def mix(x: _NF32M3X2T, y: _NF32M3X2T, a: Union[glm_typing.FAnyMatrix3x2, glm_typing.Number], /) -> _NF32M3X2T: ... +@overload +def mix(x: glm_typing.F32Matrix3x3, y: glm_typing.F32Matrix3x3, a: Union[glm_typing.FAnyMatrix3x3, glm_typing.Number], /) -> mat3x3: ... +@overload +def mix(x: _NF32M3X3T, y: _NF32M3X3T, a: Union[glm_typing.FAnyMatrix3x3, glm_typing.Number], /) -> _NF32M3X3T: ... +@overload +def mix(x: glm_typing.F32Matrix3x4, y: glm_typing.F32Matrix3x4, a: Union[glm_typing.FAnyMatrix3x4, glm_typing.Number], /) -> mat3x4: ... +@overload +def mix(x: _NF32M3X4T, y: _NF32M3X4T, a: Union[glm_typing.FAnyMatrix3x4, glm_typing.Number], /) -> _NF32M3X4T: ... +@overload +def mix(x: glm_typing.F32Matrix4x2, y: glm_typing.F32Matrix4x2, a: Union[glm_typing.FAnyMatrix4x2, glm_typing.Number], /) -> mat4x2: ... +@overload +def mix(x: _NF32M4X2T, y: _NF32M4X2T, a: Union[glm_typing.FAnyMatrix4x2, glm_typing.Number], /) -> _NF32M4X2T: ... +@overload +def mix(x: glm_typing.F32Matrix4x3, y: glm_typing.F32Matrix4x3, a: Union[glm_typing.FAnyMatrix4x3, glm_typing.Number], /) -> mat4x3: ... +@overload +def mix(x: _NF32M4X3T, y: _NF32M4X3T, a: Union[glm_typing.FAnyMatrix4x3, glm_typing.Number], /) -> _NF32M4X3T: ... +@overload +def mix(x: glm_typing.F32Matrix4x4, y: glm_typing.F32Matrix4x4, a: Union[glm_typing.FAnyMatrix4x4, glm_typing.Number], /) -> mat4x4: ... +@overload +def mix(x: _NF32M4X4T, y: _NF32M4X4T, a: Union[glm_typing.FAnyMatrix4x4, glm_typing.Number], /) -> _NF32M4X4T: ... +@overload +def mix(x: _QT, y: _QT, a: glm_typing.Number, /) -> _QT: ... + +@overload +def modf(x: glm_typing.Number, /) -> Tuple[float, float]: ... +@overload +def modf(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def modf(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def modf(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def modf(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def modf(x: _FDVT, i: _FDVT, /) -> _FDVT: ... + +@overload +def round(x: glm_typing.Number, /) -> float: ... +@overload +def round(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def round(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def round(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def round(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def round(x: _FDVT, i: _FDVT, /) -> _FDVT: ... + +@overload +def roundEven(x: glm_typing.Number, /) -> float: ... +@overload +def roundEven(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def roundEven(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def roundEven(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def roundEven(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def roundEven(x: _FDVT, i: _FDVT, /) -> _FDVT: ... + +@overload +def sign(x: glm_typing.Number, /) -> float: ... +@overload +def sign(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def sign(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def sign(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def sign(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def sign(x: _FDVT, i: _FDVT, /) -> _FDVT: ... + +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.Number, /) -> float: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def smoothstep(edge0: glm_typing.F32Vector1, edge1: glm_typing.F32Vector1, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def smoothstep(edge0: glm_typing.F32Vector2, edge1: glm_typing.F32Vector2, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def smoothstep(edge0: glm_typing.F32Vector3, edge1: glm_typing.F32Vector3, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def smoothstep(edge0: glm_typing.F32Vector4, edge1: glm_typing.F32Vector4, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: _NF32VT, /) -> _FDVT: ... +@overload +def smoothstep(edge0: _NF32VT, edge1: _NF32VT, x: _NF32VT, /) -> _NF32VT: ... + +@overload +def step(edge: glm_typing.Number, x: glm_typing.Number, /) -> float: ... +@overload +def step(edge: glm_typing.Number, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def step(edge: glm_typing.F32Vector1, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def step(edge: glm_typing.Number, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def step(edge: glm_typing.F32Vector2, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def step(edge: glm_typing.Number, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def step(edge: glm_typing.F32Vector3, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def step(edge: glm_typing.Number, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def step(edge: glm_typing.F32Vector4, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def step(edge: glm_typing.Number, x: _NF32VT, /) -> _NF32VT: ... +@overload +def step(edge: _NF32VT, x: _NF32VT, /) -> _NF32VT: ... + +@overload +def trunc(x: glm_typing.Number, /) -> float: ... +@overload +def trunc(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def trunc(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def trunc(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def trunc(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def trunc(x: _FDVT, /) -> _FDVT: ... + +@overload +def uintBitsToFloat(x: int, /) -> float: ... +@overload +def uintBitsToFloat(x: glm_typing.U32Vector2, /) -> vec2: ... +@overload +def uintBitsToFloat(x: glm_typing.U32Vector3, /) -> vec3: ... +@overload +def uintBitsToFloat(x: glm_typing.U32Vector4, /) -> vec4: ... +@overload +def uintBitsToFloat(x: glm_typing.U32Vector1, /) -> vec1: ... + + +@overload +def exp(x: glm_typing.Number, /) -> float: ... +@overload +def exp(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def exp(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def exp(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def exp(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def exp(x: _FDVT, /) -> _FDVT: ... +@overload +def exp(x: _QT, /) -> _QT: ... + +@overload +def exp2(x: glm_typing.Number, /) -> float: ... +@overload +def exp2(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def exp2(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def exp2(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def exp2(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def exp2(x: _FDVT, /) -> _FDVT: ... + +@overload +def inversesqrt(x: glm_typing.Number, /) -> float: ... +@overload +def inversesqrt(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def inversesqrt(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def inversesqrt(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def inversesqrt(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def inversesqrt(x: _FDVT, /) -> _FDVT: ... + +@overload +def log(x: glm_typing.Number, /) -> float: ... +@overload +def log(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def log(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def log(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def log(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def log(x: _FDVT, /) -> _FDVT: ... +@overload +def log(x: _QT, /) -> _QT: ... + +@overload +def log2(x: glm_typing.Number, /) -> float: ... +@overload +def log2(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def log2(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def log2(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def log2(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def log2(x: _FDVT, /) -> _FDVT: ... + +@overload +def pow(base: glm_typing.Number, exponent: glm_typing.Number, /) -> float: ... +@overload +def pow(base: glm_typing.F32Vector1, exponent: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def pow(base: glm_typing.F32Vector2, exponent: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def pow(base: glm_typing.F32Vector3, exponent: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def pow(base: glm_typing.F32Vector4, exponent: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def pow(base: _NF32DFVT, exponent: _NF32DFVT, /) -> _NF32DFVT: ... +@overload +def pow(base: _QT, exponent: _QT, /) -> _QT: ... + +@overload +def sqrt(x: glm_typing.Number, /) -> float: ... +@overload +def sqrt(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def sqrt(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def sqrt(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def sqrt(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def sqrt(x: _FDVT, /) -> _FDVT: ... +@overload +def sqrt(x: _QT, /) -> _QT: ... + + +@overload +def cross(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def cross(x: _NF32DFV3T, y: _NF32DFV3T, /) -> _NF32DFV3T: ... +@overload +def cross(x: _QT, y: _QT, /) -> _QT: ... + +@overload +def distance(p0: glm_typing.Number, p1: glm_typing.Number, /) -> float: ... +@overload +def distance(p0: glm_typing.F32Vector1, p1: glm_typing.F32Vector1, /) -> float: ... +@overload +def distance(p0: glm_typing.F32Vector2, p1: glm_typing.F32Vector2, /) -> float: ... +@overload +def distance(p0: glm_typing.F32Vector3, p1: glm_typing.F32Vector3, /) -> float: ... +@overload +def distance(p0: glm_typing.F32Vector4, p1: glm_typing.F32Vector4, /) -> float: ... +@overload +def distance(p0: _NF32DFVT, p1: _NF32DFVT, /) -> float: ... + +@overload +def dot(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def dot(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> float: ... +@overload +def dot(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> float: ... +@overload +def dot(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def dot(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> float: ... +@overload +def dot(x: _NF32DFVT, y: _NF32DFVT, /) -> float: ... +@overload +def dot(x: _QT, y: _QT, /) -> float: ... + +@overload +def faceforward(N: glm_typing.Number, I: glm_typing.Number, Nref: float, /) -> float: ... +@overload +def faceforward(x: glm_typing.F32Vector1, I: glm_typing.F32Vector1, Nref: glm_typing.F32Vector1, /) -> float: ... +@overload +def faceforward(x: glm_typing.F32Vector2, I: glm_typing.F32Vector2, Nref: glm_typing.F32Vector2, /) -> float: ... +@overload +def faceforward(x: glm_typing.F32Vector3, I: glm_typing.F32Vector3, Nref: glm_typing.F32Vector3, /) -> float: ... +@overload +def faceforward(x: glm_typing.F32Vector4, I: glm_typing.F32Vector4, Nref: glm_typing.F32Vector4, /) -> float: ... +@overload +def faceforward(N: _NF32DFVT, I: _NF32DFVT, Nref: _NF32DFVT, /) -> _NF32DFVT: ... + +def length(x: Union[glm_typing.Number, glm_typing.FDAnyVectorAny, glm_typing.FDAnyQuaternion], /) -> float: ... + +@overload +def normalize(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def normalize(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def normalize(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def normalize(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def normalize(x: _FDVT, /) -> _FDVT: ... +@overload +def normalize(x: _QT, /) -> _QT: ... + +@overload +def reflect(I: glm_typing.Number, N: glm_typing.Number, /) -> float: ... +@overload +def reflect(I: glm_typing.F32Vector1, N: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def reflect(I: glm_typing.F32Vector2, N: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def reflect(I: glm_typing.F32Vector3, N: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def reflect(I: glm_typing.F32Vector4, N: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def reflect(I: _NF32DFVT, N: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def refract(I: glm_typing.Number, N: glm_typing.Number, eta: float, /) -> float: ... +@overload +def refract(I: glm_typing.F32Vector1, N: glm_typing.F32Vector1, eta: float, /) -> vec1: ... +@overload +def refract(I: glm_typing.F32Vector2, N: glm_typing.F32Vector2, eta: float, /) -> vec2: ... +@overload +def refract(I: glm_typing.F32Vector3, N: glm_typing.F32Vector3, eta: float, /) -> vec3: ... +@overload +def refract(I: glm_typing.F32Vector4, N: glm_typing.F32Vector4, eta: float, /) -> vec4: ... +@overload +def refract(I: _NF32DFVT, N: _NF32DFVT, eta: float, /) -> _NF32DFVT: ... + + +@overload +def bitCount(v: int, /) -> int: ... +@overload +def bitCount(v: glm_typing.IUAnyVector1, /) -> ivec1: ... +@overload +def bitCount(v: glm_typing.IUAnyVector2, /) -> ivec2: ... +@overload +def bitCount(v: glm_typing.IUAnyVector3, /) -> ivec3: ... +@overload +def bitCount(v: glm_typing.IUAnyVector4, /) -> ivec4: ... + +@overload +def bitfieldExtract(value: int, offset: int, bits: int, /) -> int: ... +@overload +def bitfieldExtract(v: glm_typing.I32Vector1, offset: int, bits: int, /) -> ivec1: ... +@overload +def bitfieldExtract(v: glm_typing.I32Vector2, offset: int, bits: int, /) -> ivec2: ... +@overload +def bitfieldExtract(v: glm_typing.I32Vector3, offset: int, bits: int, /) -> ivec3: ... +@overload +def bitfieldExtract(v: glm_typing.I32Vector4, offset: int, bits: int, /) -> ivec4: ... +@overload +def bitfieldExtract(value: _NI32IUVT, offset: int, bits: int, /) -> _NI32IUVT: ... + +@overload +def bitfieldInsert(base: int, insert: int, offset: int, bits: int, /) -> int: ... +@overload +def bitfieldInsert(base: glm_typing.I32Vector1, insert: glm_typing.I32Vector1, offset: int, bits: int, /) -> ivec1: ... +@overload +def bitfieldInsert(base: glm_typing.I32Vector2, insert: glm_typing.I32Vector2, offset: int, bits: int, /) -> ivec2: ... +@overload +def bitfieldInsert(base: glm_typing.I32Vector3, insert: glm_typing.I32Vector3, offset: int, bits: int, /) -> ivec3: ... +@overload +def bitfieldInsert(base: glm_typing.I32Vector4, insert: glm_typing.I32Vector4, offset: int, bits: int, /) -> ivec4: ... +@overload +def bitfieldInsert(base: _NI32IUVT, insert: _NI32IUVT, offset: int, bits: int, /) -> _NI32IUVT: ... + +@overload +def bitfieldReverse(value: int, /) -> int: ... +@overload +def bitfieldReverse(value: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def bitfieldReverse(value: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def bitfieldReverse(value: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def bitfieldReverse(value: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def bitfieldReverse(value: _NI32IUVT, /) -> _NI32IUVT: ... + +@overload +def findLSB(value: int, /) -> int: ... +@overload +def findLSB(value: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def findLSB(value: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def findLSB(value: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def findLSB(value: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def findLSB(value: _NI32IUVT, /) -> _NI32IUVT: ... + +@overload +def findMSB(value: int, /) -> int: ... +@overload +def findMSB(value: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def findMSB(value: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def findMSB(value: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def findMSB(value: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def findMSB(value: _NI32IUVT, /) -> _NI32IUVT: ... + +def imulExtended(x: _IVT, y: _IVT, msb: _IVT, lsb: _IVT, /) -> None: ... + +def uaddCarry(x: _UVT, y: _UVT, carry: _UVT, /) -> _UVT: ... + +def umulExtended(x: _UVT, y: _UVT, msb: _UVT, lsb: _UVT, /) -> None: ... + +def usubBorrow(x: _UVT, y: _UVT, borrow: _UVT, /) -> _UVT: ... + + +def determinant(m: glm_typing.AnyAnyMatrixSquare, /) -> float: ... + +@overload +def inverse(m: glm_typing.F32Matrix2x2, /) -> mat2x2: ... +@overload +def inverse(m: glm_typing.F32Matrix3x3, /) -> mat3x3: ... +@overload +def inverse(m: glm_typing.F32Matrix4x4, /) -> mat4x4: ... +@overload +def inverse(m: _NF32FDMSQRT, /) -> _NF32FDMSQRT: ... +@overload +def inverse(q: _QT, /) -> _QT: ... + +@overload +def matrixCompMult(x: glm_typing.F32Matrix2x2, y: glm_typing.F32Matrix2x2, /) -> mat2x2: ... +@overload +def matrixCompMult(x: glm_typing.F32Matrix3x3, y: glm_typing.F32Matrix3x3, /) -> mat3x3: ... +@overload +def matrixCompMult(x: glm_typing.F32Matrix4x4, y: glm_typing.F32Matrix4x4, /) -> mat4x4: ... +@overload +def matrixCompMult(x: _NF32FDMSQRT, y: _NF32FDMSQRT, /) -> _NF32FDMSQRT: ... + +@overload +def outerProduct(c: glm_typing.F32Vector2, r: glm_typing.F32Vector2, /) -> mat2x2: ... +@overload +def outerProduct(c: dvec2, r: dvec2, /) -> mat2x2: ... +@overload +def outerProduct(c: glm_typing.F32Vector2, r: glm_typing.F32Vector3, /) -> mat3x2: ... +@overload +def outerProduct(c: dvec2, r: dvec3, /) -> mat3x2: ... +@overload +def outerProduct(c: glm_typing.F32Vector2, r: glm_typing.F32Vector4, /) -> mat4x2: ... +@overload +def outerProduct(c: dvec2, r: dvec4, /) -> mat4x2: ... +@overload +def outerProduct(c: glm_typing.F32Vector3, r: glm_typing.F32Vector2, /) -> mat2x3: ... +@overload +def outerProduct(c: dvec3, r: dvec2, /) -> mat2x3: ... +@overload +def outerProduct(c: glm_typing.F32Vector3, r: glm_typing.F32Vector3, /) -> mat3x3: ... +@overload +def outerProduct(c: dvec3, r: dvec3, /) -> mat3x3: ... +@overload +def outerProduct(c: glm_typing.F32Vector3, r: glm_typing.F32Vector4, /) -> mat4x3: ... +@overload +def outerProduct(c: dvec3, r: dvec4, /) -> mat4x3: ... +@overload +def outerProduct(c: glm_typing.F32Vector4, r: glm_typing.F32Vector2, /) -> mat2x4: ... +@overload +def outerProduct(c: dvec4, r: dvec2, /) -> mat2x4: ... +@overload +def outerProduct(c: glm_typing.F32Vector4, r: glm_typing.F32Vector3, /) -> mat3x4: ... +@overload +def outerProduct(c: dvec4, r: dvec3, /) -> mat3x4: ... +@overload +def outerProduct(c: glm_typing.F32Vector4, r: glm_typing.F32Vector4, /) -> mat4x4: ... +@overload +def outerProduct(c: dvec4, r: dvec4, /) -> mat4x4: ... + +@overload +def transpose(x: glm_typing.F32Matrix2x2, /) -> fmat2x2: ... +@overload +def transpose(x: glm_typing.F32Matrix2x3, /) -> fmat3x2: ... +@overload +def transpose(x: glm_typing.F32Matrix2x4, /) -> fmat4x2: ... +@overload +def transpose(x: glm_typing.F32Matrix3x2, /) -> fmat2x3: ... +@overload +def transpose(x: glm_typing.F32Matrix3x3, /) -> fmat3x3: ... +@overload +def transpose(x: glm_typing.F32Matrix3x4, /) -> fmat4x3: ... +@overload +def transpose(x: glm_typing.F32Matrix4x2, /) -> fmat2x4: ... +@overload +def transpose(x: glm_typing.F32Matrix4x3, /) -> fmat3x4: ... +@overload +def transpose(x: glm_typing.F32Matrix4x4, /) -> fmat4x4: ... +@overload +def transpose(x: dmat2x2, /) -> dmat2x2: ... +@overload +def transpose(x: dmat2x3, /) -> dmat3x2: ... +@overload +def transpose(x: dmat2x4, /) -> dmat4x2: ... +@overload +def transpose(x: dmat3x2, /) -> dmat2x3: ... +@overload +def transpose(x: dmat3x3, /) -> dmat3x3: ... +@overload +def transpose(x: dmat3x4, /) -> dmat4x3: ... +@overload +def transpose(x: dmat4x2, /) -> dmat2x4: ... +@overload +def transpose(x: dmat4x3, /) -> dmat3x4: ... +@overload +def transpose(x: dmat4x4, /) -> dmat4x4: ... +@overload +def transpose(x: imat2x2, /) -> imat2x2: ... +@overload +def transpose(x: imat2x3, /) -> imat3x2: ... +@overload +def transpose(x: imat2x4, /) -> imat4x2: ... +@overload +def transpose(x: imat3x2, /) -> imat2x3: ... +@overload +def transpose(x: imat3x3, /) -> imat3x3: ... +@overload +def transpose(x: imat3x4, /) -> imat4x3: ... +@overload +def transpose(x: imat4x2, /) -> imat2x4: ... +@overload +def transpose(x: imat4x3, /) -> imat3x4: ... +@overload +def transpose(x: imat4x4, /) -> imat4x4: ... +@overload +def transpose(x: umat2x2, /) -> umat2x2: ... +@overload +def transpose(x: umat2x3, /) -> umat3x2: ... +@overload +def transpose(x: umat2x4, /) -> umat4x2: ... +@overload +def transpose(x: umat3x2, /) -> umat2x3: ... +@overload +def transpose(x: umat3x3, /) -> umat3x3: ... +@overload +def transpose(x: umat3x4, /) -> umat4x3: ... +@overload +def transpose(x: umat4x2, /) -> umat2x4: ... +@overload +def transpose(x: umat4x3, /) -> umat3x4: ... +@overload +def transpose(x: umat4x4, /) -> umat4x4: ... + + +def packDouble2x32(v: glm_typing.U32Vector2, /) -> float: ... + +def packHalf2x16(v: glm_typing.F32Vector2, /) -> int: ... + +def packSnorm2x16(v: glm_typing.F32Vector2, /) -> int: ... + +def packSnorm4x8(v: glm_typing.F32Vector4, /) -> int: ... + +def packUnorm2x16(v: glm_typing.F32Vector2, /) -> int: ... + +def packUnorm4x8(v: glm_typing.F32Vector4, /) -> int: ... + +def unpackDouble2x32(v: float, /) -> uvec2: ... + +def unpackHalf2x16(v: int, /) -> vec2: ... + +def unpackSnorm2x16(p: int, /) -> vec2: ... + +def unpackSnorm4x8(p: int, /) -> vec4: ... + +def unpackUnorm2x16(p: int, /) -> vec2: ... + +def unpackUnorm4x8(p: int, /) -> vec4: ... + + +@overload +def acos(x: glm_typing.Number, /) -> float: ... +@overload +def acos(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def acos(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def acos(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def acos(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def acos(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def acosh(x: glm_typing.Number, /) -> float: ... +@overload +def acosh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def acosh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def acosh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def acosh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def acosh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def asin(x: glm_typing.Number, /) -> float: ... +@overload +def asin(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def asin(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def asin(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def asin(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def asin(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def asinh(x: glm_typing.Number, /) -> float: ... +@overload +def asinh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def asinh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def asinh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def asinh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def asinh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def atan(y_over_x: glm_typing.Number, /) -> float: ... +@overload +def atan(y_over_x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def atan(y_over_x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def atan(y_over_x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def atan(y_over_x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def atan(y_over_x: _NF32DFVT, /) -> _NF32DFVT: ... +@overload +def atan(y: glm_typing.Number, x: glm_typing.Number, /) -> float: ... +@overload +def atan(y: glm_typing.F32Vector1, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def atan(y: glm_typing.F32Vector2, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def atan(y: glm_typing.F32Vector3, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def atan(y: glm_typing.F32Vector4, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def atan(y: _NF32DFVT, x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def atanh(x: glm_typing.Number, /) -> float: ... +@overload +def atanh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def atanh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def atanh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def atanh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def atanh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def cos(x: glm_typing.Number, /) -> float: ... +@overload +def cos(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def cos(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def cos(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def cos(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def cos(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def cosh(x: glm_typing.Number, /) -> float: ... +@overload +def cosh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def cosh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def cosh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def cosh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def cosh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def degrees(x: glm_typing.Number, /) -> float: ... +@overload +def degrees(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def degrees(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def degrees(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def degrees(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def degrees(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def radians(x: glm_typing.Number, /) -> float: ... +@overload +def radians(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def radians(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def radians(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def radians(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def radians(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def sin(x: glm_typing.Number, /) -> float: ... +@overload +def sin(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def sin(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def sin(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def sin(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def sin(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def sinh(x: glm_typing.Number, /) -> float: ... +@overload +def sinh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def sinh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def sinh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def sinh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def sinh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def tan(x: glm_typing.Number, /) -> float: ... +@overload +def tan(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def tan(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def tan(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def tan(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def tan(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def tanh(x: glm_typing.Number, /) -> float: ... +@overload +def tanh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def tanh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def tanh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def tanh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def tanh(x: _NF32DFVT, /) -> _NF32DFVT: ... + + + +def all(v: glm_typing.BAnyVectorAny, /) -> bool: ... + +def any(v: glm_typing.BAnyVectorAny, /) -> bool: ... + +@overload +def equal(x: glm_typing.Number, y: glm_typing.Number, ULPs: int, /) -> int: ... +@overload +def equal(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def equal(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def equal(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, ULPs_epsilon: Union[glm_typing.Number, ivec1, glm_typing.F32Vector1], /) -> bvec1: ... +@overload +def equal(x: _NF32V1T, y: _NF32V1T, ULPs_epsilon: Union[glm_typing.Number, ivec1, glm_typing.F32Vector1], /) -> bvec1: ... +@overload +def equal(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def equal(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def equal(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, ULPs_epsilon: Union[glm_typing.Number, ivec2, glm_typing.F32Vector2], /) -> bvec2: ... +@overload +def equal(x: _NF32V2T, y: _NF32V2T, ULPs_epsilon: Union[glm_typing.Number, ivec2, glm_typing.F32Vector2], /) -> bvec2: ... +@overload +def equal(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def equal(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def equal(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, ULPs_epsilon: Union[glm_typing.Number, ivec3, glm_typing.F32Vector3], /) -> bvec3: ... +@overload +def equal(x: _NF32V3T, y: _NF32V3T, ULPs_epsilon: Union[glm_typing.Number, ivec3, glm_typing.F32Vector3], /) -> bvec3: ... +@overload +def equal(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def equal(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... +@overload +def equal(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, ULPs_epsilon: Union[glm_typing.Number, ivec4, glm_typing.F32Vector4], /) -> bvec4: ... +@overload +def equal(x: _NF32V4T, y: _NF32V4T, ULPs_epsilon: Union[glm_typing.Number, ivec4, glm_typing.F32Vector4], /) -> bvec4: ... +@overload +def equal(x: glm_typing.F32Matrix2xAny, y: glm_typing.F32Matrix2xAny, /) -> bvec2: ... +@overload +def equal(x: _NF32M2XNT, y: _NF32M2XNT, /) -> bvec2: ... +@overload +def equal(x: glm_typing.F32Matrix2xAny, y: glm_typing.F32Matrix2xAny, ULPs_epsilon: Union[glm_typing.Number, ivec2, glm_typing.F32Vector2], /) -> bvec2: ... +@overload +def equal(x: _NF32M2XNT, y: _NF32M2XNT, ULPs_epsilon: Union[glm_typing.Number, ivec2, glm_typing.F32Vector2], /) -> bvec2: ... +@overload +def equal(x: glm_typing.F32Matrix3xAny, y: glm_typing.F32Matrix3xAny, /) -> bvec3: ... +@overload +def equal(x: _NF32M3XNT, y: _NF32M3XNT, /) -> bvec3: ... +@overload +def equal(x: glm_typing.F32Matrix3xAny, y: glm_typing.F32Matrix3xAny, ULPs_epsilon: Union[glm_typing.Number, ivec3, glm_typing.F32Vector3], /) -> bvec3: ... +@overload +def equal(x: _NF32M3XNT, y: _NF32M3XNT, ULPs_epsilon: Union[glm_typing.Number, ivec3, glm_typing.F32Vector3], /) -> bvec3: ... +@overload +def equal(x: glm_typing.F32Matrix4xAny, y: glm_typing.F32Matrix4xAny, /) -> bvec4: ... +@overload +def equal(x: _NF32M4XNT, y: _NF32M4XNT, /) -> bvec4: ... +@overload +def equal(x: glm_typing.F32Matrix4xAny, y: glm_typing.F32Matrix4xAny, ULPs_epsilon: Union[glm_typing.Number, ivec4, glm_typing.F32Vector4], /) -> bvec4: ... +@overload +def equal(x: _NF32M4XNT, y: _NF32M4XNT, ULPs_epsilon: Union[glm_typing.Number, ivec4, glm_typing.F32Vector4], /) -> bvec4: ... +@overload +def equal(x: _QT, y: _QT, /) -> int: ... + +@overload +def greaterThan(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def greaterThan(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def greaterThan(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def greaterThan(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def greaterThan(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def greaterThan(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def greaterThan(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def greaterThan(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def greaterThan(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +@overload +def greaterThanEqual(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def greaterThanEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def greaterThanEqual(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def greaterThanEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def greaterThanEqual(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def greaterThanEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def greaterThanEqual(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def greaterThanEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def greaterThanEqual(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +@overload +def lessThan(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def lessThan(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def lessThan(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def lessThan(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def lessThan(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def lessThan(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def lessThan(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def lessThan(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def lessThan(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +@overload +def lessThanEqual(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def lessThanEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def lessThanEqual(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def lessThanEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def lessThanEqual(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def lessThanEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def lessThanEqual(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def lessThanEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def lessThanEqual(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +@overload +def notEqual(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def notEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def notEqual(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def notEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def notEqual(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def notEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def notEqual(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def notEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def notEqual(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +def not_(v: glm_typing.BAnyVectorAny, /) -> bool: ... + + +def add(a: Any, b: Any, /) -> Any: ... + +def and_(a: Any, b: Any, /) -> Any: ... + +def cmp(a: Any, b: Any, /) -> Any: ... + +def div(a: Any, b: Any, /) -> Any: ... + +def floordiv(a: Any, b: Any, /) -> Any: ... + +def if_else(b: Any, x: Any, y: Any, /) -> Any: ... + +def inv(a: Any, /) -> Any: ... + +def lshift(a: Any, b: Any, /) -> Any: ... + +def mul(a: Any, b: Any, /) -> Any: ... + +def neg(a: Any, /) -> Any: ... + +def or_(a: Any, b: Any, /) -> Any: ... + +def pos(a: Any, /) -> Any: ... + +def rshift(a: Any, b: Any, /) -> Any: ... + +def sub(a: Any, b: Any, /) -> Any: ... + +def xor(a: Any, b: Any, /) -> Any: ... + + + +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector1) -> vec1: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector1, Gamma: glm_typing.Number) -> vec1: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector2) -> vec2: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector2, Gamma: glm_typing.Number) -> vec2: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector3) -> vec3: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector3, Gamma: glm_typing.Number) -> vec3: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector4) -> vec4: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector4, Gamma: glm_typing.Number) -> vec4: ... +@overload +def convertLinearToSRGB(ColorLinear: _NF32DFVT) -> _NF32DFVT: ... +@overload +def convertLinearToSRGB(ColorLinear: _NF32DFVT, Gamma: glm_typing.Number) -> _NF32DFVT: ... + +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector1) -> vec1: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector1, Gamma: glm_typing.Number) -> vec1: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector2) -> vec2: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector2, Gamma: glm_typing.Number) -> vec2: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector3) -> vec3: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector3, Gamma: glm_typing.Number) -> vec3: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector4) -> vec4: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector4, Gamma: glm_typing.Number) -> vec4: ... +@overload +def convertSRGBToLinear(ColorLinear: _NF32DFVT) -> _NF32DFVT: ... +@overload +def convertSRGBToLinear(ColorLinear: _NF32DFVT, Gamma: glm_typing.Number) -> _NF32DFVT: ... + + +def e() -> float: ... + +def epsilon() -> float: ... + +def euler() -> float: ... + +def four_over_pi() -> float: ... + +def golden_ratio() -> float: ... + +def half_pi() -> float: ... + +def ln_ln_two() -> float: ... + +def ln_ten() -> float: ... + +def ln_two() -> float: ... + +def one() -> float: ... + +def one_over_pi() -> float: ... + +def one_over_root_two() -> float: ... + +def one_over_two_pi() -> float: ... + +def pi() -> float: ... + +def quarter_pi() -> float: ... + +def root_five() -> float: ... + +def root_half_pi() -> float: ... + +def root_ln_four() -> float: ... + +def root_pi() -> float: ... + +def root_three() -> float: ... + +def root_two() -> float: ... + +def root_two_pi() -> float: ... + +def third() -> float: ... + +def three_over_two_pi() -> float: ... + +def two_over_pi() -> float: ... + +def two_over_root_pi() -> float: ... + +def two_pi() -> float: ... + +def two_thirds() -> float: ... + +def zero() -> float: ... + + +@overload +def epsilonEqual(x: glm_typing.Number, y: glm_typing.Number, epsilon: glm_typing.Number, /) -> bool: ... +@overload +def epsilonEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, epsilon: glm_typing.Number, /) -> bvec1: ... +@overload +def epsilonEqual(x: _NF32DFV1T, y: _NF32DFV1T, epsilon: glm_typing.Number, /) -> bvec1: ... +@overload +def epsilonEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, epsilon: glm_typing.Number, /) -> bvec2: ... +@overload +def epsilonEqual(x: _NF32DFV2T, y: _NF32DFV2T, epsilon: glm_typing.Number, /) -> bvec2: ... +@overload +def epsilonEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, epsilon: glm_typing.Number, /) -> bvec3: ... +@overload +def epsilonEqual(x: _NF32DFV3T, y: _NF32DFV3T, epsilon: glm_typing.Number, /) -> bvec3: ... +@overload +def epsilonEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, epsilon: glm_typing.Number, /) -> bvec4: ... +@overload +def epsilonEqual(x: _NF32DFV4T, y: _NF32DFV4T, epsilon: glm_typing.Number, /) -> bvec4: ... + +@overload +def epsilonNotEqual(x: glm_typing.Number, y: glm_typing.Number, epsilon: glm_typing.Number, /) -> bool: ... +@overload +def epsilonNotEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, epsilon: glm_typing.Number, /) -> bvec1: ... +@overload +def epsilonNotEqual(x: _NF32DFV1T, y: _NF32DFV1T, epsilon: glm_typing.Number, /) -> bvec1: ... +@overload +def epsilonNotEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, epsilon: glm_typing.Number, /) -> bvec2: ... +@overload +def epsilonNotEqual(x: _NF32DFV2T, y: _NF32DFV2T, epsilon: glm_typing.Number, /) -> bvec2: ... +@overload +def epsilonNotEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, epsilon: glm_typing.Number, /) -> bvec3: ... +@overload +def epsilonNotEqual(x: _NF32DFV3T, y: _NF32DFV3T, epsilon: glm_typing.Number, /) -> bvec3: ... +@overload +def epsilonNotEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, epsilon: glm_typing.Number, /) -> bvec4: ... +@overload +def epsilonNotEqual(x: _NF32DFV4T, y: _NF32DFV4T, epsilon: glm_typing.Number, /) -> bvec4: ... + + +@overload +def iround(x: glm_typing.Number, /) -> int: ... +@overload +def iround(x: glm_typing.F32Vector1, /) -> ivec1: ... +@overload +def iround(x: _NF32DFV1T, /) -> ivec1: ... +@overload +def iround(x: glm_typing.F32Vector2, /) -> ivec2: ... +@overload +def iround(x: _NF32DFV2T, /) -> ivec2: ... +@overload +def iround(x: glm_typing.F32Vector3, /) -> ivec3: ... +@overload +def iround(x: _NF32DFV3T, /) -> ivec3: ... +@overload +def iround(x: glm_typing.F32Vector4, /) -> ivec4: ... +@overload +def iround(x: _NF32DFV4T, /) -> ivec4: ... + +@overload +def uround(x: glm_typing.Number, /) -> int: ... +@overload +def uround(x: glm_typing.F32Vector1, /) -> uvec1: ... +@overload +def uround(x: _NF32DFV1T, /) -> uvec1: ... +@overload +def uround(x: glm_typing.F32Vector2, /) -> uvec2: ... +@overload +def uround(x: _NF32DFV2T, /) -> uvec2: ... +@overload +def uround(x: glm_typing.F32Vector3, /) -> uvec3: ... +@overload +def uround(x: _NF32DFV3T, /) -> uvec3: ... +@overload +def uround(x: glm_typing.F32Vector4, /) -> uvec4: ... +@overload +def uround(x: _NF32DFV4T, /) -> uvec4: ... + + + +@overload +def column(m: glm_typing.F32Matrix2x2, index: int, /) -> vec2: ... +@overload +def column(m: glm_typing.F32Matrix2x2, index: int, x: glm_typing.F32Vector2, /) -> mat2x2: ... +@overload +def column(m: glm_typing.F32Matrix2x3, index: int, /) -> vec3: ... +@overload +def column(m: glm_typing.F32Matrix2x3, index: int, x: glm_typing.F32Vector3, /) -> mat2x3: ... +@overload +def column(m: glm_typing.F32Matrix2x4, index: int, /) -> vec4: ... +@overload +def column(m: glm_typing.F32Matrix2x4, index: int, x: glm_typing.F32Vector4, /) -> mat2x4: ... +@overload +def column(m: glm_typing.F32Matrix3x2, index: int, /) -> vec2: ... +@overload +def column(m: glm_typing.F32Matrix3x2, index: int, x: glm_typing.F32Vector2, /) -> mat3x2: ... +@overload +def column(m: glm_typing.F32Matrix3x3, index: int, /) -> vec3: ... +@overload +def column(m: glm_typing.F32Matrix3x3, index: int, x: glm_typing.F32Vector3, /) -> mat3x3: ... +@overload +def column(m: glm_typing.F32Matrix3x4, index: int, /) -> vec4: ... +@overload +def column(m: glm_typing.F32Matrix3x4, index: int, x: glm_typing.F32Vector4, /) -> mat3x4: ... +@overload +def column(m: glm_typing.F32Matrix4x2, index: int, /) -> vec2: ... +@overload +def column(m: glm_typing.F32Matrix4x2, index: int, x: glm_typing.F32Vector2, /) -> mat4x2: ... +@overload +def column(m: glm_typing.F32Matrix4x3, index: int, /) -> vec3: ... +@overload +def column(m: glm_typing.F32Matrix4x3, index: int, x: glm_typing.F32Vector3, /) -> mat4x3: ... +@overload +def column(m: glm_typing.F32Matrix4x4, index: int, /) -> vec4: ... +@overload +def column(m: glm_typing.F32Matrix4x4, index: int, x: glm_typing.F32Vector4, /) -> mat4x4: ... +@overload +def column(m: dmat2x2, index: int, /) -> dvec2: ... +@overload +def column(m: dmat2x2, index: int, x: Union[dvec2, dmvec2], /) -> dmat2x2: ... +@overload +def column(m: dmat2x3, index: int, /) -> dvec3: ... +@overload +def column(m: dmat2x3, index: int, x: Union[dvec3, dmvec3], /) -> dmat2x3: ... +@overload +def column(m: dmat2x4, index: int, /) -> dvec4: ... +@overload +def column(m: dmat2x4, index: int, x: Union[dvec4, dmvec4], /) -> dmat2x4: ... +@overload +def column(m: dmat3x2, index: int, /) -> dvec2: ... +@overload +def column(m: dmat3x2, index: int, x: Union[dvec2, dmvec2], /) -> dmat3x2: ... +@overload +def column(m: dmat3x3, index: int, /) -> dvec3: ... +@overload +def column(m: dmat3x3, index: int, x: Union[dvec3, dmvec3], /) -> dmat3x3: ... +@overload +def column(m: dmat3x4, index: int, /) -> dvec4: ... +@overload +def column(m: dmat3x4, index: int, x: Union[dvec4, dmvec4], /) -> dmat3x4: ... +@overload +def column(m: dmat4x2, index: int, /) -> dvec2: ... +@overload +def column(m: dmat4x2, index: int, x: Union[dvec2, dmvec2], /) -> dmat4x2: ... +@overload +def column(m: dmat4x3, index: int, /) -> dvec3: ... +@overload +def column(m: dmat4x3, index: int, x: Union[dvec3, dmvec3], /) -> dmat4x3: ... +@overload +def column(m: dmat4x4, index: int, /) -> dvec4: ... +@overload +def column(m: dmat4x4, index: int, x: Union[dvec4, dmvec4], /) -> dmat4x4: ... +@overload +def column(m: imat2x2, index: int, /) -> ivec2: ... +@overload +def column(m: imat2x2, index: int, x: Union[ivec2, imvec2], /) -> imat2x2: ... +@overload +def column(m: imat2x3, index: int, /) -> ivec3: ... +@overload +def column(m: imat2x3, index: int, x: Union[ivec3, imvec3], /) -> imat2x3: ... +@overload +def column(m: imat2x4, index: int, /) -> ivec4: ... +@overload +def column(m: imat2x4, index: int, x: Union[ivec4, imvec4], /) -> imat2x4: ... +@overload +def column(m: imat3x2, index: int, /) -> ivec2: ... +@overload +def column(m: imat3x2, index: int, x: Union[ivec2, imvec2], /) -> imat3x2: ... +@overload +def column(m: imat3x3, index: int, /) -> ivec3: ... +@overload +def column(m: imat3x3, index: int, x: Union[ivec3, imvec3], /) -> imat3x3: ... +@overload +def column(m: imat3x4, index: int, /) -> ivec4: ... +@overload +def column(m: imat3x4, index: int, x: Union[ivec4, imvec4], /) -> imat3x4: ... +@overload +def column(m: imat4x2, index: int, /) -> ivec2: ... +@overload +def column(m: imat4x2, index: int, x: Union[ivec2, imvec2], /) -> imat4x2: ... +@overload +def column(m: imat4x3, index: int, /) -> ivec3: ... +@overload +def column(m: imat4x3, index: int, x: Union[ivec3, imvec3], /) -> imat4x3: ... +@overload +def column(m: imat4x4, index: int, /) -> ivec4: ... +@overload +def column(m: imat4x4, index: int, x: Union[ivec4, imvec4], /) -> imat4x4: ... +@overload +def column(m: umat2x2, index: int, /) -> uvec2: ... +@overload +def column(m: umat2x2, index: int, x: Union[uvec2, umvec2], /) -> umat2x2: ... +@overload +def column(m: umat2x3, index: int, /) -> uvec3: ... +@overload +def column(m: umat2x3, index: int, x: Union[uvec3, umvec3], /) -> umat2x3: ... +@overload +def column(m: umat2x4, index: int, /) -> uvec4: ... +@overload +def column(m: umat2x4, index: int, x: Union[uvec4, umvec4], /) -> umat2x4: ... +@overload +def column(m: umat3x2, index: int, /) -> uvec2: ... +@overload +def column(m: umat3x2, index: int, x: Union[uvec2, umvec2], /) -> umat3x2: ... +@overload +def column(m: umat3x3, index: int, /) -> uvec3: ... +@overload +def column(m: umat3x3, index: int, x: Union[uvec3, umvec3], /) -> umat3x3: ... +@overload +def column(m: umat3x4, index: int, /) -> uvec4: ... +@overload +def column(m: umat3x4, index: int, x: Union[uvec4, umvec4], /) -> umat3x4: ... +@overload +def column(m: umat4x2, index: int, /) -> uvec2: ... +@overload +def column(m: umat4x2, index: int, x: Union[uvec2, umvec2], /) -> umat4x2: ... +@overload +def column(m: umat4x3, index: int, /) -> uvec3: ... +@overload +def column(m: umat4x3, index: int, x: Union[uvec3, umvec3], /) -> umat4x3: ... +@overload +def column(m: umat4x4, index: int, /) -> uvec4: ... +@overload +def column(m: umat4x4, index: int, x: Union[uvec4, umvec4], /) -> umat4x4: ... + +@overload +def row(m: glm_typing.F32Matrix2x2, index: int, /) -> vec2: ... +@overload +def row(m: glm_typing.F32Matrix2x2, index: int, x: glm_typing.F32Vector2, /) -> mat2x2: ... +@overload +def row(m: glm_typing.F32Matrix2x3, index: int, /) -> vec2: ... +@overload +def row(m: glm_typing.F32Matrix2x3, index: int, x: glm_typing.F32Vector2, /) -> mat2x3: ... +@overload +def row(m: glm_typing.F32Matrix2x4, index: int, /) -> vec2: ... +@overload +def row(m: glm_typing.F32Matrix2x4, index: int, x: glm_typing.F32Vector2, /) -> mat2x4: ... +@overload +def row(m: glm_typing.F32Matrix3x2, index: int, /) -> vec3: ... +@overload +def row(m: glm_typing.F32Matrix3x2, index: int, x: glm_typing.F32Vector3, /) -> mat3x2: ... +@overload +def row(m: glm_typing.F32Matrix3x3, index: int, /) -> vec3: ... +@overload +def row(m: glm_typing.F32Matrix3x3, index: int, x: glm_typing.F32Vector3, /) -> mat3x3: ... +@overload +def row(m: glm_typing.F32Matrix3x4, index: int, /) -> vec3: ... +@overload +def row(m: glm_typing.F32Matrix3x4, index: int, x: glm_typing.F32Vector3, /) -> mat3x4: ... +@overload +def row(m: glm_typing.F32Matrix4x2, index: int, /) -> vec4: ... +@overload +def row(m: glm_typing.F32Matrix4x2, index: int, x: glm_typing.F32Vector4, /) -> mat4x2: ... +@overload +def row(m: glm_typing.F32Matrix4x3, index: int, /) -> vec4: ... +@overload +def row(m: glm_typing.F32Matrix4x3, index: int, x: glm_typing.F32Vector4, /) -> mat4x3: ... +@overload +def row(m: glm_typing.F32Matrix4x4, index: int, /) -> vec4: ... +@overload +def row(m: glm_typing.F32Matrix4x4, index: int, x: glm_typing.F32Vector4, /) -> mat4x4: ... +@overload +def row(m: dmat2x2, index: int, /) -> dvec2: ... +@overload +def row(m: dmat2x2, index: int, x: Union[dvec2, dmvec2], /) -> dmat2x2: ... +@overload +def row(m: dmat2x3, index: int, /) -> dvec2: ... +@overload +def row(m: dmat2x3, index: int, x: Union[dvec2, dmvec2], /) -> dmat2x3: ... +@overload +def row(m: dmat2x4, index: int, /) -> dvec2: ... +@overload +def row(m: dmat2x4, index: int, x: Union[dvec2, dmvec2], /) -> dmat2x4: ... +@overload +def row(m: dmat3x2, index: int, /) -> dvec3: ... +@overload +def row(m: dmat3x2, index: int, x: Union[dvec3, dmvec3], /) -> dmat3x2: ... +@overload +def row(m: dmat3x3, index: int, /) -> dvec3: ... +@overload +def row(m: dmat3x3, index: int, x: Union[dvec3, dmvec3], /) -> dmat3x3: ... +@overload +def row(m: dmat3x4, index: int, /) -> dvec3: ... +@overload +def row(m: dmat3x4, index: int, x: Union[dvec3, dmvec3], /) -> dmat3x4: ... +@overload +def row(m: dmat4x2, index: int, /) -> dvec4: ... +@overload +def row(m: dmat4x2, index: int, x: Union[dvec4, dmvec4], /) -> dmat4x2: ... +@overload +def row(m: dmat4x3, index: int, /) -> dvec4: ... +@overload +def row(m: dmat4x3, index: int, x: Union[dvec4, dmvec4], /) -> dmat4x3: ... +@overload +def row(m: dmat4x4, index: int, /) -> dvec4: ... +@overload +def row(m: dmat4x4, index: int, x: Union[dvec4, dmvec4], /) -> dmat4x4: ... +@overload +def row(m: imat2x2, index: int, /) -> ivec2: ... +@overload +def row(m: imat2x2, index: int, x: Union[ivec2, imvec2], /) -> imat2x2: ... +@overload +def row(m: imat2x3, index: int, /) -> ivec2: ... +@overload +def row(m: imat2x3, index: int, x: Union[ivec2, imvec2], /) -> imat2x3: ... +@overload +def row(m: imat2x4, index: int, /) -> ivec2: ... +@overload +def row(m: imat2x4, index: int, x: Union[ivec2, imvec2], /) -> imat2x4: ... +@overload +def row(m: imat3x2, index: int, /) -> ivec3: ... +@overload +def row(m: imat3x2, index: int, x: Union[ivec3, imvec3], /) -> imat3x2: ... +@overload +def row(m: imat3x3, index: int, /) -> ivec3: ... +@overload +def row(m: imat3x3, index: int, x: Union[ivec3, imvec3], /) -> imat3x3: ... +@overload +def row(m: imat3x4, index: int, /) -> ivec3: ... +@overload +def row(m: imat3x4, index: int, x: Union[ivec3, imvec3], /) -> imat3x4: ... +@overload +def row(m: imat4x2, index: int, /) -> ivec4: ... +@overload +def row(m: imat4x2, index: int, x: Union[ivec4, imvec4], /) -> imat4x2: ... +@overload +def row(m: imat4x3, index: int, /) -> ivec4: ... +@overload +def row(m: imat4x3, index: int, x: Union[ivec4, imvec4], /) -> imat4x3: ... +@overload +def row(m: imat4x4, index: int, /) -> ivec4: ... +@overload +def row(m: imat4x4, index: int, x: Union[ivec4, imvec4], /) -> imat4x4: ... +@overload +def row(m: umat2x2, index: int, /) -> uvec2: ... +@overload +def row(m: umat2x2, index: int, x: Union[uvec2, umvec2], /) -> umat2x2: ... +@overload +def row(m: umat2x3, index: int, /) -> uvec2: ... +@overload +def row(m: umat2x3, index: int, x: Union[uvec2, umvec2], /) -> umat2x3: ... +@overload +def row(m: umat2x4, index: int, /) -> uvec2: ... +@overload +def row(m: umat2x4, index: int, x: Union[uvec2, umvec2], /) -> umat2x4: ... +@overload +def row(m: umat3x2, index: int, /) -> uvec3: ... +@overload +def row(m: umat3x2, index: int, x: Union[uvec3, umvec3], /) -> umat3x2: ... +@overload +def row(m: umat3x3, index: int, /) -> uvec3: ... +@overload +def row(m: umat3x3, index: int, x: Union[uvec3, umvec3], /) -> umat3x3: ... +@overload +def row(m: umat3x4, index: int, /) -> uvec3: ... +@overload +def row(m: umat3x4, index: int, x: Union[uvec3, umvec3], /) -> umat3x4: ... +@overload +def row(m: umat4x2, index: int, /) -> uvec4: ... +@overload +def row(m: umat4x2, index: int, x: Union[uvec4, umvec4], /) -> umat4x2: ... +@overload +def row(m: umat4x3, index: int, /) -> uvec4: ... +@overload +def row(m: umat4x3, index: int, x: Union[uvec4, umvec4], /) -> umat4x3: ... +@overload +def row(m: umat4x4, index: int, /) -> uvec4: ... +@overload +def row(m: umat4x4, index: int, x: Union[uvec4, umvec4], /) -> umat4x4: ... + + +@overload +def affineInverse(m: glm_typing.FAnyMatrix3x3, /) -> mat3x3: ... +@overload +def affineInverse(m: dmat3x3, /) -> dmat3x3: ... +@overload +def affineInverse(m: glm_typing.FAnyMatrix4x4, /) -> mat4x4: ... +@overload +def affineInverse(m: dmat4x4, /) -> dmat4x4: ... + +@overload +def inverseTranspose(m: glm_typing.FAnyMatrix2x2, /) -> mat2x2: ... +@overload +def inverseTranspose(m: dmat2x2, /) -> dmat2x2: ... +@overload +def inverseTranspose(m: glm_typing.FAnyMatrix3x3, /) -> mat3x3: ... +@overload +def inverseTranspose(m: dmat3x3, /) -> dmat3x3: ... +@overload +def inverseTranspose(m: glm_typing.FAnyMatrix4x4, /) -> mat4x4: ... +@overload +def inverseTranspose(m: dmat4x4, /) -> dmat4x4: ... + + +@overload +def perlin(p: glm_typing.FDAnyVectorAny, /) -> float: ... +@overload +def perlin(p: glm_typing.F32Vector1, rep: glm_typing.F32Vector1, /) -> float: ... +@overload +def perlin(p: glm_typing.F32Vector2, rep: glm_typing.F32Vector2, /) -> float: ... +@overload +def perlin(p: glm_typing.F32Vector3, rep: glm_typing.F32Vector3, /) -> float: ... +@overload +def perlin(p: glm_typing.F32Vector4, rep: glm_typing.F32Vector4, /) -> float: ... +@overload +def perlin(p: _NF32DFVT, rep: _NF32DFVT, /) -> float: ... + +def simplex(p: glm_typing.FDAnyVectorAny, /) -> float: ... + + +def packF2x11_1x10(v: glm_typing.F32Vector3, /) -> int: ... + +def packF3x9_E1x5(v: glm_typing.F32Vector3, /) -> int: ... + +@overload +def packHalf(v: glm_typing.F32Vector1, /) -> u16vec1: ... +@overload +def packHalf(v: glm_typing.F32Vector2, /) -> u16vec2: ... +@overload +def packHalf(v: glm_typing.F32Vector3, /) -> u16vec3: ... +@overload +def packHalf(v: glm_typing.F32Vector4, /) -> u16vec4: ... + +def packHalf1x16(v: float, /) -> int: ... + +def packHalf4x16(v: glm_typing.F32Vector4, /) -> int: ... + +def packI3x10_1x2(v: glm_typing.I32Vector4, /) -> int: ... + +def packInt2x16(v: glm_typing.I16Vector2, /) -> int: ... + +def packInt2x32(v: glm_typing.I32Vector2, /) -> int: ... + +def packInt2x8(v: glm_typing.I8Vector2, /) -> int: ... + +def packInt4x16(v: glm_typing.I16Vector4, /) -> int: ... + +def packInt4x8(v: glm_typing.I8Vector4, /) -> int: ... + +def packRGBM(v: glm_typing.F32Vector3, /) -> vec4: ... + +@overload +def packSnorm(t: ctypes.c_int8, v: glm_typing.F32Vector1, /) -> i8vec1: ... +@overload +def packSnorm(t: ctypes.c_int8, v: _NF32DFV1T, /) -> i8vec1: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector1, /) -> u8vec1: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: _NF32DFV1T, /) -> u8vec1: ... +@overload +def packSnorm(t: ctypes.c_int16, v: glm_typing.F32Vector1, /) -> i16vec1: ... +@overload +def packSnorm(t: ctypes.c_int16, v: _NF32DFV1T, /) -> i16vec1: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector1, /) -> u16vec1: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: _NF32DFV1T, /) -> u16vec1: ... +@overload +def packSnorm(t: ctypes.c_int32, v: glm_typing.F32Vector1, /) -> i32vec1: ... +@overload +def packSnorm(t: ctypes.c_int32, v: _NF32DFV1T, /) -> i32vec1: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector1, /) -> u32vec1: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: _NF32DFV1T, /) -> u32vec1: ... +@overload +def packSnorm(t: ctypes.c_int64, v: glm_typing.F32Vector1, /) -> i64vec1: ... +@overload +def packSnorm(t: ctypes.c_int64, v: _NF32DFV1T, /) -> i64vec1: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector1, /) -> u64vec1: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: _NF32DFV1T, /) -> u64vec1: ... +@overload +def packSnorm(t: ctypes.c_int8, v: glm_typing.F32Vector2, /) -> i8vec2: ... +@overload +def packSnorm(t: ctypes.c_int8, v: _NF32DFV2T, /) -> i8vec2: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector2, /) -> u8vec2: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: _NF32DFV2T, /) -> u8vec2: ... +@overload +def packSnorm(t: ctypes.c_int16, v: glm_typing.F32Vector2, /) -> i16vec2: ... +@overload +def packSnorm(t: ctypes.c_int16, v: _NF32DFV2T, /) -> i16vec2: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector2, /) -> u16vec2: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: _NF32DFV2T, /) -> u16vec2: ... +@overload +def packSnorm(t: ctypes.c_int32, v: glm_typing.F32Vector2, /) -> i32vec2: ... +@overload +def packSnorm(t: ctypes.c_int32, v: _NF32DFV2T, /) -> i32vec2: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector2, /) -> u32vec2: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: _NF32DFV2T, /) -> u32vec2: ... +@overload +def packSnorm(t: ctypes.c_int64, v: glm_typing.F32Vector2, /) -> i64vec2: ... +@overload +def packSnorm(t: ctypes.c_int64, v: _NF32DFV2T, /) -> i64vec2: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector2, /) -> u64vec2: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: _NF32DFV2T, /) -> u64vec2: ... +@overload +def packSnorm(t: ctypes.c_int8, v: glm_typing.F32Vector3, /) -> i8vec3: ... +@overload +def packSnorm(t: ctypes.c_int8, v: _NF32DFV3T, /) -> i8vec3: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector3, /) -> u8vec3: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: _NF32DFV3T, /) -> u8vec3: ... +@overload +def packSnorm(t: ctypes.c_int16, v: glm_typing.F32Vector3, /) -> i16vec3: ... +@overload +def packSnorm(t: ctypes.c_int16, v: _NF32DFV3T, /) -> i16vec3: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector3, /) -> u16vec3: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: _NF32DFV3T, /) -> u16vec3: ... +@overload +def packSnorm(t: ctypes.c_int32, v: glm_typing.F32Vector3, /) -> i32vec3: ... +@overload +def packSnorm(t: ctypes.c_int32, v: _NF32DFV3T, /) -> i32vec3: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector3, /) -> u32vec3: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: _NF32DFV3T, /) -> u32vec3: ... +@overload +def packSnorm(t: ctypes.c_int64, v: glm_typing.F32Vector3, /) -> i64vec3: ... +@overload +def packSnorm(t: ctypes.c_int64, v: _NF32DFV3T, /) -> i64vec3: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector3, /) -> u64vec3: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: _NF32DFV3T, /) -> u64vec3: ... +@overload +def packSnorm(t: ctypes.c_int8, v: glm_typing.F32Vector4, /) -> i8vec4: ... +@overload +def packSnorm(t: ctypes.c_int8, v: _NF32DFV4T, /) -> i8vec4: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector4, /) -> u8vec4: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: _NF32DFV4T, /) -> u8vec4: ... +@overload +def packSnorm(t: ctypes.c_int16, v: glm_typing.F32Vector4, /) -> i16vec4: ... +@overload +def packSnorm(t: ctypes.c_int16, v: _NF32DFV4T, /) -> i16vec4: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector4, /) -> u16vec4: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: _NF32DFV4T, /) -> u16vec4: ... +@overload +def packSnorm(t: ctypes.c_int32, v: glm_typing.F32Vector4, /) -> i32vec4: ... +@overload +def packSnorm(t: ctypes.c_int32, v: _NF32DFV4T, /) -> i32vec4: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector4, /) -> u32vec4: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: _NF32DFV4T, /) -> u32vec4: ... +@overload +def packSnorm(t: ctypes.c_int64, v: glm_typing.F32Vector4, /) -> i64vec4: ... +@overload +def packSnorm(t: ctypes.c_int64, v: _NF32DFV4T, /) -> i64vec4: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector4, /) -> u64vec4: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: _NF32DFV4T, /) -> u64vec4: ... + +def packSnorm1x16(v: float, /) -> int: ... + +def packSnorm1x8(v: float, /) -> int: ... + +def packSnorm2x8(v: glm_typing.F32Vector2, /) -> int: ... + +def packSnorm3x10_1x2(v: glm_typing.F32Vector4, /) -> int: ... + +def packSnorm4x16(v: glm_typing.F32Vector4, /) -> int: ... + +def packU3x10_1x2(v: glm_typing.U32Vector4, /) -> int: ... + +def packUint2x16(v: glm_typing.U16Vector2, /) -> int: ... + +def packUint2x32(v: glm_typing.U32Vector2, /) -> int: ... + +def packUint2x8(v: glm_typing.U8Vector2, /) -> int: ... + +def packUint4x16(v: glm_typing.U16Vector4, /) -> int: ... + +def packUint4x8(v: glm_typing.U16Vector4, /) -> int: ... + +@overload +def packUnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector1, /) -> u8vec1: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: _NF32DFV1T, /) -> u8vec1: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector1, /) -> u16vec1: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: _NF32DFV1T, /) -> u16vec1: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector1, /) -> u32vec1: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: _NF32DFV1T, /) -> u32vec1: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector1, /) -> u64vec1: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: _NF32DFV1T, /) -> u64vec1: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector2, /) -> u8vec2: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: _NF32DFV2T, /) -> u8vec2: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector2, /) -> u16vec2: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: _NF32DFV2T, /) -> u16vec2: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector2, /) -> u32vec2: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: _NF32DFV2T, /) -> u32vec2: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector2, /) -> u64vec2: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: _NF32DFV2T, /) -> u64vec2: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector3, /) -> u8vec3: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: _NF32DFV3T, /) -> u8vec3: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector3, /) -> u16vec3: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: _NF32DFV3T, /) -> u16vec3: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector3, /) -> u32vec3: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: _NF32DFV3T, /) -> u32vec3: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector3, /) -> u64vec3: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: _NF32DFV3T, /) -> u64vec3: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector4, /) -> u8vec4: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: _NF32DFV4T, /) -> u8vec4: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector4, /) -> u16vec4: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: _NF32DFV4T, /) -> u16vec4: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector4, /) -> u32vec4: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: _NF32DFV4T, /) -> u32vec4: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector4, /) -> u64vec4: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: _NF32DFV4T, /) -> u64vec4: ... + +def packUnorm1x16(v: float, /) -> int: ... + +def packUnorm1x5_1x6_1x5(v: glm_typing.F32Vector3, /) -> int: ... + +def packUnorm2x4(v: glm_typing.F32Vector2, /) -> int: ... + +def packUnorm2x8(v: glm_typing.F32Vector2, /) -> int: ... + +def packUnorm3x10_1x2(v: glm_typing.F32Vector4, /) -> int: ... + +def packUnorm4x16(v: glm_typing.F32Vector4, /) -> int: ... + +def packUnorm4x4(v: glm_typing.F32Vector4, /) -> int: ... + +def unpackF2x11_1x10(p: int, /) -> vec3: ... + +def unpackF3x9_E1x5(p: int, /) -> vec3: ... + +@overload +def unpackHalf(v: glm_typing.U16Vector1, /) -> vec1: ... +@overload +def unpackHalf(v: glm_typing.U16Vector2, /) -> vec2: ... +@overload +def unpackHalf(v: glm_typing.U16Vector3, /) -> vec3: ... +@overload +def unpackHalf(v: glm_typing.U16Vector4, /) -> vec4: ... + +def unpackHalf1x16(p: int, /) -> float: ... + +def unpackI3x10_1x2(p: int, /) -> ivec4: ... + +def unpackInt2x16(p: int, /) -> i16vec2: ... + +def unpackInt2x32(p: int, /) -> i32vec2: ... + +def unpackInt2x8(p: int, /) -> i8vec2: ... + +def unpackInt4x16(p: int, /) -> i16vec4: ... + +def unpackInt4x8(p: int, /) -> i8vec4: ... + +def unpackRGBM(p: glm_typing.F32Vector4, /) -> vec3: ... + +@overload +def unpackSnorm(t: ctypes.c_float, v: glm_typing.I32Vector1, /) -> vec1: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: _NI32IUV1T, /) -> vec1: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: glm_typing.I32Vector1, /) -> dvec1: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: _NI32IUV1T, /) -> dvec1: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: _NI32IUV2T, /) -> vec2: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: glm_typing.I32Vector2, /) -> dvec2: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: _NI32IUV2T, /) -> dvec2: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: _NI32IUV3T, /) -> vec3: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: glm_typing.I32Vector3, /) -> dvec3: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: _NI32IUV3T, /) -> dvec3: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: _NI32IUV4T, /) -> vec4: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: glm_typing.I32Vector4, /) -> dvec4: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: _NI32IUV4T, /) -> dvec4: ... + +def unpackSnorm1x16(p: int, /) -> float: ... + +def unpackSnorm1x8(p: int, /) -> float: ... + +def unpackSnorm2x8(p: int, /) -> vec2: ... + +def unpackSnorm3x10_1x2(p: int, /) -> vec4: ... + +def unpackSnorm4x16(p: int, /) -> vec4: ... + +def unpackU3x10_1x2(p: int, /) -> uvec4: ... + +def unpackUint2x16(p: int, /) -> u16vec2: ... + +def unpackUint2x32(p: int, /) -> u32vec2: ... + +def unpackUint2x8(p: int, /) -> u8vec2: ... + +def unpackUint4x16(p: int, /) -> u16vec4: ... + +def unpackUint4x8(p: int, /) -> u8vec4: ... + +@overload +def unpackUnorm(t: ctypes.c_float, v: glm_typing.I32Vector1, /) -> vec1: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: _NI32IUV1T, /) -> vec1: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: glm_typing.I32Vector1, /) -> dvec1: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: _NI32IUV1T, /) -> dvec1: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: _NI32IUV2T, /) -> vec2: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: glm_typing.I32Vector2, /) -> dvec2: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: _NI32IUV2T, /) -> dvec2: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: _NI32IUV3T, /) -> vec3: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: glm_typing.I32Vector3, /) -> dvec3: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: _NI32IUV3T, /) -> dvec3: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: _NI32IUV4T, /) -> vec4: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: glm_typing.I32Vector4, /) -> dvec4: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: _NI32IUV4T, /) -> dvec4: ... + +def unpackUnorm1x16(p: int, /) -> float: ... + +def unpackUnorm1x5_1x6_1x5(p: int, /) -> vec3: ... + +def unpackUnorm1x8(p: int, /) -> float: ... + +def unpackUnorm2x3_1x2(p: int, /) -> vec3: ... + +def unpackUnorm2x4(p: int, /) -> vec2: ... + +def unpackUnorm2x8(p: int, /) -> vec2: ... + +def unpackUnorm3x10_1x2(p: int, /) -> vec4: ... + +def unpackUnorm3x5_1x1(p: int, /) -> vec4: ... + +def unpackUnorm4x16(p: int, /) -> vec4: ... + +def unpackUnorm4x4(p: int, /) -> vec4: ... + + +@overload +def eulerAngles(x: glm_typing.F32Quaternion, /) -> vec3: ... +@overload +def eulerAngles(x: dquat, /) -> dvec3: ... + +@overload +def mat3_cast(x: glm_typing.F32Quaternion, /) -> mat3: ... +@overload +def mat3_cast(x: dquat, /) -> dmat3: ... + +@overload +def mat4_cast(x: glm_typing.F32Quaternion, /) -> mat4: ... +@overload +def mat4_cast(x: dquat, /) -> dmat4: ... + +def pitch(x: glm_typing.AnyAnyQuaternion, /) -> float: ... + +@overload +def quatLookAtLH(direction: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> quat: ... +@overload +def quatLookAtLH(direction: dvec3, up: dvec3, /) -> dquat: ... + +@overload +def quatLookAtRH(direction: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> quat: ... +@overload +def quatLookAtRH(direction: dvec3, up: dvec3, /) -> dquat: ... + +@overload +def quatLookAt(direction: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> quat: ... +@overload +def quatLookAt(direction: dvec3, up: dvec3, /) -> dquat: ... + +@overload +def quat_cast(x: Union[glm_typing.F32Matrix3x3, glm_typing.F32Matrix4x4], /) -> quat: ... +@overload +def quat_cast(x: Union[dmat3, dmat4], /) -> quat: ... + +def roll(x: glm_typing.AnyAnyQuaternion, /) -> float: ... + +def yaw(x: glm_typing.AnyAnyQuaternion, /) -> float: ... + + +def ballRand(Radius: glm_typing.Number, /) -> vec3: ... + +def circularRand(Radius: glm_typing.Number, /) -> vec2: ... + +def diskRand(Radius: glm_typing.Number, /) -> vec2: ... + +@overload +def gaussRand(Mean: glm_typing.Number, Deviation: glm_typing.Number, /) -> float: ... +@overload +def gaussRand(Mean: glm_typing.F32Vector1, Deviation: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def gaussRand(Mean: glm_typing.F32Vector2, Deviation: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def gaussRand(Mean: glm_typing.F32Vector3, Deviation: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def gaussRand(Mean: glm_typing.F32Vector4, Deviation: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def gaussRand(Mean: _NF32VT, Deviation: _NF32VT, /) -> _NF32VT: ... + +@overload +def linearRand(Min: glm_typing.Number, Max: glm_typing.Number, /) -> float: ... +@overload +def linearRand(Min: glm_typing.F32Vector1, Max: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def linearRand(Min: glm_typing.F32Vector2, Max: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def linearRand(Min: glm_typing.F32Vector3, Max: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def linearRand(Min: glm_typing.F32Vector4, Max: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def linearRand(Min: _NF32VT, Max: _NF32VT, /) -> _NF32VT: ... + +def setSeed(seed: SupportsInt, /) -> None: ... + +def sphericalRand(Radius: glm_typing.Number, /) -> vec3: ... + + +def acot(x: glm_typing.Number, /) -> float: ... + +def acoth(x: glm_typing.Number, /) -> float: ... + +def acsc(x: glm_typing.Number, /) -> float: ... + +def acsch(x: glm_typing.Number, /) -> float: ... + +def asec(x: glm_typing.Number, /) -> float: ... + +def asech(x: glm_typing.Number, /) -> float: ... + +def cot(x: glm_typing.Number, /) -> float: ... + +def coth(x: glm_typing.Number, /) -> float: ... + +def csc(x: glm_typing.Number, /) -> float: ... + +def csch(x: glm_typing.Number, /) -> float: ... + +def sec(x: glm_typing.Number, /) -> float: ... + +def sech(x: glm_typing.Number, /) -> float: ... + + +@overload +def ceilMultiple(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def ceilMultiple(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def ceilMultiple(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def ceilMultiple(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def ceilMultiple(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def ceilMultiple(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def ceilPowerOfTwo(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def ceilPowerOfTwo(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def ceilPowerOfTwo(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def ceilPowerOfTwo(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def ceilPowerOfTwo(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def ceilPowerOfTwo(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def floorMultiple(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def floorMultiple(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def floorMultiple(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def floorMultiple(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def floorMultiple(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def floorMultiple(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def floorPowerOfTwo(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def floorPowerOfTwo(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def floorPowerOfTwo(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def floorPowerOfTwo(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def floorPowerOfTwo(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def floorPowerOfTwo(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def roundMultiple(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def roundMultiple(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def roundMultiple(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def roundMultiple(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def roundMultiple(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def roundMultiple(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def roundPowerOfTwo(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def roundPowerOfTwo(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def roundPowerOfTwo(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def roundPowerOfTwo(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def roundPowerOfTwo(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def roundPowerOfTwo(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + + +def make_mat2(x: ctypes.pointer[Any], /) -> mat2x2: ... + +def make_mat3(x: ctypes.pointer[Any], /) -> mat3x3: ... + +def make_mat4(x: ctypes.pointer[Any], /) -> mat4x4: ... + +def make_mat2x2(x: ctypes.pointer[Any], /) -> mat2x2: ... + +def make_mat2x3(x: ctypes.pointer[Any], /) -> mat2x3: ... + +def make_mat2x4(x: ctypes.pointer[Any], /) -> mat2x4: ... + +def make_mat3x2(x: ctypes.pointer[Any], /) -> mat3x2: ... + +def make_mat3x3(x: ctypes.pointer[Any], /) -> mat3x3: ... + +def make_mat3x4(x: ctypes.pointer[Any], /) -> mat3x4: ... + +def make_mat4x2(x: ctypes.pointer[Any], /) -> mat4x2: ... + +def make_mat4x3(x: ctypes.pointer[Any], /) -> mat4x3: ... + +def make_mat4x4(x: ctypes.pointer[Any], /) -> mat4x4: ... + +def make_quat(x: ctypes.pointer[Any], /) -> quat: ... + +def make_vec2(x: ctypes.pointer[Any], /) -> vec2: ... + +def make_vec3(x: ctypes.pointer[Any], /) -> vec3: ... + +def make_vec4(x: ctypes.pointer[Any], /) -> vec4: ... + +@overload +def sizeof(x: Type[Union[ctypes.c_bool, ctypes.c_short, ctypes.c_long, ctypes.c_longlong, ctypes.c_byte, ctypes.c_ushort, ctypes.c_ulong, ctypes.c_ulonglong, ctypes.c_ubyte, ctypes.c_double, ctypes.c_float, glm_typing.AnyAnyVecAny, glm_typing.AnyAnyMatAnyxAny, glm_typing.AnyAnyQuat]], /) -> int: ... +@overload +def sizeof(x: Union[ctypes.c_bool, ctypes.c_short, ctypes.c_long, ctypes.c_longlong, ctypes.c_byte, ctypes.c_ushort, ctypes.c_ulong, ctypes.c_ulonglong, ctypes.c_ubyte, ctypes.c_double, ctypes.c_float, array[Any], glm_typing.AnyAnyVecAny, glm_typing.AnyAnyMatAnyxAny, glm_typing.AnyAnyQuat], /) -> int: ... + +@overload +def value_ptr(x: Union[glm_typing.F32VecAny, glm_typing.F32MatAnyxAny, glm_typing.F32Quat], /) -> ctypes.pointer[ctypes.c_float]: ... +@overload +def value_ptr(x: Union[glm_typing.D64VecAny, glm_typing.D64MatAnyxAny, glm_typing.D64Quat], /) -> ctypes.pointer[ctypes.c_double]: ... +@overload +def value_ptr(x: Union[glm_typing.I32VecAny, glm_typing.I32MatAnyxAny], /) -> ctypes.pointer[ctypes.c_int32]: ... +@overload +def value_ptr(x: Union[glm_typing.U32VecAny, glm_typing.U32MatAnyxAny], /) -> ctypes.pointer[ctypes.c_uint32]: ... +@overload +def value_ptr(x: glm_typing.I8VecAny, /) -> ctypes.pointer[ctypes.c_int8]: ... +@overload +def value_ptr(x: glm_typing.U8VecAny, /) -> ctypes.pointer[ctypes.c_uint8]: ... +@overload +def value_ptr(x: glm_typing.B8VecAny, /) -> ctypes.pointer[ctypes.c_bool]: ... +@overload +def value_ptr(x: glm_typing.I16VecAny, /) -> ctypes.pointer[ctypes.c_int16]: ... +@overload +def value_ptr(x: glm_typing.U16VecAny, /) -> ctypes.pointer[ctypes.c_uint16]: ... +@overload +def value_ptr(x: glm_typing.I64VecAny, /) -> ctypes.pointer[ctypes.c_int64]: ... +@overload +def value_ptr(x: glm_typing.U64VecAny, /) -> ctypes.pointer[ctypes.c_uint64]: ... + + +@overload +def float_distance(x: glm_typing.Number, y: glm_typing.Number) -> float: ... +@overload +def float_distance(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> ivec1: ... +@overload +def float_distance(x: dvec1, y: dvec1, /) -> i64vec1: ... +@overload +def float_distance(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> ivec2: ... +@overload +def float_distance(x: dvec2, y: dvec2, /) -> i64vec2: ... +@overload +def float_distance(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> ivec3: ... +@overload +def float_distance(x: dvec3, y: dvec3, /) -> i64vec3: ... +@overload +def float_distance(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> ivec4: ... +@overload +def float_distance(x: dvec4, y: dvec4, /) -> i64vec4: ... + +@overload +def next_float(x: glm_typing.Number, /) -> float: ... +@overload +def next_float(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def next_float(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def next_float(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def next_float(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def next_float(x: _NF32DFVT, /) -> _NF32DFVT: ... +@overload +def next_float(x: glm_typing.Number, ULPs: glm_typing.Number, /) -> float: ... +@overload +def next_float(x: glm_typing.F32Vector1, ULPs: glm_typing.Number, /) -> vec1: ... +@overload +def next_float(x: glm_typing.F32Vector2, ULPs: glm_typing.Number, /) -> vec2: ... +@overload +def next_float(x: glm_typing.F32Vector3, ULPs: glm_typing.Number, /) -> vec3: ... +@overload +def next_float(x: glm_typing.F32Vector4, ULPs: glm_typing.Number, /) -> vec4: ... +@overload +def next_float(x: _NF32DFVT, ULPs: glm_typing.Number, /) -> _NF32DFVT: ... +@overload +def next_float(x: glm_typing.F32Vector1, ULPs: glm_typing.I32Vector1, /) -> vec1: ... +@overload +def next_float(x: _NF32DFV1T, ULPs: glm_typing.I32Vector1, /) -> _NF32DFV1T: ... +@overload +def next_float(x: glm_typing.F32Vector2, ULPs: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def next_float(x: _NF32DFV2T, ULPs: glm_typing.I32Vector2, /) -> _NF32DFV2T: ... +@overload +def next_float(x: glm_typing.F32Vector3, ULPs: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def next_float(x: _NF32DFV3T, ULPs: glm_typing.I32Vector3, /) -> _NF32DFV3T: ... +@overload +def next_float(x: glm_typing.F32Vector4, ULPs: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def next_float(x: _NF32DFV4T, ULPs: glm_typing.I32Vector4, /) -> _NF32DFV4T: ... + +@overload +def prev_float(x: glm_typing.Number, /) -> float: ... +@overload +def prev_float(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def prev_float(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def prev_float(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def prev_float(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def prev_float(x: _NF32DFVT, /) -> _NF32DFVT: ... +@overload +def prev_float(x: glm_typing.Number, ULPs: glm_typing.Number, /) -> float: ... +@overload +def prev_float(x: glm_typing.F32Vector1, ULPs: glm_typing.Number, /) -> vec1: ... +@overload +def prev_float(x: glm_typing.F32Vector2, ULPs: glm_typing.Number, /) -> vec2: ... +@overload +def prev_float(x: glm_typing.F32Vector3, ULPs: glm_typing.Number, /) -> vec3: ... +@overload +def prev_float(x: glm_typing.F32Vector4, ULPs: glm_typing.Number, /) -> vec4: ... +@overload +def prev_float(x: _NF32DFVT, ULPs: glm_typing.Number, /) -> _NF32DFVT: ... +@overload +def prev_float(x: glm_typing.F32Vector1, ULPs: glm_typing.I32Vector1, /) -> vec1: ... +@overload +def prev_float(x: _NF32DFV1T, ULPs: glm_typing.I32Vector1, /) -> _NF32DFV1T: ... +@overload +def prev_float(x: glm_typing.F32Vector2, ULPs: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def prev_float(x: _NF32DFV2T, ULPs: glm_typing.I32Vector2, /) -> _NF32DFV2T: ... +@overload +def prev_float(x: glm_typing.F32Vector3, ULPs: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def prev_float(x: _NF32DFV3T, ULPs: glm_typing.I32Vector3, /) -> _NF32DFV3T: ... +@overload +def prev_float(x: glm_typing.F32Vector4, ULPs: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def prev_float(x: _NF32DFV4T, ULPs: glm_typing.I32Vector4, /) -> _NF32DFV4T: ... + + +def frustumLH_NO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumLH_ZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumRH_NO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumRH_ZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustum(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumNO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumRH(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumLH(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def infinitePerspectiveLH(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, /) -> mat4x4: ... + +def infinitePerspectiveRH(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, /) -> mat4x4: ... + +def infinitePerspective(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, /) -> mat4x4: ... + +def orthoLH_NO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoLH_ZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoRH_NO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoRH_ZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def ortho(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoLH(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoNO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoRH(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveLH_NO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveLH_ZO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveRH_NO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveRH_ZO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspective(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveLH(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveNO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveRH(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveZO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovLH_NO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovLH_ZO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovRH_NO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovRH_ZO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFov(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovLH(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovNO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovRH(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovZO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +@overload +def tweakedInfinitePerspective(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, /) -> mat4x4: ... +@overload +def tweakedInfinitePerspective(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, epsilon: float, /) -> mat4x4: ... + + +@overload +def pickMatrix(center: glm_typing.F32Vector2, delta: glm_typing.F32Vector2, viewport: glm_typing.F32Vector4, /) -> mat4x4: ... +@overload +def pickMatrix(center: dvec2, delta: dvec2, viewport: dvec4, /) -> dmat4x4: ... + +@overload +def projectNO(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def projectNO(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def project(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def project(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def projectZO(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def projectZO(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def unProjectNO(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def unProjectNO(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def unProject(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def unProject(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def unProjectZO(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def unProjectZO(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + + +def identity(matrix_type: Type[_MT], /) -> _MT: ... + +@overload +def lookAtLH(eye: glm_typing.F32Vector3, center: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def lookAtLH(eye: dvec3, center: dvec3, up: dvec3, /) -> dmat4x4: ... + +@overload +def lookAtRH(eye: glm_typing.F32Vector3, center: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def lookAtRH(eye: dvec3, center: dvec3, up: dvec3, /) -> dmat4x4: ... + +@overload +def lookAt(eye: glm_typing.F32Vector3, center: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def lookAt(eye: dvec3, center: dvec3, up: dvec3, /) -> dmat4x4: ... + +@overload +def rotate(angle: glm_typing.Number, axis: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def rotate(angle: glm_typing.Number, axis: dvec3, /) -> dmat4x4: ... +@overload +def rotate(angle: glm_typing.Number, /) -> mat3x3: ... +@overload +def rotate(m: glm_typing.F32Matrix4x4, angle: glm_typing.Number, axis: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def rotate(m: dmat4x4, angle: glm_typing.Number, axis: dvec3, /) -> dmat4x4: ... +@overload +def rotate(m: glm_typing.F32Matrix3x3, angle: glm_typing.Number, /) -> mat3x3: ... +@overload +def rotate(m: dmat3x3, angle: glm_typing.Number, /) -> dmat3x3: ... +@overload +def rotate(v: glm_typing.F32Vector2, angle: glm_typing.Number, /) -> vec2: ... +@overload +def rotate(v: dvec2, angle: glm_typing.Number, /) -> dvec2: ... +@overload +def rotate(v: glm_typing.F32Vector3, angle: glm_typing.Number, normal: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def rotate(v: dvec3, angle: glm_typing.Number, normal: dvec3, /) -> dvec3: ... +@overload +def rotate(v: glm_typing.F32Vector4, angle: glm_typing.Number, normal: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def rotate(v: dvec4, angle: glm_typing.Number, normal: dvec3, /) -> dvec4: ... +@overload +def rotate(v: quat, angle: glm_typing.Number, normal: glm_typing.F32Vector3, /) -> quat: ... +@overload +def rotate(v: dquat, angle: glm_typing.Number, normal: dvec3, /) -> dquat: ... + +@overload +def rotate_slow(m: glm_typing.F32Matrix4x4, angle: glm_typing.Number, axis: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def rotate_slow(m: dmat4x4, angle: glm_typing.Number, axis: dvec3, /) -> dmat4x4: ... + +@overload +def scale(v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def scale(v: dvec3, /) -> dmat4x4: ... +@overload +def scale(v: glm_typing.F32Vector2, /) -> mat3x3: ... +@overload +def scale(v: dvec2, /) -> mat3x3: ... +@overload +def scale(m: glm_typing.F32Matrix4x4, v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def scale(m: dmat4x4, v: dvec3, /) -> dmat4x4: ... +@overload +def scale(m: glm_typing.F32Matrix3x3, v: glm_typing.F32Vector2, /) -> mat3x3: ... +@overload +def scale(m: dmat3x3, v: dvec2, /) -> dmat3x3: ... + +@overload +def scale_slow(m: glm_typing.F32Matrix4x4, v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def scale_slow(m: dmat4x4, v: dvec3, /) -> dmat4x4: ... + +@overload +def translate(v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def translate(v: dvec3, /) -> dmat4x4: ... +@overload +def translate(v: glm_typing.F32Vector2, /) -> mat3x3: ... +@overload +def translate(v: dvec2, /) -> dmat3x3: ... +@overload +def translate(m: glm_typing.F32Matrix4x4, v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def translate(m: dmat4x4, v: dvec3, /) -> dmat4x4: ... +@overload +def translate(m: glm_typing.F32Matrix3x3, v: glm_typing.F32Vector2, /) -> mat3x3: ... +@overload +def translate(m: dmat3x3, v: dvec2, /) -> dmat3x3: ... + + +@overload +def conjugate(q: glm_typing.F32Quaternion, /) -> quat: ... +@overload +def conjugate(q: _NF32QT, /) -> _NF32QT: ... + +@overload +def lerp(x: glm_typing.F32Quaternion, y: glm_typing.F32Quaternion, a: glm_typing.Number, /) -> quat: ... +@overload +def lerp(x: _NF32QT, y: _NF32QT, a: glm_typing.Number, /) -> _NF32QT: ... +@overload +def lerp(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, a: glm_typing.Number, /) -> vec3: ... +@overload +def lerp(x: _NF32DFV3T, y: _NF32DFV3T, a: glm_typing.Number, /) -> _NF32DFV3T: ... + +@overload +def slerp(x: glm_typing.F32Quaternion, y: glm_typing.F32Quaternion, a: glm_typing.Number, /) -> quat: ... +@overload +def slerp(x: _NF32QT, y: _NF32QT, a: glm_typing.Number, /) -> _NF32QT: ... +@overload +def slerp(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, a: glm_typing.Number, /) -> vec3: ... +@overload +def slerp(x: _NF32DFV3T, y: _NF32DFV3T, a: glm_typing.Number, /) -> _NF32DFV3T: ... + + +def angle(x: _QT, /) -> float: ... + +@overload +def angleAxis(angle: glm_typing.Number, axis: glm_typing.F32Vector3, /) -> quat: ... +@overload +def angleAxis(angle: glm_typing.Number, axis: dvec3, /) -> dquat: ... + +@overload +def axis(x: glm_typing.F32Quat, /) -> vec3: ... +@overload +def axis(x: dquat, /) -> dvec3: ... + + +@overload +def decompose(modelMatrix: glm_typing.F32Matrix3x3, scale: glm_typing.F32Vector3, orientation: glm_typing.F32Quaternion, translation: glm_typing.F32Vector3, skew: glm_typing.F32Vector3, perspective: glm_typing.F32Vector4, /) -> bool: ... +@overload +def decompose(modelMatrix: dmat4x4, scale: dvec3, orientation: dquat, translation: dvec3, skew: dvec3, perspective: dvec4, /) -> bool: ... + + +@overload +def shearX(m: glm_typing.F32Matrix3x3, y: glm_typing.Number, /) -> mat3x3: ... +@overload +def shearX(m: _NF32M3X3T, y: glm_typing.Number, /) -> _NF32M3X3T: ... + +@overload +def shearY(m: glm_typing.F32Matrix3x3, y: glm_typing.Number, /) -> mat3x3: ... +@overload +def shearY(m: _NF32M3X3T, y: glm_typing.Number, /) -> _NF32M3X3T: ... + + + +@overload +def distance2(p0: glm_typing.F32Vector1, p1: glm_typing.F32Vector1, /) -> float: ... +@overload +def distance2(p0: glm_typing.F32Vector2, p1: glm_typing.F32Vector2, /) -> float: ... +@overload +def distance2(p0: glm_typing.F32Vector3, p1: glm_typing.F32Vector3, /) -> float: ... +@overload +def distance2(p0: glm_typing.F32Vector4, p1: glm_typing.F32Vector4, /) -> float: ... +@overload +def distance2(p0: _NF32DFVT, p1: _NF32DFVT, /) -> float: ... + +@overload +def l1Norm(v: glm_typing.FDAnyVector3, /) -> float: ... +@overload +def l1Norm(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def l1Norm(x: _NF32DFV3T, y: _NF32DFV3T, /) -> float: ... + +@overload +def l2Norm(v: glm_typing.FDAnyVector3, /) -> float: ... +@overload +def l2Norm(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def l2Norm(x: _NF32DFV3T, y: _NF32DFV3T, /) -> float: ... + +@overload +def lMaxNorm(v: glm_typing.FDAnyVector3, /) -> float: ... +@overload +def lMaxNorm(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def lMaxNorm(x: _NF32DFV3T, y: _NF32DFV3T, /) -> float: ... + +@overload +def length2(p0: glm_typing.F32Vector1, p1: glm_typing.F32Vector1, /) -> float: ... +@overload +def length2(p0: glm_typing.F32Vector2, p1: glm_typing.F32Vector2, /) -> float: ... +@overload +def length2(p0: glm_typing.F32Vector3, p1: glm_typing.F32Vector3, /) -> float: ... +@overload +def length2(p0: glm_typing.F32Vector4, p1: glm_typing.F32Vector4, /) -> float: ... +@overload +def length2(p0: _NF32DFVT, p1: _NF32DFVT, /) -> float: ... + +@overload +def lxNorm(v: glm_typing.FDAnyVector3, /) -> float: ... +@overload +def lxNorm(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def lxNorm(x: _NF32DFV3T, y: _NF32DFV3T, /) -> float: ... + + +@overload +def euclidean(polar: glm_typing.F32Vector2, /) -> vec3: ... +@overload +def euclidean(polar: dvec2, /) -> dvec3: ... + +@overload +def polar(euclidean: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def polar(euclidean: _NF32DFV3T, /) -> _NF32DFV3T: ... + + +@overload +def orientation(Normal: glm_typing.F32Vector3, Up: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def orientation(Normal: dvec3, Up: dvec3, /) -> dmat4x4: ... + +@overload +def rotateX(v: glm_typing.F32Vector3, angle: glm_typing.Number) -> vec3: ... +@overload +def rotateX(v: _NF32DFV3T, angle: glm_typing.Number) -> _NF32DFV3T: ... +@overload +def rotateX(v: glm_typing.F32Vector4, angle: glm_typing.Number) -> vec4: ... +@overload +def rotateX(v: _NF32DFV4T, angle: glm_typing.Number) -> _NF32DFV4T: ... + +@overload +def rotateY(v: glm_typing.F32Vector3, angle: glm_typing.Number) -> vec3: ... +@overload +def rotateY(v: _NF32DFV3T, angle: glm_typing.Number) -> _NF32DFV3T: ... +@overload +def rotateY(v: glm_typing.F32Vector4, angle: glm_typing.Number) -> vec4: ... +@overload +def rotateY(v: _NF32DFV4T, angle: glm_typing.Number) -> _NF32DFV4T: ... + +@overload +def rotateZ(v: glm_typing.F32Vector3, angle: glm_typing.Number) -> vec3: ... +@overload +def rotateZ(v: _NF32DFV3T, angle: glm_typing.Number) -> _NF32DFV3T: ... +@overload +def rotateZ(v: glm_typing.F32Vector4, angle: glm_typing.Number) -> vec4: ... +@overload +def rotateZ(v: _NF32DFV4T, angle: glm_typing.Number) -> _NF32DFV4T: ... + +__all__ = ['abs', 'acos', 'acosh', 'acot', 'acoth', 'acsc', 'acsch', 'add', 'affineInverse', 'all', 'and_', 'angle', 'angleAxis', 'any', 'array', 'asec', 'asech', 'asin', 'asinh', 'atan', 'atanh', 'axis', 'ballRand', 'bitCount', 'bitfieldExtract', 'bitfieldInsert', 'bitfieldReverse', 'bool_', 'bvec1', 'bvec2', 'bvec3', 'bvec4', 'c_int16', 'c_int32', 'c_int64', 'c_int8', 'c_uint16', 'c_uint32', 'c_uint64', 'c_uint8', 'ceil', 'ceilMultiple', 'ceilPowerOfTwo', 'circularRand', 'clamp', 'cmp', 'column', 'conjugate', 'convertLinearToSRGB', 'convertSRGBToLinear', 'cos', 'cosh', 'cot', 'coth', 'cross', 'csc', 'csch', 'decompose', 'degrees', 'determinant', 'diskRand', 'distance', 'distance2', 'div', 'dmat2', 'dmat2x2', 'dmat2x3', 'dmat2x4', 'dmat3', 'dmat3x2', 'dmat3x3', 'dmat3x4', 'dmat4', 'dmat4x2', 'dmat4x3', 'dmat4x4', 'dmvec2', 'dmvec3', 'dmvec4', 'dot', 'double', 'dquat', 'dvec1', 'dvec2', 'dvec3', 'dvec4', 'e', 'epsilon', 'epsilonEqual', 'epsilonNotEqual', 'equal', 'euclidean', 'euler', 'eulerAngles', 'exp', 'exp2', 'f32mat2', 'f32mat2x2', 'f32mat2x3', 'f32mat2x4', 'f32mat3', 'f32mat3x2', 'f32mat3x3', 'f32mat3x4', 'f32mat4', 'f32mat4x2', 'f32mat4x3', 'f32mat4x4', 'f32quat', 'f32vec1', 'f32vec2', 'f32vec3', 'f32vec4', 'f64mat2', 'f64mat2x2', 'f64mat2x3', 'f64mat2x4', 'f64mat3', 'f64mat3x2', 'f64mat3x3', 'f64mat3x4', 'f64mat4', 'f64mat4x2', 'f64mat4x3', 'f64mat4x4', 'f64quat', 'f64vec1', 'f64vec2', 'f64vec3', 'f64vec4', 'faceforward', 'findLSB', 'findMSB', 'float32', 'float64', 'floatBitsToInt', 'floatBitsToUint', 'float_', 'float_distance', 'floor', 'floorMultiple', 'floorPowerOfTwo', 'floordiv', 'fma', 'fmat2', 'fmat2x2', 'fmat2x3', 'fmat2x4', 'fmat3', 'fmat3x2', 'fmat3x3', 'fmat3x4', 'fmat4', 'fmat4x2', 'fmat4x3', 'fmat4x4', 'fmax', 'fmin', 'four_over_pi', 'fquat', 'fract', 'frexp', 'frustum', 'frustumLH', 'frustumLH_NO', 'frustumLH_ZO', 'frustumNO', 'frustumRH', 'frustumRH_NO', 'frustumRH_ZO', 'frustumZO', 'fvec1', 'fvec2', 'fvec3', 'fvec4', 'gaussRand', 'golden_ratio', 'greaterThan', 'greaterThanEqual', 'half_pi', 'i16vec1', 'i16vec2', 'i16vec3', 'i16vec4', 'i32mat2', 'i32mat2x2', 'i32mat2x3', 'i32mat2x4', 'i32mat3', 'i32mat3x2', 'i32mat3x3', 'i32mat3x4', 'i32mat4', 'i32mat4x2', 'i32mat4x3', 'i32mat4x4', 'i32vec1', 'i32vec2', 'i32vec3', 'i32vec4', 'i64vec1', 'i64vec2', 'i64vec3', 'i64vec4', 'i8vec1', 'i8vec2', 'i8vec3', 'i8vec4', 'identity', 'if_else', 'imat2', 'imat2x2', 'imat2x3', 'imat2x4', 'imat3', 'imat3x2', 'imat3x3', 'imat3x4', 'imat4', 'imat4x2', 'imat4x3', 'imat4x4', 'imulExtended', 'imvec2', 'imvec3', 'imvec4', 'infinitePerspective', 'infinitePerspectiveLH', 'infinitePerspectiveRH', 'int16', 'int32', 'int64', 'int8', 'intBitsToFloat', 'inv', 'inverse', 'inverseTranspose', 'inversesqrt', 'iround', 'isinf', 'isnan', 'ivec1', 'ivec2', 'ivec3', 'ivec4', 'l1Norm', 'l2Norm', 'lMaxNorm', 'ldexp', 'length2', 'lerp', 'lessThan', 'lessThanEqual', 'linearRand', 'ln_ln_two', 'ln_ten', 'ln_two', 'log', 'log2', 'lookAt', 'lookAtLH', 'lookAtRH', 'lshift', 'lxNorm', 'make_mat2', 'make_mat2x2', 'make_mat2x3', 'make_mat2x4', 'make_mat3', 'make_mat3x2', 'make_mat3x3', 'make_mat3x4', 'make_mat4', 'make_mat4x2', 'make_mat4x3', 'make_mat4x4', 'make_quat', 'make_vec2', 'make_vec3', 'make_vec4', 'mat2', 'mat2x2', 'mat2x3', 'mat2x4', 'mat3', 'mat3_cast', 'mat3x2', 'mat3x3', 'mat3x4', 'mat4', 'mat4_cast', 'mat4x2', 'mat4x3', 'mat4x4', 'matrixCompMult', 'max', 'min', 'mix', 'modf', 'mul', 'mvec2', 'mvec3', 'mvec4', 'neg', 'next_float', 'normalize', 'notEqual', 'not_', 'one', 'one_over_pi', 'one_over_root_two', 'or_', 'orientation', 'ortho', 'orthoLH', 'orthoLH_NO', 'orthoLH_ZO', 'orthoNO', 'orthoRH', 'orthoRH_NO', 'orthoRH_ZO', 'orthoZO', 'outerProduct', 'packDouble2x32', 'packF2x11_1x10', 'packF3x9_E1x5', 'packHalf', 'packHalf1x16', 'packHalf2x16', 'packHalf4x16', 'packI3x10_1x2', 'packInt2x16', 'packInt2x32', 'packInt2x8', 'packInt4x16', 'packInt4x8', 'packRGBM', 'packSnorm', 'packSnorm1x16', 'packSnorm1x8', 'packSnorm2x16', 'packSnorm2x8', 'packSnorm3x10_1x2', 'packSnorm4x16', 'packSnorm4x8', 'packU3x10_1x2', 'packUint2x16', 'packUint2x32', 'packUint2x8', 'packUint4x16', 'packUint4x8', 'packUnorm', 'packUnorm1x16', 'packUnorm1x5_1x6_1x5', 'packUnorm2x16', 'packUnorm2x4', 'packUnorm2x8', 'packUnorm3x10_1x2', 'packUnorm4x16', 'packUnorm4x4', 'packUnorm4x8', 'perlin', 'perspective', 'perspectiveFov', 'perspectiveFovLH', 'perspectiveFovLH_NO', 'perspectiveFovLH_ZO', 'perspectiveFovNO', 'perspectiveFovRH', 'perspectiveFovRH_NO', 'perspectiveFovRH_ZO', 'perspectiveFovZO', 'perspectiveLH', 'perspectiveLH_NO', 'perspectiveLH_ZO', 'perspectiveNO', 'perspectiveRH', 'perspectiveRH_NO', 'perspectiveRH_ZO', 'perspectiveZO', 'pi', 'pickMatrix', 'pitch', 'polar', 'pos', 'pow', 'prev_float', 'project', 'projectNO', 'projectZO', 'quat', 'quatLookAt', 'quatLookAtLH', 'quatLookAtRH', 'quater_pi', 'radians', 'reflect', 'refract', 'roll', 'root_five', 'root_half_pi', 'root_ln_four', 'root_pi', 'root_three', 'root_two', 'root_two_pi', 'round', 'roundEven', 'roundMultiple', 'roundPowerOfTwo', 'row', 'rshift', 'sec', 'sech', 'setSeed', 'shearX', 'shearY', 'sign', 'simplex', 'sin', 'sinh', 'sizeof', 'slerp', 'smoothstep', 'sphericalRand', 'sqrt', 'step', 'sub', 'tan', 'tanh', 'third', 'three_over_two_pi', 'transpose', 'trunc', 'tweakedInfinitePerspective', 'two_over_pi', 'two_over_root_pi', 'two_pi', 'two_thirds', 'u16vec1', 'u16vec2', 'u16vec3', 'u16vec4', 'u32mat2', 'u32mat2x2', 'u32mat2x3', 'u32mat2x4', 'u32mat3', 'u32mat3x2', 'u32mat3x3', 'u32mat3x4', 'u32mat4', 'u32mat4x2', 'u32mat4x3', 'u32mat4x4', 'u32vec1', 'u32vec2', 'u32vec3', 'u32vec4', 'u64vec1', 'u64vec2', 'u64vec3', 'u64vec4', 'u8vec1', 'u8vec2', 'u8vec3', 'u8vec4', 'uaddCarry', 'uint16', 'uint32', 'uint64', 'uint8', 'uintBitsToFloat', 'umat2', 'umat2x2', 'umat2x3', 'umat2x4', 'umat3', 'umat3x2', 'umat3x3', 'umat3x4', 'umat4', 'umat4x2', 'umat4x3', 'umat4x4', 'umulExtended', 'umvec2', 'umvec3', 'umvec4', 'unProject', 'unProjectNO', 'unProjectZO', 'unpackDouble2x32', 'unpackF2x11_1x10', 'unpackF3x9_E1x5', 'unpackHalf', 'unpackHalf1x16', 'unpackHalf2x16', 'unpackI3x10_1x2', 'unpackInt2x16', 'unpackInt2x32', 'unpackInt2x8', 'unpackInt4x16', 'unpackInt4x8', 'unpackRGBM', 'unpackSnorm', 'unpackSnorm1x16', 'unpackSnorm1x8', 'unpackSnorm2x16', 'unpackSnorm2x8', 'unpackSnorm3x10_1x2', 'unpackSnorm4x16', 'unpackSnorm4x8', 'unpackU3x10_1x2', 'unpackUint2x16', 'unpackUint2x32', 'unpackUint2x8', 'unpackUint4x16', 'unpackUint4x8', 'unpackUnorm', 'unpackUnorm1x16', 'unpackUnorm1x5_1x6_1x5', 'unpackUnorm1x8', 'unpackUnorm2x16', 'unpackUnorm2x3_1x2', 'unpackUnorm2x4', 'unpackUnorm2x8', 'unpackUnorm3x10_1x2', 'unpackUnorm3x5_1x1', 'unpackUnorm4x16', 'unpackUnorm4x4', 'unpackUnorm4x8', 'uround', 'usubBorrow', 'uvec1', 'uvec2', 'uvec3', 'uvec4', 'value_ptr', 'vec1', 'vec2', 'vec3', 'vec4', 'xor', 'yaw', 'zero'] diff --git a/pyglm/__init__.py b/pyglm/__init__.py new file mode 100644 index 00000000..29995034 --- /dev/null +++ b/pyglm/__init__.py @@ -0,0 +1,4 @@ +from . import glm +from . import glm_typing +typing = glm_typing +__version__ = glm.__version__ diff --git a/pyglm/__init__.pyi b/pyglm/__init__.pyi new file mode 100644 index 00000000..8befeea5 --- /dev/null +++ b/pyglm/__init__.pyi @@ -0,0 +1,19284 @@ + +# generated by tools/generate.py +# https://github.com/esoma/pyglm-typing/ + +import ctypes +from typing import (Any, Callable, Generator, Generic, Iterable, List, Literal, + Optional, SupportsInt, Tuple, Type, TypeVar, Union, + overload) + +from . import glm_typing + +_T = TypeVar('_T') +_VT = TypeVar('_VT', bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, mvec2, mvec3, mvec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4, vec1, vec2, vec3, vec4) +_NF32VT = TypeVar('_NF32VT', bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4) +_FDVT = TypeVar('_FDVT', dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, mvec2, mvec3, mvec4, vec1, vec2, vec3, vec4) +_NF32DFVT = TypeVar('_NF32DFVT', dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4) +_NF32DFV1T = TypeVar('_NF32DFV1T', bound=dvec1) +_NF32DFV2T = TypeVar('_NF32DFV2T', dmvec2, dvec2) +_NF32DFV3T = TypeVar('_NF32DFV3T', dmvec3, dvec3) +_NF32DFV4T = TypeVar('_NF32DFV4T', dmvec4, dvec4) +_NF32V1T = TypeVar('_NF32V1T', bvec1, dvec1, i16vec1, i64vec1, i8vec1, ivec1, u16vec1, u64vec1, u8vec1, uvec1) +_NF32V2T = TypeVar('_NF32V2T', bvec2, dmvec2, dvec2, i16vec2, i64vec2, i8vec2, imvec2, ivec2, u16vec2, u64vec2, u8vec2, umvec2, uvec2) +_NF32V3T = TypeVar('_NF32V3T', bvec3, dmvec3, dvec3, i16vec3, i64vec3, i8vec3, imvec3, ivec3, u16vec3, u64vec3, u8vec3, umvec3, uvec3) +_NF32V4T = TypeVar('_NF32V4T', bvec4, dmvec4, dvec4, i16vec4, i64vec4, i8vec4, imvec4, ivec4, u16vec4, u64vec4, u8vec4, umvec4, uvec4) +_IVT = TypeVar('_IVT', i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4) +_UVT = TypeVar('_UVT', u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4) +_NI32IVT = TypeVar('_NI32IVT', i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4) +_NI32IUVT = TypeVar('_NI32IUVT', i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4) +_NI32IUV1T = TypeVar('_NI32IUV1T', i16vec1, i64vec1, i8vec1, u16vec1, u64vec1, u8vec1, uvec1) +_NI32IUV2T = TypeVar('_NI32IUV2T', i16vec2, i64vec2, i8vec2, u16vec2, u64vec2, u8vec2, umvec2, uvec2) +_NI32IUV3T = TypeVar('_NI32IUV3T', i16vec3, i64vec3, i8vec3, u16vec3, u64vec3, u8vec3, umvec3, uvec3) +_NI32IUV4T = TypeVar('_NI32IUV4T', i16vec4, i64vec4, i8vec4, u16vec4, u64vec4, u8vec4, umvec4, uvec4) +_MT = TypeVar('_MT', dmat2x2, dmat2x3, dmat2x4, dmat3x2, dmat3x3, dmat3x4, dmat4x2, dmat4x3, dmat4x4, imat2x2, imat2x3, imat2x4, imat3x2, imat3x3, imat3x4, imat4x2, imat4x3, imat4x4, mat2x2, mat2x3, mat2x4, mat3x2, mat3x3, mat3x4, mat4x2, mat4x3, mat4x4, umat2x2, umat2x3, umat2x4, umat3x2, umat3x3, umat3x4, umat4x2, umat4x3, umat4x4) +_NF32FDMSQRT = TypeVar('_NF32FDMSQRT', dmat2x2, dmat3x3, dmat4x4) +_NF32M2XNT = TypeVar('_NF32M2XNT', dmat2x2, dmat2x3, dmat2x4, imat2x2, imat2x3, imat2x4, umat2x2, umat2x3, umat2x4) +_NF32M3XNT = TypeVar('_NF32M3XNT', dmat3x2, dmat3x3, dmat3x4, imat3x2, imat3x3, imat3x4, umat3x2, umat3x3, umat3x4) +_NF32M4XNT = TypeVar('_NF32M4XNT', dmat4x2, dmat4x3, dmat4x4, imat4x2, imat4x3, imat4x4, umat4x2, umat4x3, umat4x4) +_NF32M2X2T = TypeVar('_NF32M2X2T', dmat2x2, imat2x2, umat2x2) +_NF32M2X3T = TypeVar('_NF32M2X3T', dmat2x3, imat2x3, umat2x3) +_NF32M2X4T = TypeVar('_NF32M2X4T', dmat2x4, imat2x4, umat2x4) +_NF32M3X2T = TypeVar('_NF32M3X2T', dmat3x2, imat3x2, umat3x2) +_NF32M3X3T = TypeVar('_NF32M3X3T', dmat3x3, imat3x3, umat3x3) +_NF32M3X4T = TypeVar('_NF32M3X4T', dmat3x4, imat3x4, umat3x4) +_NF32M4X2T = TypeVar('_NF32M4X2T', dmat4x2, imat4x2, umat4x2) +_NF32M4X3T = TypeVar('_NF32M4X3T', dmat4x3, imat4x3, umat4x3) +_NF32M4X4T = TypeVar('_NF32M4X4T', dmat4x4, imat4x4, umat4x4) +_QT = TypeVar('_QT', dquat, quat) +_NF32QT = TypeVar('_NF32QT', bound=dquat) + +bool_ = ctypes.c_bool +c_int16 = ctypes.c_short +int16 = ctypes.c_short +c_int32 = ctypes.c_long +int32 = ctypes.c_long +c_int64 = ctypes.c_longlong +int64 = ctypes.c_longlong +c_int8 = ctypes.c_byte +int8 = ctypes.c_byte +c_uint16 = ctypes.c_ushort +uint16 = ctypes.c_ushort +c_uint32 = ctypes.c_ulong +uint32 = ctypes.c_ulong +c_uint64 = ctypes.c_ulonglong +uint64 = ctypes.c_ulonglong +c_uint8 = ctypes.c_ubyte +uint8 = ctypes.c_ubyte +double = ctypes.c_double +float64 = ctypes.c_double +float32 = ctypes.c_float +float_ = ctypes.c_float + + +class bvec1: + x: bool + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.BAnyVector2, glm_typing.BAnyVector3, glm_typing.BAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> bool: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[bool, None, None]: ... + + def __neg__(self) -> bvec1: ... + def __pos__(self) -> bvec1: ... + def __abs__(self) -> bvec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[bool]: ... + def to_tuple(self) -> Tuple[bool]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> bvec1: ... + + def __add__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __radd__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __iadd__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + def __sub__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rsub__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __isub__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __mul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __rmul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __imul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + + def __mod__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rmod__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __imod__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + def __pow__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rpow__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __ipow__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + def __truediv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rtruediv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __itruediv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + def __floordiv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __rfloordiv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + def __ifloordiv__(self, other: Union[glm_typing.B8Vector1, glm_typing.Number]) -> bvec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __matmul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> bvec1: ... + @overload + def __imatmul__(self, other: glm_typing.B8Vector1) -> bvec1: ... + + def __divmod__(self, other: bvec1) -> Tuple[bvec1, bvec1]: ... + + + +class bvec2: + x: bool + y: bool + + + @property + def xy(self) -> b8vec2: ... + @xy.setter + def xy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yx(self) -> b8vec2: ... + @yx.setter + def yx(self, value: glm_typing.B8Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.BAnyVector3, glm_typing.BAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> bool: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[bool, None, None]: ... + + def __neg__(self) -> bvec2: ... + def __pos__(self) -> bvec2: ... + def __abs__(self) -> bvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[bool]: ... + def to_tuple(self) -> Tuple[bool, bool]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> bvec2: ... + + def __add__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __radd__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __iadd__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + def __sub__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rsub__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __isub__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __mul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __rmul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __imul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + + def __mod__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rmod__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __imod__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + def __pow__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rpow__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __ipow__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + def __truediv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rtruediv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __itruediv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + def __floordiv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.B8Vector2, glm_typing.Number]) -> bvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __matmul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> bvec2: ... + @overload + def __imatmul__(self, other: glm_typing.B8Vector2) -> bvec2: ... + + def __divmod__(self, other: bvec2) -> Tuple[bvec2, bvec2]: ... + + + +class bvec3: + x: bool + y: bool + z: bool + + + @property + def xy(self) -> b8vec2: ... + @xy.setter + def xy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yx(self) -> b8vec2: ... + @yx.setter + def yx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xz(self) -> b8vec2: ... + @xz.setter + def xz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zx(self) -> b8vec2: ... + @zx.setter + def zx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yz(self) -> b8vec2: ... + @yz.setter + def yz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zy(self) -> b8vec2: ... + @zy.setter + def zy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xyz(self) -> b8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xzy(self) -> b8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yxz(self) -> b8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yzx(self) -> b8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zxy(self) -> b8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zyx(self) -> b8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.B8Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.BAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> bool: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[bool, None, None]: ... + + def __neg__(self) -> bvec3: ... + def __pos__(self) -> bvec3: ... + def __abs__(self) -> bvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[bool]: ... + def to_tuple(self) -> Tuple[bool, bool, bool]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> bvec3: ... + + def __add__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __radd__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __iadd__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + def __sub__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rsub__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __isub__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __mul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __rmul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __imul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + + def __mod__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rmod__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __imod__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + def __pow__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rpow__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __ipow__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + def __truediv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rtruediv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __itruediv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + def __floordiv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.B8Vector3, glm_typing.Number]) -> bvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __matmul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> bvec3: ... + @overload + def __imatmul__(self, other: glm_typing.B8Vector3) -> bvec3: ... + + def __divmod__(self, other: bvec3) -> Tuple[bvec3, bvec3]: ... + + + +class bvec4: + x: bool + y: bool + z: bool + w: bool + + + @property + def xy(self) -> b8vec2: ... + @xy.setter + def xy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yx(self) -> b8vec2: ... + @yx.setter + def yx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xz(self) -> b8vec2: ... + @xz.setter + def xz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zx(self) -> b8vec2: ... + @zx.setter + def zx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xw(self) -> b8vec2: ... + @xw.setter + def xw(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def wx(self) -> b8vec2: ... + @wx.setter + def wx(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yz(self) -> b8vec2: ... + @yz.setter + def yz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zy(self) -> b8vec2: ... + @zy.setter + def zy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def yw(self) -> b8vec2: ... + @yw.setter + def yw(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def wy(self) -> b8vec2: ... + @wy.setter + def wy(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def zw(self) -> b8vec2: ... + @zw.setter + def zw(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def wz(self) -> b8vec2: ... + @wz.setter + def wz(self, value: glm_typing.B8Vector2) -> None: ... + + @property + def xyz(self) -> b8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xzy(self) -> b8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yxz(self) -> b8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yzx(self) -> b8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zxy(self) -> b8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zyx(self) -> b8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xyw(self) -> b8vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xwy(self) -> b8vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yxw(self) -> b8vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def ywx(self) -> b8vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wxy(self) -> b8vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wyx(self) -> b8vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xzw(self) -> b8vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xwz(self) -> b8vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zxw(self) -> b8vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zwx(self) -> b8vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wxz(self) -> b8vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wzx(self) -> b8vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def yzw(self) -> b8vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def ywz(self) -> b8vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zyw(self) -> b8vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def zwy(self) -> b8vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wyz(self) -> b8vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def wzy(self) -> b8vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.B8Vector3) -> None: ... + + @property + def xyzw(self) -> b8vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xywz(self) -> b8vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xzyw(self) -> b8vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xzwy(self) -> b8vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xwyz(self) -> b8vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def xwzy(self) -> b8vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def yxzw(self) -> b8vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def yxwz(self) -> b8vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def yzxw(self) -> b8vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def yzwx(self) -> b8vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def ywxz(self) -> b8vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def ywzx(self) -> b8vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zxyw(self) -> b8vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zxwy(self) -> b8vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zyxw(self) -> b8vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zywx(self) -> b8vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zwxy(self) -> b8vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def zwyx(self) -> b8vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wxyz(self) -> b8vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wxzy(self) -> b8vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wyxz(self) -> b8vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wyzx(self) -> b8vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wzxy(self) -> b8vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.B8Vector4) -> None: ... + + @property + def wzyx(self) -> b8vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.B8Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> bool: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[bool, None, None]: ... + + def __neg__(self) -> bvec4: ... + def __pos__(self) -> bvec4: ... + def __abs__(self) -> bvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[bool]: ... + def to_tuple(self) -> Tuple[bool, bool, bool, bool]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> bvec4: ... + + def __add__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __radd__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __iadd__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + def __sub__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rsub__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __isub__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __mul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __rmul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __imul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + + def __mod__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rmod__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __imod__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + def __pow__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rpow__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __ipow__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + def __truediv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rtruediv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __itruediv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + def __floordiv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.B8Vector4, glm_typing.Number]) -> bvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __matmul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> bvec4: ... + @overload + def __imatmul__(self, other: glm_typing.B8Vector4) -> bvec4: ... + + def __divmod__(self, other: bvec4) -> Tuple[bvec4, bvec4]: ... + + + +class dmvec2: + x: float + y: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.DAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dmvec2: ... + def __pos__(self) -> dmvec2: ... + def __abs__(self) -> dmvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmvec2: ... + + def __add__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __radd__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __iadd__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + def __sub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rsub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __isub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rmod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __imod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + def __pow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rpow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __ipow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dmvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dmvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dmvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dmvec2) -> Tuple[dmvec2, dmvec2]: ... + + + +class dmvec3: + x: float + y: float + z: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xz(self) -> d64vec2: ... + @xz.setter + def xz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zx(self) -> d64vec2: ... + @zx.setter + def zx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yz(self) -> d64vec2: ... + @yz.setter + def yz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zy(self) -> d64vec2: ... + @zy.setter + def zy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xyz(self) -> d64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzy(self) -> d64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxz(self) -> d64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzx(self) -> d64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxy(self) -> d64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyx(self) -> d64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.D64Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dmvec3: ... + def __pos__(self) -> dmvec3: ... + def __abs__(self) -> dmvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmvec3: ... + + def __add__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __radd__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __iadd__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + def __sub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rsub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __isub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rmod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __imod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + def __pow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rpow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __ipow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dmvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dmvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dmvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dmvec3) -> Tuple[dmvec3, dmvec3]: ... + + + +class dmvec4: + x: float + y: float + z: float + w: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xz(self) -> d64vec2: ... + @xz.setter + def xz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zx(self) -> d64vec2: ... + @zx.setter + def zx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xw(self) -> d64vec2: ... + @xw.setter + def xw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wx(self) -> d64vec2: ... + @wx.setter + def wx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yz(self) -> d64vec2: ... + @yz.setter + def yz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zy(self) -> d64vec2: ... + @zy.setter + def zy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yw(self) -> d64vec2: ... + @yw.setter + def yw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wy(self) -> d64vec2: ... + @wy.setter + def wy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zw(self) -> d64vec2: ... + @zw.setter + def zw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wz(self) -> d64vec2: ... + @wz.setter + def wz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xyz(self) -> d64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzy(self) -> d64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxz(self) -> d64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzx(self) -> d64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxy(self) -> d64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyx(self) -> d64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xyw(self) -> d64vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xwy(self) -> d64vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxw(self) -> d64vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def ywx(self) -> d64vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wxy(self) -> d64vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wyx(self) -> d64vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzw(self) -> d64vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xwz(self) -> d64vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxw(self) -> d64vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zwx(self) -> d64vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wxz(self) -> d64vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wzx(self) -> d64vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzw(self) -> d64vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def ywz(self) -> d64vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyw(self) -> d64vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zwy(self) -> d64vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wyz(self) -> d64vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wzy(self) -> d64vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xyzw(self) -> d64vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xywz(self) -> d64vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xzyw(self) -> d64vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xzwy(self) -> d64vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xwyz(self) -> d64vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xwzy(self) -> d64vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yxzw(self) -> d64vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yxwz(self) -> d64vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yzxw(self) -> d64vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yzwx(self) -> d64vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def ywxz(self) -> d64vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def ywzx(self) -> d64vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zxyw(self) -> d64vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zxwy(self) -> d64vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zyxw(self) -> d64vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zywx(self) -> d64vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zwxy(self) -> d64vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zwyx(self) -> d64vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wxyz(self) -> d64vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wxzy(self) -> d64vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wyxz(self) -> d64vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wyzx(self) -> d64vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wzxy(self) -> d64vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wzyx(self) -> d64vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.D64Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dmvec4: ... + def __pos__(self) -> dmvec4: ... + def __abs__(self) -> dmvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmvec4: ... + + def __add__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __radd__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __iadd__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + def __sub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rsub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __isub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rmod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __imod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + def __pow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rpow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __ipow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dmvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dmvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dmvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dmvec4) -> Tuple[dmvec4, dmvec4]: ... + + +f64vec1 = dvec1 + +class dvec1: + x: float + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.DAnyVector2, glm_typing.DAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dvec1: ... + def __pos__(self) -> dvec1: ... + def __abs__(self) -> dvec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dvec1: ... + + def __add__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __radd__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __iadd__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + def __sub__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rsub__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __isub__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __mul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __imul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rmod__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __imod__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + def __pow__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rpow__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __ipow__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector1, glm_typing.Number]) -> dvec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dvec1: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dvec1) -> Tuple[dvec1, dvec1]: ... + + +f64vec2 = dvec2 + +class dvec2: + x: float + y: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.DAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dvec2: ... + def __pos__(self) -> dvec2: ... + def __abs__(self) -> dvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dvec2: ... + + def __add__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __radd__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __iadd__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + def __sub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rsub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __isub__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rmod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __imod__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + def __pow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rpow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __ipow__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector2, glm_typing.Number]) -> dvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dvec2) -> Tuple[dvec2, dvec2]: ... + + +f64vec3 = dvec3 + +class dvec3: + x: float + y: float + z: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xz(self) -> d64vec2: ... + @xz.setter + def xz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zx(self) -> d64vec2: ... + @zx.setter + def zx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yz(self) -> d64vec2: ... + @yz.setter + def yz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zy(self) -> d64vec2: ... + @zy.setter + def zy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xyz(self) -> d64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzy(self) -> d64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxz(self) -> d64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzx(self) -> d64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxy(self) -> d64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyx(self) -> d64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.D64Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.DAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dvec3: ... + def __pos__(self) -> dvec3: ... + def __abs__(self) -> dvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dvec3: ... + + def __add__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __radd__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __iadd__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + def __sub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rsub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __isub__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rmod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __imod__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + def __pow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rpow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __ipow__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector3, glm_typing.Number]) -> dvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dvec3) -> Tuple[dvec3, dvec3]: ... + + +f64vec4 = dvec4 + +class dvec4: + x: float + y: float + z: float + w: float + + + @property + def xy(self) -> d64vec2: ... + @xy.setter + def xy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yx(self) -> d64vec2: ... + @yx.setter + def yx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xz(self) -> d64vec2: ... + @xz.setter + def xz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zx(self) -> d64vec2: ... + @zx.setter + def zx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xw(self) -> d64vec2: ... + @xw.setter + def xw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wx(self) -> d64vec2: ... + @wx.setter + def wx(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yz(self) -> d64vec2: ... + @yz.setter + def yz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zy(self) -> d64vec2: ... + @zy.setter + def zy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def yw(self) -> d64vec2: ... + @yw.setter + def yw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wy(self) -> d64vec2: ... + @wy.setter + def wy(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def zw(self) -> d64vec2: ... + @zw.setter + def zw(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def wz(self) -> d64vec2: ... + @wz.setter + def wz(self, value: glm_typing.D64Vector2) -> None: ... + + @property + def xyz(self) -> d64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzy(self) -> d64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxz(self) -> d64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzx(self) -> d64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxy(self) -> d64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyx(self) -> d64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xyw(self) -> d64vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xwy(self) -> d64vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yxw(self) -> d64vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def ywx(self) -> d64vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wxy(self) -> d64vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wyx(self) -> d64vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xzw(self) -> d64vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xwz(self) -> d64vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zxw(self) -> d64vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zwx(self) -> d64vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wxz(self) -> d64vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wzx(self) -> d64vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def yzw(self) -> d64vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def ywz(self) -> d64vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zyw(self) -> d64vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def zwy(self) -> d64vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wyz(self) -> d64vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def wzy(self) -> d64vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.D64Vector3) -> None: ... + + @property + def xyzw(self) -> d64vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xywz(self) -> d64vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xzyw(self) -> d64vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xzwy(self) -> d64vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xwyz(self) -> d64vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def xwzy(self) -> d64vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yxzw(self) -> d64vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yxwz(self) -> d64vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yzxw(self) -> d64vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def yzwx(self) -> d64vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def ywxz(self) -> d64vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def ywzx(self) -> d64vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zxyw(self) -> d64vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zxwy(self) -> d64vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zyxw(self) -> d64vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zywx(self) -> d64vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zwxy(self) -> d64vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def zwyx(self) -> d64vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wxyz(self) -> d64vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wxzy(self) -> d64vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wyxz(self) -> d64vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wyzx(self) -> d64vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wzxy(self) -> d64vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.D64Vector4) -> None: ... + + @property + def wzyx(self) -> d64vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.D64Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> dvec4: ... + def __pos__(self) -> dvec4: ... + def __abs__(self) -> dvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dvec4: ... + + def __add__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __radd__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __iadd__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + def __sub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rsub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __isub__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rmod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __imod__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + def __pow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rpow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __ipow__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + def __truediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rtruediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __itruediv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + def __floordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.D64Vector4, glm_typing.Number]) -> dvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Matrix4x2) -> vec4: ... + + def __divmod__(self, other: dvec4) -> Tuple[dvec4, dvec4]: ... + + + +class i16vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.IAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i16vec1: ... + def __pos__(self) -> i16vec1: ... + def __abs__(self) -> i16vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i16vec1: ... + + def __add__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __radd__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __iadd__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + def __sub__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rsub__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __isub__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __mul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __rmul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __imul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + + def __mod__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rmod__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __imod__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + def __pow__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rpow__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __ipow__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + def __truediv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rtruediv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __itruediv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + def __floordiv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.I16Vector1, glm_typing.Number]) -> i16vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __matmul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i16vec1: ... + @overload + def __imatmul__(self, other: glm_typing.I16Vector1) -> i16vec1: ... + + def __divmod__(self, other: i16vec1) -> Tuple[i16vec1, i16vec1]: ... + + + +class i16vec2: + x: int + y: int + + + @property + def xy(self) -> i16vec2: ... + @xy.setter + def xy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yx(self) -> i16vec2: ... + @yx.setter + def yx(self, value: glm_typing.I16Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i16vec2: ... + def __pos__(self) -> i16vec2: ... + def __abs__(self) -> i16vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i16vec2: ... + + def __add__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __radd__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __iadd__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + def __sub__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rsub__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __isub__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __mul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __rmul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __imul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + + def __mod__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rmod__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __imod__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + def __pow__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rpow__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __ipow__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + def __truediv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rtruediv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __itruediv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + def __floordiv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I16Vector2, glm_typing.Number]) -> i16vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __matmul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i16vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I16Vector2) -> i16vec2: ... + + def __divmod__(self, other: i16vec2) -> Tuple[i16vec2, i16vec2]: ... + + + +class i16vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i16vec2: ... + @xy.setter + def xy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yx(self) -> i16vec2: ... + @yx.setter + def yx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xz(self) -> i16vec2: ... + @xz.setter + def xz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zx(self) -> i16vec2: ... + @zx.setter + def zx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yz(self) -> i16vec2: ... + @yz.setter + def yz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zy(self) -> i16vec2: ... + @zy.setter + def zy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xyz(self) -> i16vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xzy(self) -> i16vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yxz(self) -> i16vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yzx(self) -> i16vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zxy(self) -> i16vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zyx(self) -> i16vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I16Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i16vec3: ... + def __pos__(self) -> i16vec3: ... + def __abs__(self) -> i16vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i16vec3: ... + + def __add__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __radd__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __iadd__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + def __sub__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rsub__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __isub__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __mul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __rmul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __imul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + + def __mod__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rmod__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __imod__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + def __pow__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rpow__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __ipow__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + def __truediv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rtruediv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __itruediv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + def __floordiv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I16Vector3, glm_typing.Number]) -> i16vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __matmul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i16vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I16Vector3) -> i16vec3: ... + + def __divmod__(self, other: i16vec3) -> Tuple[i16vec3, i16vec3]: ... + + + +class i16vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i16vec2: ... + @xy.setter + def xy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yx(self) -> i16vec2: ... + @yx.setter + def yx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xz(self) -> i16vec2: ... + @xz.setter + def xz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zx(self) -> i16vec2: ... + @zx.setter + def zx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xw(self) -> i16vec2: ... + @xw.setter + def xw(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def wx(self) -> i16vec2: ... + @wx.setter + def wx(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yz(self) -> i16vec2: ... + @yz.setter + def yz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zy(self) -> i16vec2: ... + @zy.setter + def zy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def yw(self) -> i16vec2: ... + @yw.setter + def yw(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def wy(self) -> i16vec2: ... + @wy.setter + def wy(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def zw(self) -> i16vec2: ... + @zw.setter + def zw(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def wz(self) -> i16vec2: ... + @wz.setter + def wz(self, value: glm_typing.I16Vector2) -> None: ... + + @property + def xyz(self) -> i16vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xzy(self) -> i16vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yxz(self) -> i16vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yzx(self) -> i16vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zxy(self) -> i16vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zyx(self) -> i16vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xyw(self) -> i16vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xwy(self) -> i16vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yxw(self) -> i16vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def ywx(self) -> i16vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wxy(self) -> i16vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wyx(self) -> i16vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xzw(self) -> i16vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xwz(self) -> i16vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zxw(self) -> i16vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zwx(self) -> i16vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wxz(self) -> i16vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wzx(self) -> i16vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def yzw(self) -> i16vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def ywz(self) -> i16vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zyw(self) -> i16vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def zwy(self) -> i16vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wyz(self) -> i16vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def wzy(self) -> i16vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I16Vector3) -> None: ... + + @property + def xyzw(self) -> i16vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xywz(self) -> i16vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xzyw(self) -> i16vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xzwy(self) -> i16vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xwyz(self) -> i16vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def xwzy(self) -> i16vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def yxzw(self) -> i16vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def yxwz(self) -> i16vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def yzxw(self) -> i16vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def yzwx(self) -> i16vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def ywxz(self) -> i16vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def ywzx(self) -> i16vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zxyw(self) -> i16vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zxwy(self) -> i16vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zyxw(self) -> i16vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zywx(self) -> i16vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zwxy(self) -> i16vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def zwyx(self) -> i16vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wxyz(self) -> i16vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wxzy(self) -> i16vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wyxz(self) -> i16vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wyzx(self) -> i16vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wzxy(self) -> i16vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I16Vector4) -> None: ... + + @property + def wzyx(self) -> i16vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I16Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i16vec4: ... + def __pos__(self) -> i16vec4: ... + def __abs__(self) -> i16vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i16vec4: ... + + def __add__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __radd__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __iadd__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + def __sub__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rsub__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __isub__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __mul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __rmul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __imul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + + def __mod__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rmod__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __imod__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + def __pow__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rpow__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __ipow__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + def __truediv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rtruediv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __itruediv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + def __floordiv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I16Vector4, glm_typing.Number]) -> i16vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __matmul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i16vec4: ... + @overload + def __imatmul__(self, other: glm_typing.I16Vector4) -> i16vec4: ... + + def __divmod__(self, other: i16vec4) -> Tuple[i16vec4, i16vec4]: ... + + + +class i64vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.IAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i64vec1: ... + def __pos__(self) -> i64vec1: ... + def __abs__(self) -> i64vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i64vec1: ... + + def __add__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __radd__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __iadd__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + def __sub__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rsub__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __isub__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __mul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __rmul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __imul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + + def __mod__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rmod__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __imod__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + def __pow__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rpow__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __ipow__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + def __truediv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rtruediv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __itruediv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + def __floordiv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.I64Vector1, glm_typing.Number]) -> i64vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __matmul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i64vec1: ... + @overload + def __imatmul__(self, other: glm_typing.I64Vector1) -> i64vec1: ... + + def __divmod__(self, other: i64vec1) -> Tuple[i64vec1, i64vec1]: ... + + + +class i64vec2: + x: int + y: int + + + @property + def xy(self) -> i64vec2: ... + @xy.setter + def xy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yx(self) -> i64vec2: ... + @yx.setter + def yx(self, value: glm_typing.I64Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i64vec2: ... + def __pos__(self) -> i64vec2: ... + def __abs__(self) -> i64vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i64vec2: ... + + def __add__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __radd__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __iadd__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + def __sub__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rsub__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __isub__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __mul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __rmul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __imul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + + def __mod__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rmod__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __imod__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + def __pow__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rpow__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __ipow__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + def __truediv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rtruediv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __itruediv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + def __floordiv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I64Vector2, glm_typing.Number]) -> i64vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __matmul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i64vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I64Vector2) -> i64vec2: ... + + def __divmod__(self, other: i64vec2) -> Tuple[i64vec2, i64vec2]: ... + + + +class i64vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i64vec2: ... + @xy.setter + def xy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yx(self) -> i64vec2: ... + @yx.setter + def yx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xz(self) -> i64vec2: ... + @xz.setter + def xz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zx(self) -> i64vec2: ... + @zx.setter + def zx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yz(self) -> i64vec2: ... + @yz.setter + def yz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zy(self) -> i64vec2: ... + @zy.setter + def zy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xyz(self) -> i64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xzy(self) -> i64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yxz(self) -> i64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yzx(self) -> i64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zxy(self) -> i64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zyx(self) -> i64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I64Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i64vec3: ... + def __pos__(self) -> i64vec3: ... + def __abs__(self) -> i64vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i64vec3: ... + + def __add__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __radd__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __iadd__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + def __sub__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rsub__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __isub__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __mul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __rmul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __imul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + + def __mod__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rmod__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __imod__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + def __pow__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rpow__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __ipow__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + def __truediv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rtruediv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __itruediv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + def __floordiv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I64Vector3, glm_typing.Number]) -> i64vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __matmul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i64vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I64Vector3) -> i64vec3: ... + + def __divmod__(self, other: i64vec3) -> Tuple[i64vec3, i64vec3]: ... + + + +class i64vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i64vec2: ... + @xy.setter + def xy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yx(self) -> i64vec2: ... + @yx.setter + def yx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xz(self) -> i64vec2: ... + @xz.setter + def xz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zx(self) -> i64vec2: ... + @zx.setter + def zx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xw(self) -> i64vec2: ... + @xw.setter + def xw(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def wx(self) -> i64vec2: ... + @wx.setter + def wx(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yz(self) -> i64vec2: ... + @yz.setter + def yz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zy(self) -> i64vec2: ... + @zy.setter + def zy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def yw(self) -> i64vec2: ... + @yw.setter + def yw(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def wy(self) -> i64vec2: ... + @wy.setter + def wy(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def zw(self) -> i64vec2: ... + @zw.setter + def zw(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def wz(self) -> i64vec2: ... + @wz.setter + def wz(self, value: glm_typing.I64Vector2) -> None: ... + + @property + def xyz(self) -> i64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xzy(self) -> i64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yxz(self) -> i64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yzx(self) -> i64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zxy(self) -> i64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zyx(self) -> i64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xyw(self) -> i64vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xwy(self) -> i64vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yxw(self) -> i64vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def ywx(self) -> i64vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wxy(self) -> i64vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wyx(self) -> i64vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xzw(self) -> i64vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xwz(self) -> i64vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zxw(self) -> i64vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zwx(self) -> i64vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wxz(self) -> i64vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wzx(self) -> i64vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def yzw(self) -> i64vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def ywz(self) -> i64vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zyw(self) -> i64vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def zwy(self) -> i64vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wyz(self) -> i64vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def wzy(self) -> i64vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I64Vector3) -> None: ... + + @property + def xyzw(self) -> i64vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xywz(self) -> i64vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xzyw(self) -> i64vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xzwy(self) -> i64vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xwyz(self) -> i64vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def xwzy(self) -> i64vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def yxzw(self) -> i64vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def yxwz(self) -> i64vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def yzxw(self) -> i64vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def yzwx(self) -> i64vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def ywxz(self) -> i64vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def ywzx(self) -> i64vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zxyw(self) -> i64vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zxwy(self) -> i64vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zyxw(self) -> i64vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zywx(self) -> i64vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zwxy(self) -> i64vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def zwyx(self) -> i64vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wxyz(self) -> i64vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wxzy(self) -> i64vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wyxz(self) -> i64vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wyzx(self) -> i64vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wzxy(self) -> i64vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I64Vector4) -> None: ... + + @property + def wzyx(self) -> i64vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I64Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i64vec4: ... + def __pos__(self) -> i64vec4: ... + def __abs__(self) -> i64vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i64vec4: ... + + def __add__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __radd__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __iadd__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + def __sub__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rsub__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __isub__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __mul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __rmul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __imul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + + def __mod__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rmod__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __imod__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + def __pow__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rpow__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __ipow__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + def __truediv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rtruediv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __itruediv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + def __floordiv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I64Vector4, glm_typing.Number]) -> i64vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __matmul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i64vec4: ... + @overload + def __imatmul__(self, other: glm_typing.I64Vector4) -> i64vec4: ... + + def __divmod__(self, other: i64vec4) -> Tuple[i64vec4, i64vec4]: ... + + + +class i8vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.IAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i8vec1: ... + def __pos__(self) -> i8vec1: ... + def __abs__(self) -> i8vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i8vec1: ... + + def __add__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __radd__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __iadd__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + def __sub__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rsub__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __isub__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __mul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __rmul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __imul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + + def __mod__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rmod__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __imod__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + def __pow__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rpow__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __ipow__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + def __truediv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rtruediv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __itruediv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + def __floordiv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.I8Vector1, glm_typing.Number]) -> i8vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __matmul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i8vec1: ... + @overload + def __imatmul__(self, other: glm_typing.I8Vector1) -> i8vec1: ... + + def __divmod__(self, other: i8vec1) -> Tuple[i8vec1, i8vec1]: ... + + + +class i8vec2: + x: int + y: int + + + @property + def xy(self) -> i8vec2: ... + @xy.setter + def xy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yx(self) -> i8vec2: ... + @yx.setter + def yx(self, value: glm_typing.I8Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i8vec2: ... + def __pos__(self) -> i8vec2: ... + def __abs__(self) -> i8vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i8vec2: ... + + def __add__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __radd__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __iadd__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + def __sub__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rsub__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __isub__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __mul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __rmul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __imul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + + def __mod__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rmod__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __imod__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + def __pow__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rpow__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __ipow__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + def __truediv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rtruediv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __itruediv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + def __floordiv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I8Vector2, glm_typing.Number]) -> i8vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __matmul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i8vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I8Vector2) -> i8vec2: ... + + def __divmod__(self, other: i8vec2) -> Tuple[i8vec2, i8vec2]: ... + + + +class i8vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i8vec2: ... + @xy.setter + def xy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yx(self) -> i8vec2: ... + @yx.setter + def yx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xz(self) -> i8vec2: ... + @xz.setter + def xz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zx(self) -> i8vec2: ... + @zx.setter + def zx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yz(self) -> i8vec2: ... + @yz.setter + def yz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zy(self) -> i8vec2: ... + @zy.setter + def zy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xyz(self) -> i8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xzy(self) -> i8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yxz(self) -> i8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yzx(self) -> i8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zxy(self) -> i8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zyx(self) -> i8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I8Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i8vec3: ... + def __pos__(self) -> i8vec3: ... + def __abs__(self) -> i8vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i8vec3: ... + + def __add__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __radd__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __iadd__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + def __sub__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rsub__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __isub__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __mul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __rmul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __imul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + + def __mod__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rmod__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __imod__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + def __pow__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rpow__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __ipow__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + def __truediv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rtruediv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __itruediv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + def __floordiv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I8Vector3, glm_typing.Number]) -> i8vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __matmul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i8vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I8Vector3) -> i8vec3: ... + + def __divmod__(self, other: i8vec3) -> Tuple[i8vec3, i8vec3]: ... + + + +class i8vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i8vec2: ... + @xy.setter + def xy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yx(self) -> i8vec2: ... + @yx.setter + def yx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xz(self) -> i8vec2: ... + @xz.setter + def xz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zx(self) -> i8vec2: ... + @zx.setter + def zx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xw(self) -> i8vec2: ... + @xw.setter + def xw(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def wx(self) -> i8vec2: ... + @wx.setter + def wx(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yz(self) -> i8vec2: ... + @yz.setter + def yz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zy(self) -> i8vec2: ... + @zy.setter + def zy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def yw(self) -> i8vec2: ... + @yw.setter + def yw(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def wy(self) -> i8vec2: ... + @wy.setter + def wy(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def zw(self) -> i8vec2: ... + @zw.setter + def zw(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def wz(self) -> i8vec2: ... + @wz.setter + def wz(self, value: glm_typing.I8Vector2) -> None: ... + + @property + def xyz(self) -> i8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xzy(self) -> i8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yxz(self) -> i8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yzx(self) -> i8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zxy(self) -> i8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zyx(self) -> i8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xyw(self) -> i8vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xwy(self) -> i8vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yxw(self) -> i8vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def ywx(self) -> i8vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wxy(self) -> i8vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wyx(self) -> i8vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xzw(self) -> i8vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xwz(self) -> i8vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zxw(self) -> i8vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zwx(self) -> i8vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wxz(self) -> i8vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wzx(self) -> i8vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def yzw(self) -> i8vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def ywz(self) -> i8vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zyw(self) -> i8vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def zwy(self) -> i8vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wyz(self) -> i8vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def wzy(self) -> i8vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I8Vector3) -> None: ... + + @property + def xyzw(self) -> i8vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xywz(self) -> i8vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xzyw(self) -> i8vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xzwy(self) -> i8vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xwyz(self) -> i8vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def xwzy(self) -> i8vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def yxzw(self) -> i8vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def yxwz(self) -> i8vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def yzxw(self) -> i8vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def yzwx(self) -> i8vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def ywxz(self) -> i8vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def ywzx(self) -> i8vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zxyw(self) -> i8vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zxwy(self) -> i8vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zyxw(self) -> i8vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zywx(self) -> i8vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zwxy(self) -> i8vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def zwyx(self) -> i8vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wxyz(self) -> i8vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wxzy(self) -> i8vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wyxz(self) -> i8vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wyzx(self) -> i8vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wzxy(self) -> i8vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I8Vector4) -> None: ... + + @property + def wzyx(self) -> i8vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I8Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> i8vec4: ... + def __pos__(self) -> i8vec4: ... + def __abs__(self) -> i8vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> i8vec4: ... + + def __add__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __radd__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __iadd__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + def __sub__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rsub__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __isub__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __mul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __rmul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __imul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + + def __mod__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rmod__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __imod__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + def __pow__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rpow__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __ipow__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + def __truediv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rtruediv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __itruediv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + def __floordiv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I8Vector4, glm_typing.Number]) -> i8vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __matmul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> i8vec4: ... + @overload + def __imatmul__(self, other: glm_typing.I8Vector4) -> i8vec4: ... + + def __divmod__(self, other: i8vec4) -> Tuple[i8vec4, i8vec4]: ... + + + +class imvec2: + x: int + y: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> imvec2: ... + def __pos__(self) -> imvec2: ... + def __abs__(self) -> imvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imvec2: ... + + def __add__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __radd__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __iadd__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + def __sub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rsub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __isub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rmod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __imod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + def __pow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rpow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __ipow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> imvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> imvec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> imvec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: imvec2) -> Tuple[imvec2, imvec2]: ... + + + +class imvec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xz(self) -> i32vec2: ... + @xz.setter + def xz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zx(self) -> i32vec2: ... + @zx.setter + def zx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yz(self) -> i32vec2: ... + @yz.setter + def yz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zy(self) -> i32vec2: ... + @zy.setter + def zy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xyz(self) -> i32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzy(self) -> i32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxz(self) -> i32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzx(self) -> i32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxy(self) -> i32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyx(self) -> i32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> imvec3: ... + def __pos__(self) -> imvec3: ... + def __abs__(self) -> imvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imvec3: ... + + def __add__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __radd__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __iadd__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + def __sub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rsub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __isub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rmod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __imod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + def __pow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rpow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __ipow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> imvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> imvec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> imvec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: imvec3) -> Tuple[imvec3, imvec3]: ... + + + +class imvec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xz(self) -> i32vec2: ... + @xz.setter + def xz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zx(self) -> i32vec2: ... + @zx.setter + def zx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xw(self) -> i32vec2: ... + @xw.setter + def xw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wx(self) -> i32vec2: ... + @wx.setter + def wx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yz(self) -> i32vec2: ... + @yz.setter + def yz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zy(self) -> i32vec2: ... + @zy.setter + def zy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yw(self) -> i32vec2: ... + @yw.setter + def yw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wy(self) -> i32vec2: ... + @wy.setter + def wy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zw(self) -> i32vec2: ... + @zw.setter + def zw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wz(self) -> i32vec2: ... + @wz.setter + def wz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xyz(self) -> i32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzy(self) -> i32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxz(self) -> i32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzx(self) -> i32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxy(self) -> i32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyx(self) -> i32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xyw(self) -> i32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xwy(self) -> i32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxw(self) -> i32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def ywx(self) -> i32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wxy(self) -> i32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wyx(self) -> i32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzw(self) -> i32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xwz(self) -> i32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxw(self) -> i32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zwx(self) -> i32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wxz(self) -> i32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wzx(self) -> i32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzw(self) -> i32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def ywz(self) -> i32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyw(self) -> i32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zwy(self) -> i32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wyz(self) -> i32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wzy(self) -> i32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xyzw(self) -> i32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xywz(self) -> i32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xzyw(self) -> i32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xzwy(self) -> i32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xwyz(self) -> i32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xwzy(self) -> i32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yxzw(self) -> i32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yxwz(self) -> i32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yzxw(self) -> i32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yzwx(self) -> i32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def ywxz(self) -> i32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def ywzx(self) -> i32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zxyw(self) -> i32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zxwy(self) -> i32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zyxw(self) -> i32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zywx(self) -> i32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zwxy(self) -> i32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zwyx(self) -> i32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wxyz(self) -> i32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wxzy(self) -> i32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wyxz(self) -> i32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wyzx(self) -> i32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wzxy(self) -> i32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wzyx(self) -> i32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> imvec4: ... + def __pos__(self) -> imvec4: ... + def __abs__(self) -> imvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imvec4: ... + + def __add__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __radd__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __iadd__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + def __sub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rsub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __isub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rmod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __imod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + def __pow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rpow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __ipow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> imvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> imvec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> imvec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: imvec4) -> Tuple[imvec4, imvec4]: ... + + +i32vec1 = ivec1 + +class ivec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.IAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> ivec1: ... + def __pos__(self) -> ivec1: ... + def __abs__(self) -> ivec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> ivec1: ... + + def __add__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __radd__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __iadd__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + def __sub__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rsub__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __isub__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __mul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __imul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rmod__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __imod__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + def __pow__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rpow__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __ipow__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector1, glm_typing.Number]) -> ivec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> ivec1: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: ivec1) -> Tuple[ivec1, ivec1]: ... + + +i32vec2 = ivec2 + +class ivec2: + x: int + y: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.IAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> ivec2: ... + def __pos__(self) -> ivec2: ... + def __abs__(self) -> ivec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> ivec2: ... + + def __add__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __radd__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __iadd__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + def __sub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rsub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __isub__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rmod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __imod__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + def __pow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rpow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __ipow__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector2, glm_typing.Number]) -> ivec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: ivec2) -> Tuple[ivec2, ivec2]: ... + + +i32vec3 = ivec3 + +class ivec3: + x: int + y: int + z: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xz(self) -> i32vec2: ... + @xz.setter + def xz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zx(self) -> i32vec2: ... + @zx.setter + def zx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yz(self) -> i32vec2: ... + @yz.setter + def yz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zy(self) -> i32vec2: ... + @zy.setter + def zy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xyz(self) -> i32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzy(self) -> i32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxz(self) -> i32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzx(self) -> i32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxy(self) -> i32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyx(self) -> i32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.IAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> ivec3: ... + def __pos__(self) -> ivec3: ... + def __abs__(self) -> ivec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> ivec3: ... + + def __add__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __radd__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __iadd__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + def __sub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rsub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __isub__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rmod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __imod__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + def __pow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rpow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __ipow__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector3, glm_typing.Number]) -> ivec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: ivec3) -> Tuple[ivec3, ivec3]: ... + + +i32vec4 = ivec4 + +class ivec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> i32vec2: ... + @xy.setter + def xy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yx(self) -> i32vec2: ... + @yx.setter + def yx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xz(self) -> i32vec2: ... + @xz.setter + def xz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zx(self) -> i32vec2: ... + @zx.setter + def zx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xw(self) -> i32vec2: ... + @xw.setter + def xw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wx(self) -> i32vec2: ... + @wx.setter + def wx(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yz(self) -> i32vec2: ... + @yz.setter + def yz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zy(self) -> i32vec2: ... + @zy.setter + def zy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def yw(self) -> i32vec2: ... + @yw.setter + def yw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wy(self) -> i32vec2: ... + @wy.setter + def wy(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def zw(self) -> i32vec2: ... + @zw.setter + def zw(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def wz(self) -> i32vec2: ... + @wz.setter + def wz(self, value: glm_typing.I32Vector2) -> None: ... + + @property + def xyz(self) -> i32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzy(self) -> i32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxz(self) -> i32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzx(self) -> i32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxy(self) -> i32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyx(self) -> i32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xyw(self) -> i32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xwy(self) -> i32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yxw(self) -> i32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def ywx(self) -> i32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wxy(self) -> i32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wyx(self) -> i32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xzw(self) -> i32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xwz(self) -> i32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zxw(self) -> i32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zwx(self) -> i32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wxz(self) -> i32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wzx(self) -> i32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def yzw(self) -> i32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def ywz(self) -> i32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zyw(self) -> i32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def zwy(self) -> i32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wyz(self) -> i32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def wzy(self) -> i32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.I32Vector3) -> None: ... + + @property + def xyzw(self) -> i32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xywz(self) -> i32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xzyw(self) -> i32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xzwy(self) -> i32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xwyz(self) -> i32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def xwzy(self) -> i32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yxzw(self) -> i32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yxwz(self) -> i32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yzxw(self) -> i32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def yzwx(self) -> i32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def ywxz(self) -> i32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def ywzx(self) -> i32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zxyw(self) -> i32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zxwy(self) -> i32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zyxw(self) -> i32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zywx(self) -> i32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zwxy(self) -> i32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def zwyx(self) -> i32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wxyz(self) -> i32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wxzy(self) -> i32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wyxz(self) -> i32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wyzx(self) -> i32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wzxy(self) -> i32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.I32Vector4) -> None: ... + + @property + def wzyx(self) -> i32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.I32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> ivec4: ... + def __pos__(self) -> ivec4: ... + def __abs__(self) -> ivec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> ivec4: ... + + def __add__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __radd__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __iadd__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + def __sub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rsub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __isub__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rmod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __imod__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + def __pow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rpow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __ipow__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + def __truediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rtruediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __itruediv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + def __floordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __rfloordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + def __ifloordiv__(self, other: Union[glm_typing.I32Vector4, glm_typing.Number]) -> ivec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: ivec4) -> Tuple[ivec4, ivec4]: ... + + + +class mvec2: + x: float + y: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.FAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> mvec2: ... + def __pos__(self) -> mvec2: ... + def __abs__(self) -> mvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mvec2: ... + + def __add__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __radd__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __iadd__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + def __sub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rsub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __isub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rmod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __imod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + def __pow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rpow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __ipow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> mvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> mvec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> mvec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: mvec2) -> Tuple[mvec2, mvec2]: ... + + + +class mvec3: + x: float + y: float + z: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xz(self) -> f32vec2: ... + @xz.setter + def xz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zx(self) -> f32vec2: ... + @zx.setter + def zx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yz(self) -> f32vec2: ... + @yz.setter + def yz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zy(self) -> f32vec2: ... + @zy.setter + def zy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xyz(self) -> f32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzy(self) -> f32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxz(self) -> f32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzx(self) -> f32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxy(self) -> f32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyx(self) -> f32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.F32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> mvec3: ... + def __pos__(self) -> mvec3: ... + def __abs__(self) -> mvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mvec3: ... + + def __add__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __radd__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __iadd__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + def __sub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rsub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __isub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rmod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __imod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + def __pow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rpow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __ipow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> mvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> mvec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> mvec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: mvec3) -> Tuple[mvec3, mvec3]: ... + + + +class mvec4: + x: float + y: float + z: float + w: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xz(self) -> f32vec2: ... + @xz.setter + def xz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zx(self) -> f32vec2: ... + @zx.setter + def zx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xw(self) -> f32vec2: ... + @xw.setter + def xw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wx(self) -> f32vec2: ... + @wx.setter + def wx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yz(self) -> f32vec2: ... + @yz.setter + def yz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zy(self) -> f32vec2: ... + @zy.setter + def zy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yw(self) -> f32vec2: ... + @yw.setter + def yw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wy(self) -> f32vec2: ... + @wy.setter + def wy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zw(self) -> f32vec2: ... + @zw.setter + def zw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wz(self) -> f32vec2: ... + @wz.setter + def wz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xyz(self) -> f32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzy(self) -> f32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxz(self) -> f32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzx(self) -> f32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxy(self) -> f32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyx(self) -> f32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xyw(self) -> f32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xwy(self) -> f32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxw(self) -> f32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def ywx(self) -> f32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wxy(self) -> f32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wyx(self) -> f32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzw(self) -> f32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xwz(self) -> f32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxw(self) -> f32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zwx(self) -> f32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wxz(self) -> f32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wzx(self) -> f32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzw(self) -> f32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def ywz(self) -> f32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyw(self) -> f32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zwy(self) -> f32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wyz(self) -> f32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wzy(self) -> f32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xyzw(self) -> f32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xywz(self) -> f32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xzyw(self) -> f32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xzwy(self) -> f32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xwyz(self) -> f32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xwzy(self) -> f32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yxzw(self) -> f32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yxwz(self) -> f32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yzxw(self) -> f32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yzwx(self) -> f32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def ywxz(self) -> f32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def ywzx(self) -> f32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zxyw(self) -> f32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zxwy(self) -> f32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zyxw(self) -> f32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zywx(self) -> f32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zwxy(self) -> f32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zwyx(self) -> f32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wxyz(self) -> f32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wxzy(self) -> f32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wyxz(self) -> f32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wyzx(self) -> f32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wzxy(self) -> f32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wzyx(self) -> f32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.F32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> mvec4: ... + def __pos__(self) -> mvec4: ... + def __abs__(self) -> mvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mvec4: ... + + def __add__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __radd__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __iadd__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + def __sub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rsub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __isub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rmod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __imod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + def __pow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rpow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __ipow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> mvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> mvec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> mvec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: mvec4) -> Tuple[mvec4, mvec4]: ... + + + +class u16vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.UAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u16vec1: ... + def __pos__(self) -> u16vec1: ... + def __abs__(self) -> u16vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u16vec1: ... + + def __add__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __radd__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __iadd__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + def __sub__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rsub__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __isub__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __mul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __rmul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __imul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + + def __mod__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rmod__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __imod__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + def __pow__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rpow__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __ipow__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + def __truediv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rtruediv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __itruediv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + def __floordiv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.U16Vector1, glm_typing.Number]) -> u16vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __matmul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u16vec1: ... + @overload + def __imatmul__(self, other: glm_typing.U16Vector1) -> u16vec1: ... + + def __divmod__(self, other: u16vec1) -> Tuple[u16vec1, u16vec1]: ... + + + +class u16vec2: + x: int + y: int + + + @property + def xy(self) -> u16vec2: ... + @xy.setter + def xy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yx(self) -> u16vec2: ... + @yx.setter + def yx(self, value: glm_typing.U16Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u16vec2: ... + def __pos__(self) -> u16vec2: ... + def __abs__(self) -> u16vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u16vec2: ... + + def __add__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __radd__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __iadd__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + def __sub__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rsub__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __isub__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __mul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __rmul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __imul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + + def __mod__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rmod__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __imod__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + def __pow__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rpow__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __ipow__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + def __truediv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rtruediv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __itruediv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + def __floordiv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U16Vector2, glm_typing.Number]) -> u16vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __matmul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u16vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U16Vector2) -> u16vec2: ... + + def __divmod__(self, other: u16vec2) -> Tuple[u16vec2, u16vec2]: ... + + + +class u16vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u16vec2: ... + @xy.setter + def xy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yx(self) -> u16vec2: ... + @yx.setter + def yx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xz(self) -> u16vec2: ... + @xz.setter + def xz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zx(self) -> u16vec2: ... + @zx.setter + def zx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yz(self) -> u16vec2: ... + @yz.setter + def yz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zy(self) -> u16vec2: ... + @zy.setter + def zy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xyz(self) -> u16vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xzy(self) -> u16vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yxz(self) -> u16vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yzx(self) -> u16vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zxy(self) -> u16vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zyx(self) -> u16vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U16Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u16vec3: ... + def __pos__(self) -> u16vec3: ... + def __abs__(self) -> u16vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u16vec3: ... + + def __add__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __radd__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __iadd__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + def __sub__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rsub__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __isub__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __mul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __rmul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __imul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + + def __mod__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rmod__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __imod__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + def __pow__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rpow__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __ipow__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + def __truediv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rtruediv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __itruediv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + def __floordiv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U16Vector3, glm_typing.Number]) -> u16vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __matmul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u16vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U16Vector3) -> u16vec3: ... + + def __divmod__(self, other: u16vec3) -> Tuple[u16vec3, u16vec3]: ... + + + +class u16vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u16vec2: ... + @xy.setter + def xy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yx(self) -> u16vec2: ... + @yx.setter + def yx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xz(self) -> u16vec2: ... + @xz.setter + def xz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zx(self) -> u16vec2: ... + @zx.setter + def zx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xw(self) -> u16vec2: ... + @xw.setter + def xw(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def wx(self) -> u16vec2: ... + @wx.setter + def wx(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yz(self) -> u16vec2: ... + @yz.setter + def yz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zy(self) -> u16vec2: ... + @zy.setter + def zy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def yw(self) -> u16vec2: ... + @yw.setter + def yw(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def wy(self) -> u16vec2: ... + @wy.setter + def wy(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def zw(self) -> u16vec2: ... + @zw.setter + def zw(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def wz(self) -> u16vec2: ... + @wz.setter + def wz(self, value: glm_typing.U16Vector2) -> None: ... + + @property + def xyz(self) -> u16vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xzy(self) -> u16vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yxz(self) -> u16vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yzx(self) -> u16vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zxy(self) -> u16vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zyx(self) -> u16vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xyw(self) -> u16vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xwy(self) -> u16vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yxw(self) -> u16vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def ywx(self) -> u16vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wxy(self) -> u16vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wyx(self) -> u16vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xzw(self) -> u16vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xwz(self) -> u16vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zxw(self) -> u16vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zwx(self) -> u16vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wxz(self) -> u16vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wzx(self) -> u16vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def yzw(self) -> u16vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def ywz(self) -> u16vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zyw(self) -> u16vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def zwy(self) -> u16vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wyz(self) -> u16vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def wzy(self) -> u16vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U16Vector3) -> None: ... + + @property + def xyzw(self) -> u16vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xywz(self) -> u16vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xzyw(self) -> u16vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xzwy(self) -> u16vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xwyz(self) -> u16vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def xwzy(self) -> u16vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def yxzw(self) -> u16vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def yxwz(self) -> u16vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def yzxw(self) -> u16vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def yzwx(self) -> u16vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def ywxz(self) -> u16vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def ywzx(self) -> u16vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zxyw(self) -> u16vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zxwy(self) -> u16vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zyxw(self) -> u16vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zywx(self) -> u16vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zwxy(self) -> u16vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def zwyx(self) -> u16vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wxyz(self) -> u16vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wxzy(self) -> u16vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wyxz(self) -> u16vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wyzx(self) -> u16vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wzxy(self) -> u16vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U16Vector4) -> None: ... + + @property + def wzyx(self) -> u16vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U16Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u16vec4: ... + def __pos__(self) -> u16vec4: ... + def __abs__(self) -> u16vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u16vec4: ... + + def __add__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __radd__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __iadd__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + def __sub__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rsub__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __isub__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __mul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __rmul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __imul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + + def __mod__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rmod__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __imod__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + def __pow__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rpow__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __ipow__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + def __truediv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rtruediv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __itruediv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + def __floordiv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U16Vector4, glm_typing.Number]) -> u16vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __matmul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u16vec4: ... + @overload + def __imatmul__(self, other: glm_typing.U16Vector4) -> u16vec4: ... + + def __divmod__(self, other: u16vec4) -> Tuple[u16vec4, u16vec4]: ... + + + +class u64vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.UAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u64vec1: ... + def __pos__(self) -> u64vec1: ... + def __abs__(self) -> u64vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u64vec1: ... + + def __add__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __radd__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __iadd__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + def __sub__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rsub__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __isub__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __mul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __rmul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __imul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + + def __mod__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rmod__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __imod__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + def __pow__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rpow__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __ipow__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + def __truediv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rtruediv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __itruediv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + def __floordiv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.U64Vector1, glm_typing.Number]) -> u64vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __matmul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u64vec1: ... + @overload + def __imatmul__(self, other: glm_typing.U64Vector1) -> u64vec1: ... + + def __divmod__(self, other: u64vec1) -> Tuple[u64vec1, u64vec1]: ... + + + +class u64vec2: + x: int + y: int + + + @property + def xy(self) -> u64vec2: ... + @xy.setter + def xy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yx(self) -> u64vec2: ... + @yx.setter + def yx(self, value: glm_typing.U64Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u64vec2: ... + def __pos__(self) -> u64vec2: ... + def __abs__(self) -> u64vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u64vec2: ... + + def __add__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __radd__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __iadd__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + def __sub__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rsub__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __isub__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __mul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __rmul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __imul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + + def __mod__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rmod__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __imod__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + def __pow__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rpow__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __ipow__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + def __truediv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rtruediv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __itruediv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + def __floordiv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U64Vector2, glm_typing.Number]) -> u64vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __matmul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u64vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U64Vector2) -> u64vec2: ... + + def __divmod__(self, other: u64vec2) -> Tuple[u64vec2, u64vec2]: ... + + + +class u64vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u64vec2: ... + @xy.setter + def xy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yx(self) -> u64vec2: ... + @yx.setter + def yx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xz(self) -> u64vec2: ... + @xz.setter + def xz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zx(self) -> u64vec2: ... + @zx.setter + def zx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yz(self) -> u64vec2: ... + @yz.setter + def yz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zy(self) -> u64vec2: ... + @zy.setter + def zy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xyz(self) -> u64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xzy(self) -> u64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yxz(self) -> u64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yzx(self) -> u64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zxy(self) -> u64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zyx(self) -> u64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U64Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u64vec3: ... + def __pos__(self) -> u64vec3: ... + def __abs__(self) -> u64vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u64vec3: ... + + def __add__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __radd__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __iadd__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + def __sub__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rsub__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __isub__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __mul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __rmul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __imul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + + def __mod__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rmod__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __imod__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + def __pow__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rpow__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __ipow__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + def __truediv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rtruediv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __itruediv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + def __floordiv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U64Vector3, glm_typing.Number]) -> u64vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __matmul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u64vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U64Vector3) -> u64vec3: ... + + def __divmod__(self, other: u64vec3) -> Tuple[u64vec3, u64vec3]: ... + + + +class u64vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u64vec2: ... + @xy.setter + def xy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yx(self) -> u64vec2: ... + @yx.setter + def yx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xz(self) -> u64vec2: ... + @xz.setter + def xz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zx(self) -> u64vec2: ... + @zx.setter + def zx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xw(self) -> u64vec2: ... + @xw.setter + def xw(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def wx(self) -> u64vec2: ... + @wx.setter + def wx(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yz(self) -> u64vec2: ... + @yz.setter + def yz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zy(self) -> u64vec2: ... + @zy.setter + def zy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def yw(self) -> u64vec2: ... + @yw.setter + def yw(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def wy(self) -> u64vec2: ... + @wy.setter + def wy(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def zw(self) -> u64vec2: ... + @zw.setter + def zw(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def wz(self) -> u64vec2: ... + @wz.setter + def wz(self, value: glm_typing.U64Vector2) -> None: ... + + @property + def xyz(self) -> u64vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xzy(self) -> u64vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yxz(self) -> u64vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yzx(self) -> u64vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zxy(self) -> u64vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zyx(self) -> u64vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xyw(self) -> u64vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xwy(self) -> u64vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yxw(self) -> u64vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def ywx(self) -> u64vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wxy(self) -> u64vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wyx(self) -> u64vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xzw(self) -> u64vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xwz(self) -> u64vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zxw(self) -> u64vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zwx(self) -> u64vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wxz(self) -> u64vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wzx(self) -> u64vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def yzw(self) -> u64vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def ywz(self) -> u64vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zyw(self) -> u64vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def zwy(self) -> u64vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wyz(self) -> u64vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def wzy(self) -> u64vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U64Vector3) -> None: ... + + @property + def xyzw(self) -> u64vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xywz(self) -> u64vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xzyw(self) -> u64vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xzwy(self) -> u64vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xwyz(self) -> u64vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def xwzy(self) -> u64vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def yxzw(self) -> u64vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def yxwz(self) -> u64vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def yzxw(self) -> u64vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def yzwx(self) -> u64vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def ywxz(self) -> u64vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def ywzx(self) -> u64vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zxyw(self) -> u64vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zxwy(self) -> u64vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zyxw(self) -> u64vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zywx(self) -> u64vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zwxy(self) -> u64vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def zwyx(self) -> u64vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wxyz(self) -> u64vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wxzy(self) -> u64vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wyxz(self) -> u64vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wyzx(self) -> u64vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wzxy(self) -> u64vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U64Vector4) -> None: ... + + @property + def wzyx(self) -> u64vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U64Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u64vec4: ... + def __pos__(self) -> u64vec4: ... + def __abs__(self) -> u64vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u64vec4: ... + + def __add__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __radd__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __iadd__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + def __sub__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rsub__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __isub__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __mul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __rmul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __imul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + + def __mod__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rmod__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __imod__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + def __pow__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rpow__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __ipow__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + def __truediv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rtruediv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __itruediv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + def __floordiv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U64Vector4, glm_typing.Number]) -> u64vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __matmul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u64vec4: ... + @overload + def __imatmul__(self, other: glm_typing.U64Vector4) -> u64vec4: ... + + def __divmod__(self, other: u64vec4) -> Tuple[u64vec4, u64vec4]: ... + + + +class u8vec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.UAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u8vec1: ... + def __pos__(self) -> u8vec1: ... + def __abs__(self) -> u8vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u8vec1: ... + + def __add__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __radd__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __iadd__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + def __sub__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rsub__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __isub__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __mul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __rmul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __imul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + + def __mod__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rmod__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __imod__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + def __pow__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rpow__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __ipow__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + def __truediv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rtruediv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __itruediv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + def __floordiv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.U8Vector1, glm_typing.Number]) -> u8vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __matmul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u8vec1: ... + @overload + def __imatmul__(self, other: glm_typing.U8Vector1) -> u8vec1: ... + + def __divmod__(self, other: u8vec1) -> Tuple[u8vec1, u8vec1]: ... + + + +class u8vec2: + x: int + y: int + + + @property + def xy(self) -> u8vec2: ... + @xy.setter + def xy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yx(self) -> u8vec2: ... + @yx.setter + def yx(self, value: glm_typing.U8Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u8vec2: ... + def __pos__(self) -> u8vec2: ... + def __abs__(self) -> u8vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u8vec2: ... + + def __add__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __radd__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __iadd__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + def __sub__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rsub__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __isub__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __mul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __rmul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __imul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + + def __mod__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rmod__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __imod__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + def __pow__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rpow__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __ipow__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + def __truediv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rtruediv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __itruediv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + def __floordiv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U8Vector2, glm_typing.Number]) -> u8vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __matmul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u8vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U8Vector2) -> u8vec2: ... + + def __divmod__(self, other: u8vec2) -> Tuple[u8vec2, u8vec2]: ... + + + +class u8vec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u8vec2: ... + @xy.setter + def xy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yx(self) -> u8vec2: ... + @yx.setter + def yx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xz(self) -> u8vec2: ... + @xz.setter + def xz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zx(self) -> u8vec2: ... + @zx.setter + def zx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yz(self) -> u8vec2: ... + @yz.setter + def yz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zy(self) -> u8vec2: ... + @zy.setter + def zy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xyz(self) -> u8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xzy(self) -> u8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yxz(self) -> u8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yzx(self) -> u8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zxy(self) -> u8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zyx(self) -> u8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U8Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u8vec3: ... + def __pos__(self) -> u8vec3: ... + def __abs__(self) -> u8vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u8vec3: ... + + def __add__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __radd__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __iadd__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + def __sub__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rsub__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __isub__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __mul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __rmul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __imul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + + def __mod__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rmod__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __imod__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + def __pow__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rpow__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __ipow__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + def __truediv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rtruediv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __itruediv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + def __floordiv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U8Vector3, glm_typing.Number]) -> u8vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __matmul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u8vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U8Vector3) -> u8vec3: ... + + def __divmod__(self, other: u8vec3) -> Tuple[u8vec3, u8vec3]: ... + + + +class u8vec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u8vec2: ... + @xy.setter + def xy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yx(self) -> u8vec2: ... + @yx.setter + def yx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xz(self) -> u8vec2: ... + @xz.setter + def xz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zx(self) -> u8vec2: ... + @zx.setter + def zx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xw(self) -> u8vec2: ... + @xw.setter + def xw(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def wx(self) -> u8vec2: ... + @wx.setter + def wx(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yz(self) -> u8vec2: ... + @yz.setter + def yz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zy(self) -> u8vec2: ... + @zy.setter + def zy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def yw(self) -> u8vec2: ... + @yw.setter + def yw(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def wy(self) -> u8vec2: ... + @wy.setter + def wy(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def zw(self) -> u8vec2: ... + @zw.setter + def zw(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def wz(self) -> u8vec2: ... + @wz.setter + def wz(self, value: glm_typing.U8Vector2) -> None: ... + + @property + def xyz(self) -> u8vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xzy(self) -> u8vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yxz(self) -> u8vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yzx(self) -> u8vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zxy(self) -> u8vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zyx(self) -> u8vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xyw(self) -> u8vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xwy(self) -> u8vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yxw(self) -> u8vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def ywx(self) -> u8vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wxy(self) -> u8vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wyx(self) -> u8vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xzw(self) -> u8vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xwz(self) -> u8vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zxw(self) -> u8vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zwx(self) -> u8vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wxz(self) -> u8vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wzx(self) -> u8vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def yzw(self) -> u8vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def ywz(self) -> u8vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zyw(self) -> u8vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def zwy(self) -> u8vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wyz(self) -> u8vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def wzy(self) -> u8vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U8Vector3) -> None: ... + + @property + def xyzw(self) -> u8vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xywz(self) -> u8vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xzyw(self) -> u8vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xzwy(self) -> u8vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xwyz(self) -> u8vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def xwzy(self) -> u8vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def yxzw(self) -> u8vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def yxwz(self) -> u8vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def yzxw(self) -> u8vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def yzwx(self) -> u8vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def ywxz(self) -> u8vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def ywzx(self) -> u8vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zxyw(self) -> u8vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zxwy(self) -> u8vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zyxw(self) -> u8vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zywx(self) -> u8vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zwxy(self) -> u8vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def zwyx(self) -> u8vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wxyz(self) -> u8vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wxzy(self) -> u8vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wyxz(self) -> u8vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wyzx(self) -> u8vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wzxy(self) -> u8vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U8Vector4) -> None: ... + + @property + def wzyx(self) -> u8vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U8Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> u8vec4: ... + def __pos__(self) -> u8vec4: ... + def __abs__(self) -> u8vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> u8vec4: ... + + def __add__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __radd__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __iadd__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + def __sub__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rsub__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __isub__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __mul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __rmul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __imul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + + def __mod__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rmod__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __imod__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + def __pow__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rpow__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __ipow__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + def __truediv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rtruediv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __itruediv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + def __floordiv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U8Vector4, glm_typing.Number]) -> u8vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __matmul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> u8vec4: ... + @overload + def __imatmul__(self, other: glm_typing.U8Vector4) -> u8vec4: ... + + def __divmod__(self, other: u8vec4) -> Tuple[u8vec4, u8vec4]: ... + + + +class umvec2: + x: int + y: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> umvec2: ... + def __pos__(self) -> umvec2: ... + def __abs__(self) -> umvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umvec2: ... + + def __add__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __radd__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __iadd__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + def __sub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rsub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __isub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rmod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __imod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + def __pow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rpow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __ipow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> umvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> umvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> umvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: umvec2) -> Tuple[umvec2, umvec2]: ... + + + +class umvec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xz(self) -> u32vec2: ... + @xz.setter + def xz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zx(self) -> u32vec2: ... + @zx.setter + def zx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yz(self) -> u32vec2: ... + @yz.setter + def yz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zy(self) -> u32vec2: ... + @zy.setter + def zy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xyz(self) -> u32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzy(self) -> u32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxz(self) -> u32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzx(self) -> u32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxy(self) -> u32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyx(self) -> u32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> umvec3: ... + def __pos__(self) -> umvec3: ... + def __abs__(self) -> umvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umvec3: ... + + def __add__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __radd__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __iadd__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + def __sub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rsub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __isub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rmod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __imod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + def __pow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rpow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __ipow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> umvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> umvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> umvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: umvec3) -> Tuple[umvec3, umvec3]: ... + + + +class umvec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xz(self) -> u32vec2: ... + @xz.setter + def xz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zx(self) -> u32vec2: ... + @zx.setter + def zx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xw(self) -> u32vec2: ... + @xw.setter + def xw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wx(self) -> u32vec2: ... + @wx.setter + def wx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yz(self) -> u32vec2: ... + @yz.setter + def yz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zy(self) -> u32vec2: ... + @zy.setter + def zy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yw(self) -> u32vec2: ... + @yw.setter + def yw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wy(self) -> u32vec2: ... + @wy.setter + def wy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zw(self) -> u32vec2: ... + @zw.setter + def zw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wz(self) -> u32vec2: ... + @wz.setter + def wz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xyz(self) -> u32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzy(self) -> u32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxz(self) -> u32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzx(self) -> u32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxy(self) -> u32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyx(self) -> u32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xyw(self) -> u32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xwy(self) -> u32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxw(self) -> u32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def ywx(self) -> u32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wxy(self) -> u32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wyx(self) -> u32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzw(self) -> u32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xwz(self) -> u32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxw(self) -> u32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zwx(self) -> u32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wxz(self) -> u32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wzx(self) -> u32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzw(self) -> u32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def ywz(self) -> u32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyw(self) -> u32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zwy(self) -> u32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wyz(self) -> u32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wzy(self) -> u32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xyzw(self) -> u32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xywz(self) -> u32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xzyw(self) -> u32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xzwy(self) -> u32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xwyz(self) -> u32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xwzy(self) -> u32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yxzw(self) -> u32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yxwz(self) -> u32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yzxw(self) -> u32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yzwx(self) -> u32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def ywxz(self) -> u32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def ywzx(self) -> u32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zxyw(self) -> u32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zxwy(self) -> u32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zyxw(self) -> u32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zywx(self) -> u32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zwxy(self) -> u32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zwyx(self) -> u32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wxyz(self) -> u32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wxzy(self) -> u32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wyxz(self) -> u32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wyzx(self) -> u32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wzxy(self) -> u32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wzyx(self) -> u32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> umvec4: ... + def __pos__(self) -> umvec4: ... + def __abs__(self) -> umvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umvec4: ... + + def __add__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __radd__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __iadd__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + def __sub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rsub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __isub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rmod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __imod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + def __pow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rpow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __ipow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> umvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> umvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> umvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: umvec4) -> Tuple[umvec4, umvec4]: ... + + +u32vec1 = uvec1 + +class uvec1: + x: int + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.UAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> uvec1: ... + def __pos__(self) -> uvec1: ... + def __abs__(self) -> uvec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> uvec1: ... + + def __add__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __radd__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __iadd__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + def __sub__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rsub__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __isub__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __mul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __imul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rmod__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __imod__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + def __pow__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rpow__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __ipow__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector1, glm_typing.Number]) -> uvec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> uvec1: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: uvec1) -> Tuple[uvec1, uvec1]: ... + + +u32vec2 = uvec2 + +class uvec2: + x: int + y: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.UAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> uvec2: ... + def __pos__(self) -> uvec2: ... + def __abs__(self) -> uvec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> uvec2: ... + + def __add__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __radd__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __iadd__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + def __sub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rsub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __isub__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rmod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __imod__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + def __pow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rpow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __ipow__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector2, glm_typing.Number]) -> uvec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: uvec2) -> Tuple[uvec2, uvec2]: ... + + +u32vec3 = uvec3 + +class uvec3: + x: int + y: int + z: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xz(self) -> u32vec2: ... + @xz.setter + def xz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zx(self) -> u32vec2: ... + @zx.setter + def zx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yz(self) -> u32vec2: ... + @yz.setter + def yz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zy(self) -> u32vec2: ... + @zy.setter + def zy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xyz(self) -> u32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzy(self) -> u32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxz(self) -> u32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzx(self) -> u32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxy(self) -> u32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyx(self) -> u32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.UAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> uvec3: ... + def __pos__(self) -> uvec3: ... + def __abs__(self) -> uvec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> uvec3: ... + + def __add__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __radd__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __iadd__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + def __sub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rsub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __isub__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rmod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __imod__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + def __pow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rpow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __ipow__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector3, glm_typing.Number]) -> uvec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: uvec3) -> Tuple[uvec3, uvec3]: ... + + +u32vec4 = uvec4 + +class uvec4: + x: int + y: int + z: int + w: int + + + @property + def xy(self) -> u32vec2: ... + @xy.setter + def xy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yx(self) -> u32vec2: ... + @yx.setter + def yx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xz(self) -> u32vec2: ... + @xz.setter + def xz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zx(self) -> u32vec2: ... + @zx.setter + def zx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xw(self) -> u32vec2: ... + @xw.setter + def xw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wx(self) -> u32vec2: ... + @wx.setter + def wx(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yz(self) -> u32vec2: ... + @yz.setter + def yz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zy(self) -> u32vec2: ... + @zy.setter + def zy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def yw(self) -> u32vec2: ... + @yw.setter + def yw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wy(self) -> u32vec2: ... + @wy.setter + def wy(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def zw(self) -> u32vec2: ... + @zw.setter + def zw(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def wz(self) -> u32vec2: ... + @wz.setter + def wz(self, value: glm_typing.U32Vector2) -> None: ... + + @property + def xyz(self) -> u32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzy(self) -> u32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxz(self) -> u32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzx(self) -> u32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxy(self) -> u32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyx(self) -> u32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xyw(self) -> u32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xwy(self) -> u32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yxw(self) -> u32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def ywx(self) -> u32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wxy(self) -> u32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wyx(self) -> u32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xzw(self) -> u32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xwz(self) -> u32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zxw(self) -> u32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zwx(self) -> u32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wxz(self) -> u32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wzx(self) -> u32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def yzw(self) -> u32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def ywz(self) -> u32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zyw(self) -> u32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def zwy(self) -> u32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wyz(self) -> u32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def wzy(self) -> u32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.U32Vector3) -> None: ... + + @property + def xyzw(self) -> u32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xywz(self) -> u32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xzyw(self) -> u32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xzwy(self) -> u32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xwyz(self) -> u32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def xwzy(self) -> u32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yxzw(self) -> u32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yxwz(self) -> u32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yzxw(self) -> u32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def yzwx(self) -> u32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def ywxz(self) -> u32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def ywzx(self) -> u32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zxyw(self) -> u32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zxwy(self) -> u32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zyxw(self) -> u32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zywx(self) -> u32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zwxy(self) -> u32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def zwyx(self) -> u32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wxyz(self) -> u32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wxzy(self) -> u32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wyxz(self) -> u32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wyzx(self) -> u32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wzxy(self) -> u32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.U32Vector4) -> None: ... + + @property + def wzyx(self) -> u32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.U32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> int: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[int, None, None]: ... + + def __neg__(self) -> uvec4: ... + def __pos__(self) -> uvec4: ... + def __abs__(self) -> uvec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[int]: ... + def to_tuple(self) -> Tuple[int, int, int, int]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> uvec4: ... + + def __add__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __radd__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __iadd__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + def __sub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rsub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __isub__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rmod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __imod__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + def __pow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rpow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __ipow__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + def __truediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rtruediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __itruediv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + def __floordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __rfloordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + def __ifloordiv__(self, other: Union[glm_typing.U32Vector4, glm_typing.Number]) -> uvec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: uvec4) -> Tuple[uvec4, uvec4]: ... + + +f32vec1 = vec1 +fvec1 = vec1 + +class vec1: + x: float + + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector1, glm_typing.FAnyVector2, glm_typing.FAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[1]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> vec1: ... + def __pos__(self) -> vec1: ... + def __abs__(self) -> vec1: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> vec1: ... + + def __add__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __radd__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __iadd__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + def __sub__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rsub__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __isub__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __mul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __imul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rmod__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __imod__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + def __pow__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rpow__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __ipow__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector1, glm_typing.Number]) -> vec1: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> vec1: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: vec1) -> Tuple[vec1, vec1]: ... + + +f32vec2 = vec2 +fvec2 = vec2 + +class vec2: + x: float + y: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector2, glm_typing.FAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[2]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> vec2: ... + def __pos__(self) -> vec2: ... + def __abs__(self) -> vec2: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> vec2: ... + + def __add__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __radd__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __iadd__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + def __sub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rsub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __isub__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rmod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __imod__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + def __pow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rpow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __ipow__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector2, glm_typing.Number]) -> vec2: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: vec2) -> Tuple[vec2, vec2]: ... + + +f32vec3 = vec3 +fvec3 = vec3 + +class vec3: + x: float + y: float + z: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xz(self) -> f32vec2: ... + @xz.setter + def xz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zx(self) -> f32vec2: ... + @zx.setter + def zx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yz(self) -> f32vec2: ... + @yz.setter + def yz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zy(self) -> f32vec2: ... + @zy.setter + def zy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xyz(self) -> f32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzy(self) -> f32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxz(self) -> f32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzx(self) -> f32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxy(self) -> f32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyx(self) -> f32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.F32Vector3) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyVector3, glm_typing.FAnyVector4]) -> None: ... + + def __len__(self) -> Literal[3]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> vec3: ... + def __pos__(self) -> vec3: ... + def __abs__(self) -> vec3: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> vec3: ... + + def __add__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __radd__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __iadd__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + def __sub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rsub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __isub__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rmod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __imod__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + def __pow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rpow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __ipow__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector3, glm_typing.Number]) -> vec3: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: vec3) -> Tuple[vec3, vec3]: ... + + +f32vec4 = vec4 +fvec4 = vec4 + +class vec4: + x: float + y: float + z: float + w: float + + + @property + def xy(self) -> f32vec2: ... + @xy.setter + def xy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yx(self) -> f32vec2: ... + @yx.setter + def yx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xz(self) -> f32vec2: ... + @xz.setter + def xz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zx(self) -> f32vec2: ... + @zx.setter + def zx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xw(self) -> f32vec2: ... + @xw.setter + def xw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wx(self) -> f32vec2: ... + @wx.setter + def wx(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yz(self) -> f32vec2: ... + @yz.setter + def yz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zy(self) -> f32vec2: ... + @zy.setter + def zy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def yw(self) -> f32vec2: ... + @yw.setter + def yw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wy(self) -> f32vec2: ... + @wy.setter + def wy(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def zw(self) -> f32vec2: ... + @zw.setter + def zw(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def wz(self) -> f32vec2: ... + @wz.setter + def wz(self, value: glm_typing.F32Vector2) -> None: ... + + @property + def xyz(self) -> f32vec3: ... + @xyz.setter + def xyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzy(self) -> f32vec3: ... + @xzy.setter + def xzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxz(self) -> f32vec3: ... + @yxz.setter + def yxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzx(self) -> f32vec3: ... + @yzx.setter + def yzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxy(self) -> f32vec3: ... + @zxy.setter + def zxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyx(self) -> f32vec3: ... + @zyx.setter + def zyx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xyw(self) -> f32vec3: ... + @xyw.setter + def xyw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xwy(self) -> f32vec3: ... + @xwy.setter + def xwy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yxw(self) -> f32vec3: ... + @yxw.setter + def yxw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def ywx(self) -> f32vec3: ... + @ywx.setter + def ywx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wxy(self) -> f32vec3: ... + @wxy.setter + def wxy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wyx(self) -> f32vec3: ... + @wyx.setter + def wyx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xzw(self) -> f32vec3: ... + @xzw.setter + def xzw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xwz(self) -> f32vec3: ... + @xwz.setter + def xwz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zxw(self) -> f32vec3: ... + @zxw.setter + def zxw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zwx(self) -> f32vec3: ... + @zwx.setter + def zwx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wxz(self) -> f32vec3: ... + @wxz.setter + def wxz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wzx(self) -> f32vec3: ... + @wzx.setter + def wzx(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def yzw(self) -> f32vec3: ... + @yzw.setter + def yzw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def ywz(self) -> f32vec3: ... + @ywz.setter + def ywz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zyw(self) -> f32vec3: ... + @zyw.setter + def zyw(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def zwy(self) -> f32vec3: ... + @zwy.setter + def zwy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wyz(self) -> f32vec3: ... + @wyz.setter + def wyz(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def wzy(self) -> f32vec3: ... + @wzy.setter + def wzy(self, value: glm_typing.F32Vector3) -> None: ... + + @property + def xyzw(self) -> f32vec4: ... + @xyzw.setter + def xyzw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xywz(self) -> f32vec4: ... + @xywz.setter + def xywz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xzyw(self) -> f32vec4: ... + @xzyw.setter + def xzyw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xzwy(self) -> f32vec4: ... + @xzwy.setter + def xzwy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xwyz(self) -> f32vec4: ... + @xwyz.setter + def xwyz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def xwzy(self) -> f32vec4: ... + @xwzy.setter + def xwzy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yxzw(self) -> f32vec4: ... + @yxzw.setter + def yxzw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yxwz(self) -> f32vec4: ... + @yxwz.setter + def yxwz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yzxw(self) -> f32vec4: ... + @yzxw.setter + def yzxw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def yzwx(self) -> f32vec4: ... + @yzwx.setter + def yzwx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def ywxz(self) -> f32vec4: ... + @ywxz.setter + def ywxz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def ywzx(self) -> f32vec4: ... + @ywzx.setter + def ywzx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zxyw(self) -> f32vec4: ... + @zxyw.setter + def zxyw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zxwy(self) -> f32vec4: ... + @zxwy.setter + def zxwy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zyxw(self) -> f32vec4: ... + @zyxw.setter + def zyxw(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zywx(self) -> f32vec4: ... + @zywx.setter + def zywx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zwxy(self) -> f32vec4: ... + @zwxy.setter + def zwxy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def zwyx(self) -> f32vec4: ... + @zwyx.setter + def zwyx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wxyz(self) -> f32vec4: ... + @wxyz.setter + def wxyz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wxzy(self) -> f32vec4: ... + @wxzy.setter + def wxzy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wyxz(self) -> f32vec4: ... + @wyxz.setter + def wyxz(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wyzx(self) -> f32vec4: ... + @wyzx.setter + def wyzx(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wzxy(self) -> f32vec4: ... + @wzxy.setter + def wzxy(self, value: glm_typing.F32Vector4) -> None: ... + + @property + def wzyx(self) -> f32vec4: ... + @wzyx.setter + def wzyx(self, value: glm_typing.F32Vector4) -> None: ... + + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number, w: glm_typing.Number) -> None: ... + @overload + def __init__(self, x: glm_typing.AnyAnyVector4) -> None: ... + + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def __neg__(self) -> vec4: ... + def __pos__(self) -> vec4: ... + def __abs__(self) -> vec4: ... + + def __lt__(self, other: Any) -> bool: ... + def __le__(self, other: Any) -> bool: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + def __ge__(self, other: Any) -> bool: ... + def __gt__(self, other: Any) -> bool: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> vec4: ... + + def __add__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __radd__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __iadd__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + def __sub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rsub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __isub__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + @overload + def __mul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __mod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rmod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __imod__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + def __pow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rpow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __ipow__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + def __truediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rtruediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __itruediv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + def __floordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __rfloordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + def __ifloordiv__(self, other: Union[glm_typing.F32Vector4, glm_typing.Number]) -> vec4: ... + + @overload + def __matmul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.Number) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix2x2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix3x2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Matrix4x2) -> vec4: ... + + def __divmod__(self, other: vec4) -> Tuple[vec4, vec4]: ... + + +dmat2 = dmat2x2 +f64mat2 = dmat2x2 +f64mat2x2 = dmat2x2 + +class dmat2x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x2, glm_typing.DAnyMatrix2x2, glm_typing.DAnyMatrix2x3, glm_typing.DAnyMatrix2x4, glm_typing.DAnyMatrix3x2, glm_typing.DAnyMatrix3x3, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x2, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec2, dmvec2]) -> None: ... + + def __neg__(self) -> dmat2x2: ... + def __pos__(self) -> dmat2x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat2x2: ... + + def __add__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + def __radd__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + def __iadd__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + + def __sub__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + def __rsub__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + def __isub__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __mul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + + @overload + def __truediv__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __truediv__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rtruediv__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rtruediv__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __itruediv__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __itruediv__(self, other: glm_typing.D64Vector2) -> dvec2: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector1) -> dvec1: ... + + +f64mat2x3 = dmat2x3 + +class dmat2x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x3, glm_typing.DAnyMatrix2x3, glm_typing.DAnyMatrix2x4, glm_typing.DAnyMatrix3x3, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec3, dmvec3]) -> None: ... + + def __neg__(self) -> dmat2x3: ... + def __pos__(self) -> dmat2x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat2x3: ... + + def __add__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + def __radd__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + def __iadd__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + + def __sub__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + def __rsub__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + def __isub__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec3: ... + + +f64mat2x4 = dmat2x4 + +class dmat2x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x4, glm_typing.DAnyMatrix2x4, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec4, dmvec4]) -> None: ... + + def __neg__(self) -> dmat2x4: ... + def __pos__(self) -> dmat2x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat2x4: ... + + def __add__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + def __radd__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + def __iadd__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + + def __sub__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + def __rsub__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + def __isub__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x2) -> dmat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x3) -> dmat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix2x4) -> dmat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec4: ... + + +f64mat3x2 = dmat3x2 + +class dmat3x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x2, glm_typing.DAnyMatrix3x2, glm_typing.DAnyMatrix3x3, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x2, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec2, dmvec2]) -> None: ... + + def __neg__(self) -> dmat3x2: ... + def __pos__(self) -> dmat3x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat3x2: ... + + def __add__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + def __radd__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + def __iadd__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + + def __sub__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + def __rsub__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + def __isub__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec2: ... + + +dmat3 = dmat3x3 +f64mat3 = dmat3x3 +f64mat3x3 = dmat3x3 + +class dmat3x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x3, glm_typing.DAnyMatrix3x3, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec3, dmvec3]) -> None: ... + + def __neg__(self) -> dmat3x3: ... + def __pos__(self) -> dmat3x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat3x3: ... + + def __add__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + def __radd__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + def __iadd__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + + def __sub__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + def __rsub__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + def __isub__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + + @overload + def __truediv__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __truediv__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rtruediv__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rtruediv__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __itruediv__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __itruediv__(self, other: glm_typing.D64Vector3) -> dvec3: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector2) -> dvec2: ... + + +f64mat3x4 = dmat3x4 + +class dmat3x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x4, glm_typing.DAnyMatrix3x4, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec4, dmvec4]) -> None: ... + + def __neg__(self) -> dmat3x4: ... + def __pos__(self) -> dmat3x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat3x4: ... + + def __add__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + def __radd__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + def __iadd__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + + def __sub__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + def __rsub__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + def __isub__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x2) -> dmat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x3) -> dmat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix3x4) -> dmat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec4: ... + + +f64mat4x2 = dmat4x2 + +class dmat4x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x2, glm_typing.DAnyMatrix4x2, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec2, dmvec2]) -> None: ... + + def __neg__(self) -> dmat4x2: ... + def __pos__(self) -> dmat4x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat4x2: ... + + def __add__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + def __radd__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + def __iadd__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + + def __sub__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + def __rsub__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + def __isub__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec2: ... + + +f64mat4x3 = dmat4x3 + +class dmat4x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x3, glm_typing.DAnyMatrix4x3, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec3, dmvec3]) -> None: ... + + def __neg__(self) -> dmat4x3: ... + def __pos__(self) -> dmat4x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat4x3: ... + + def __add__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + def __radd__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + def __iadd__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + + def __sub__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + def __rsub__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + def __isub__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec3: ... + + +dmat4 = dmat4x4 +f64mat4 = dmat4x4 +f64mat4x4 = dmat4x4 + +class dmat4x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, _12: glm_typing.Number, _13: glm_typing.Number, _14: glm_typing.Number, _15: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x4, glm_typing.DAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[dmvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> dmvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[dvec4, dmvec4]) -> None: ... + + def __neg__(self) -> dmat4x4: ... + def __pos__(self) -> dmat4x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dmat4x4: ... + + def __add__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + def __radd__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + def __iadd__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + + def __sub__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + def __rsub__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + def __isub__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __mul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + + @overload + def __truediv__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __truediv__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rtruediv__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rtruediv__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __itruediv__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __itruediv__(self, other: glm_typing.D64Vector4) -> dvec4: ... + + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __matmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x2) -> dmat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x3) -> dmat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.DAnyMatrix4x4) -> dmat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + + +i32mat2 = imat2x2 +i32mat2x2 = imat2x2 +imat2 = imat2x2 + +class imat2x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x2, glm_typing.IAnyMatrix2x2, glm_typing.IAnyMatrix2x3, glm_typing.IAnyMatrix2x4, glm_typing.IAnyMatrix3x2, glm_typing.IAnyMatrix3x3, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x2, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec2, imvec2]) -> None: ... + + def __neg__(self) -> imat2x2: ... + def __pos__(self) -> imat2x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat2x2: ... + + def __add__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + def __radd__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + def __iadd__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + + def __sub__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + def __rsub__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + def __isub__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __mul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + + @overload + def __truediv__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __truediv__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rtruediv__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rtruediv__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __itruediv__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __itruediv__(self, other: glm_typing.I32Vector2) -> ivec2: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector1) -> ivec1: ... + + +i32mat2x3 = imat2x3 + +class imat2x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x3, glm_typing.IAnyMatrix2x3, glm_typing.IAnyMatrix2x4, glm_typing.IAnyMatrix3x3, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec3, imvec3]) -> None: ... + + def __neg__(self) -> imat2x3: ... + def __pos__(self) -> imat2x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat2x3: ... + + def __add__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + def __radd__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + def __iadd__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + + def __sub__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + def __rsub__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + def __isub__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec3: ... + + +i32mat2x4 = imat2x4 + +class imat2x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x4, glm_typing.IAnyMatrix2x4, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec4, imvec4]) -> None: ... + + def __neg__(self) -> imat2x4: ... + def __pos__(self) -> imat2x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat2x4: ... + + def __add__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + def __radd__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + def __iadd__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + + def __sub__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + def __rsub__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + def __isub__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x2) -> imat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x3) -> imat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix2x4) -> imat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec4: ... + + +i32mat3x2 = imat3x2 + +class imat3x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x2, glm_typing.IAnyMatrix3x2, glm_typing.IAnyMatrix3x3, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x2, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec2, imvec2]) -> None: ... + + def __neg__(self) -> imat3x2: ... + def __pos__(self) -> imat3x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat3x2: ... + + def __add__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + def __radd__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + def __iadd__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + + def __sub__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + def __rsub__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + def __isub__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec2: ... + + +i32mat3 = imat3x3 +i32mat3x3 = imat3x3 +imat3 = imat3x3 + +class imat3x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x3, glm_typing.IAnyMatrix3x3, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec3, imvec3]) -> None: ... + + def __neg__(self) -> imat3x3: ... + def __pos__(self) -> imat3x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat3x3: ... + + def __add__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + def __radd__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + def __iadd__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + + def __sub__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + def __rsub__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + def __isub__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __mul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + + @overload + def __truediv__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __truediv__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rtruediv__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rtruediv__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __itruediv__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __itruediv__(self, other: glm_typing.I32Vector3) -> ivec3: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector2) -> ivec2: ... + + +i32mat3x4 = imat3x4 + +class imat3x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x4, glm_typing.IAnyMatrix3x4, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec4, imvec4]) -> None: ... + + def __neg__(self) -> imat3x4: ... + def __pos__(self) -> imat3x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat3x4: ... + + def __add__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + def __radd__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + def __iadd__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + + def __sub__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + def __rsub__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + def __isub__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x2) -> imat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x3) -> imat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix3x4) -> imat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec4: ... + + +i32mat4x2 = imat4x2 + +class imat4x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x2, glm_typing.IAnyMatrix4x2, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec2, imvec2]) -> None: ... + + def __neg__(self) -> imat4x2: ... + def __pos__(self) -> imat4x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat4x2: ... + + def __add__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + def __radd__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + def __iadd__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + + def __sub__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + def __rsub__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + def __isub__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> ivec2: ... + + +i32mat4x3 = imat4x3 + +class imat4x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x3, glm_typing.IAnyMatrix4x3, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec3, imvec3]) -> None: ... + + def __neg__(self) -> imat4x3: ... + def __pos__(self) -> imat4x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat4x3: ... + + def __add__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + def __radd__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + def __iadd__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + + def __sub__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + def __rsub__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + def __isub__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> ivec3: ... + + +i32mat4 = imat4x4 +i32mat4x4 = imat4x4 +imat4 = imat4x4 + +class imat4x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, _12: glm_typing.Number, _13: glm_typing.Number, _14: glm_typing.Number, _15: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x4, glm_typing.IAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[imvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> imvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[ivec4, imvec4]) -> None: ... + + def __neg__(self) -> imat4x4: ... + def __pos__(self) -> imat4x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> imat4x4: ... + + def __add__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + def __radd__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + def __iadd__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + + def __sub__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + def __rsub__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + def __isub__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __mul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __mul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __imul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + + @overload + def __truediv__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __truediv__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rtruediv__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rtruediv__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __itruediv__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __itruediv__(self, other: glm_typing.I32Vector4) -> ivec4: ... + + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __matmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __matmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __rmatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x2) -> imat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x3) -> imat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.IAnyMatrix4x4) -> imat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector4) -> ivec4: ... + @overload + def __imatmul__(self, other: glm_typing.I32Vector3) -> ivec3: ... + + +f32mat2 = mat2x2 +f32mat2x2 = mat2x2 +fmat2 = mat2x2 +fmat2x2 = mat2x2 +mat2 = mat2x2 + +class mat2x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x2, glm_typing.FAnyMatrix2x2, glm_typing.FAnyMatrix2x3, glm_typing.FAnyMatrix2x4, glm_typing.FAnyMatrix3x2, glm_typing.FAnyMatrix3x3, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x2, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec2, mvec2]) -> None: ... + + def __neg__(self) -> mat2x2: ... + def __pos__(self) -> mat2x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat2x2: ... + + def __add__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + def __radd__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + def __iadd__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + + def __sub__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + def __rsub__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + def __isub__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __mul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.F32Vector1) -> vec1: ... + + @overload + def __truediv__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __truediv__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rtruediv__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rtruediv__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __itruediv__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __itruediv__(self, other: glm_typing.F32Vector2) -> vec2: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector1) -> vec1: ... + + +f32mat2x3 = mat2x3 +fmat2x3 = mat2x3 + +class mat2x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x3, glm_typing.FAnyMatrix2x3, glm_typing.FAnyMatrix2x4, glm_typing.FAnyMatrix3x3, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec3, mvec3]) -> None: ... + + def __neg__(self) -> mat2x3: ... + def __pos__(self) -> mat2x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat2x3: ... + + def __add__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + def __radd__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + def __iadd__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + + def __sub__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + def __rsub__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + def __isub__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec3: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec3: ... + + +f32mat2x4 = mat2x4 +fmat2x4 = mat2x4 + +class mat2x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x4, glm_typing.FAnyMatrix2x4, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec4, mvec4]) -> None: ... + + def __neg__(self) -> mat2x4: ... + def __pos__(self) -> mat2x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat2x4: ... + + def __add__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + def __radd__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + def __iadd__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + + def __sub__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + def __rsub__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + def __isub__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec4: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x2) -> mat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x3) -> mat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix2x4) -> mat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec4: ... + + +f32mat3x2 = mat3x2 +fmat3x2 = mat3x2 + +class mat3x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x2, glm_typing.FAnyMatrix3x2, glm_typing.FAnyMatrix3x3, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x2, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec2, mvec2]) -> None: ... + + def __neg__(self) -> mat3x2: ... + def __pos__(self) -> mat3x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat3x2: ... + + def __add__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + def __radd__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + def __iadd__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + + def __sub__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + def __rsub__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + def __isub__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec2: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec2: ... + + +f32mat3 = mat3x3 +f32mat3x3 = mat3x3 +fmat3 = mat3x3 +fmat3x3 = mat3x3 +mat3 = mat3x3 + +class mat3x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x3, glm_typing.FAnyMatrix3x3, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec3, mvec3]) -> None: ... + + def __neg__(self) -> mat3x3: ... + def __pos__(self) -> mat3x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat3x3: ... + + def __add__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + def __radd__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + def __iadd__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + + def __sub__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + def __rsub__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + def __isub__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Vector2) -> vec2: ... + + @overload + def __truediv__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __truediv__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rtruediv__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rtruediv__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __itruediv__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __itruediv__(self, other: glm_typing.F32Vector3) -> vec3: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector2) -> vec2: ... + + +f32mat3x4 = mat3x4 +fmat3x4 = mat3x4 + +class mat3x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x4, glm_typing.FAnyMatrix3x4, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec4, mvec4]) -> None: ... + + def __neg__(self) -> mat3x4: ... + def __pos__(self) -> mat3x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat3x4: ... + + def __add__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + def __radd__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + def __iadd__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + + def __sub__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + def __rsub__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + def __isub__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec4: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x2) -> mat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x3) -> mat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix3x4) -> mat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec4: ... + + +f32mat4x2 = mat4x2 +fmat4x2 = mat4x2 + +class mat4x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x2, glm_typing.FAnyMatrix4x2, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec2, mvec2]) -> None: ... + + def __neg__(self) -> mat4x2: ... + def __pos__(self) -> mat4x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float], Tuple[float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat4x2: ... + + def __add__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + def __radd__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + def __iadd__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + + def __sub__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + def __rsub__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + def __isub__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec2: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec2: ... + + +f32mat4x3 = mat4x3 +fmat4x3 = mat4x3 + +class mat4x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x3, glm_typing.FAnyMatrix4x3, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec3, mvec3]) -> None: ... + + def __neg__(self) -> mat4x3: ... + def __pos__(self) -> mat4x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat4x3: ... + + def __add__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + def __radd__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + def __iadd__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + + def __sub__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + def __rsub__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + def __isub__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec3: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec3: ... + + +f32mat4 = mat4x4 +f32mat4x4 = mat4x4 +fmat4 = mat4x4 +fmat4x4 = mat4x4 +mat4 = mat4x4 + +class mat4x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, _12: glm_typing.Number, _13: glm_typing.Number, _14: glm_typing.Number, _15: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x4, glm_typing.FAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[mvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> float: ... + @overload + def __getitem__(self, index: int) -> mvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[vec4, mvec4]) -> None: ... + + def __neg__(self) -> mat4x4: ... + def __pos__(self) -> mat4x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[float]]: ... + def to_tuple(self) -> Tuple[Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float], Tuple[float, float, float, float]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> mat4x4: ... + + def __add__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + def __radd__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + def __iadd__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + + def __sub__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + def __rsub__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + def __isub__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __mul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec3: ... + + @overload + def __truediv__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __truediv__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rtruediv__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rtruediv__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __itruediv__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __itruediv__(self, other: glm_typing.F32Vector4) -> vec4: ... + + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __matmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x2) -> mat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x3) -> mat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.FAnyMatrix4x4) -> mat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + + +u32mat2 = umat2x2 +u32mat2x2 = umat2x2 +umat2 = umat2x2 + +class umat2x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x2, glm_typing.UAnyMatrix2x2, glm_typing.UAnyMatrix2x3, glm_typing.UAnyMatrix2x4, glm_typing.UAnyMatrix3x2, glm_typing.UAnyMatrix3x3, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x2, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec2, umvec2]) -> None: ... + + def __neg__(self) -> umat2x2: ... + def __pos__(self) -> umat2x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat2x2: ... + + def __add__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + def __radd__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + def __iadd__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + + def __sub__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + def __rsub__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + def __isub__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __mul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + + @overload + def __truediv__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __truediv__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rtruediv__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rtruediv__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __itruediv__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __itruediv__(self, other: glm_typing.U32Vector2) -> uvec2: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector1) -> uvec1: ... + + +u32mat2x3 = umat2x3 + +class umat2x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x3, glm_typing.UAnyMatrix2x3, glm_typing.UAnyMatrix2x4, glm_typing.UAnyMatrix3x3, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec3, umvec3]) -> None: ... + + def __neg__(self) -> umat2x3: ... + def __pos__(self) -> umat2x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat2x3: ... + + def __add__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + def __radd__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + def __iadd__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + + def __sub__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + def __rsub__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + def __isub__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec3: ... + + +u32mat2x4 = umat2x4 + +class umat2x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix2x4, glm_typing.UAnyMatrix2x4, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[2]: ... + def __len__(self) -> Literal[2]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec4, umvec4]) -> None: ... + + def __neg__(self) -> umat2x4: ... + def __pos__(self) -> umat2x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat2x4: ... + + def __add__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + def __radd__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + def __iadd__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + + def __sub__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + def __rsub__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + def __isub__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x2) -> umat2x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x3) -> umat2x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix2x4) -> umat2x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec4: ... + + +u32mat3x2 = umat3x2 + +class umat3x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x2, glm_typing.UAnyMatrix3x2, glm_typing.UAnyMatrix3x3, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x2, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec2, umvec2]) -> None: ... + + def __neg__(self) -> umat3x2: ... + def __pos__(self) -> umat3x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat3x2: ... + + def __add__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + def __radd__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + def __iadd__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + + def __sub__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + def __rsub__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + def __isub__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec2: ... + + +u32mat3 = umat3x3 +u32mat3x3 = umat3x3 +umat3 = umat3x3 + +class umat3x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x3, glm_typing.UAnyMatrix3x3, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec3, umvec3]) -> None: ... + + def __neg__(self) -> umat3x3: ... + def __pos__(self) -> umat3x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat3x3: ... + + def __add__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + def __radd__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + def __iadd__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + + def __sub__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + def __rsub__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + def __isub__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __mul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + + @overload + def __truediv__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __truediv__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rtruediv__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rtruediv__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __itruediv__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __itruediv__(self, other: glm_typing.U32Vector3) -> uvec3: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector2) -> uvec2: ... + + +u32mat3x4 = umat3x4 + +class umat3x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix3x4, glm_typing.UAnyMatrix3x4, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[3]: ... + def __len__(self) -> Literal[3]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec4, umvec4]) -> None: ... + + def __neg__(self) -> umat3x4: ... + def __pos__(self) -> umat3x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat3x4: ... + + def __add__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + def __radd__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + def __iadd__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + + def __sub__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + def __rsub__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + def __isub__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x2) -> umat3x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x3) -> umat3x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix3x4) -> umat3x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec4: ... + + +u32mat4x2 = umat4x2 + +class umat4x2: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x2, glm_typing.UAnyMatrix4x2, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec2, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec2: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec2, umvec2]) -> None: ... + + def __neg__(self) -> umat4x2: ... + def __pos__(self) -> umat4x2: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int], Tuple[int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat4x2: ... + + def __add__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + def __radd__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + def __iadd__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + + def __sub__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + def __rsub__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + def __isub__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> uvec2: ... + + +u32mat4x3 = umat4x3 + +class umat4x3: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x3, glm_typing.UAnyMatrix4x3, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec3, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec3: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec3, umvec3]) -> None: ... + + def __neg__(self) -> umat4x3: ... + def __pos__(self) -> umat4x3: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int], Tuple[int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat4x3: ... + + def __add__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + def __radd__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + def __iadd__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + + def __sub__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + def __rsub__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + def __isub__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> uvec3: ... + + +u32mat4 = umat4x4 +u32mat4x4 = umat4x4 +umat4 = umat4x4 + +class umat4x4: + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, x: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, _0: glm_typing.Number, _1: glm_typing.Number, _2: glm_typing.Number, _3: glm_typing.Number, _4: glm_typing.Number, _5: glm_typing.Number, _6: glm_typing.Number, _7: glm_typing.Number, _8: glm_typing.Number, _9: glm_typing.Number, _10: glm_typing.Number, _11: glm_typing.Number, _12: glm_typing.Number, _13: glm_typing.Number, _14: glm_typing.Number, _15: glm_typing.Number, /) -> None: ... + @overload + def __init__(self, x: Union[glm_typing.AnyAnyMatrix4x4, glm_typing.UAnyMatrix4x4], /) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[umvec4, None, None]: ... + + @overload + def __getitem__(self, index: Tuple[int, int]) -> int: ... + @overload + def __getitem__(self, index: int) -> umvec4: ... + + @overload + def __setitem__(self, index: Tuple[int, int], value: glm_typing.Number) -> None: ... + @overload + def __setitem__(self, index: int, value: Union[uvec4, umvec4]) -> None: ... + + def __neg__(self) -> umat4x4: ... + def __pos__(self) -> umat4x4: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def to_list(self) -> List[List[int]]: ... + def to_tuple(self) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int], Tuple[int, int, int, int]]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> umat4x4: ... + + def __add__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + def __radd__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + def __iadd__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + + def __sub__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + def __rsub__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + def __isub__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __mul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __mul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __imul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + + @overload + def __truediv__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __truediv__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rtruediv__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rtruediv__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __itruediv__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __itruediv__(self, other: glm_typing.U32Vector4) -> uvec4: ... + + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __matmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __matmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __rmatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __rmatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x2) -> umat4x2: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x3) -> umat4x3: ... + @overload + def __imatmul__(self, other: glm_typing.UAnyMatrix4x4) -> umat4x4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector4) -> uvec4: ... + @overload + def __imatmul__(self, other: glm_typing.U32Vector3) -> uvec3: ... + + +f64quat = dquat + +class dquat: + w: float + x: float + y: float + z: float + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, w: glm_typing.Number, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, w: Union[glm_typing.AnyAnyQuaternion, glm_typing.D64Matrix3x3, glm_typing.D64Matrix4x4, glm_typing.D64Vector3]) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> dquat: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + @overload + def __mul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __mul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __mul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __imul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + + @overload + def __matmul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __matmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __rmatmul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __rmatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + @overload + def __imatmul__(self, other: Union[dquat, glm_typing.Number]) -> dquat: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector3) -> dvec3: ... + @overload + def __imatmul__(self, other: glm_typing.D64Vector4) -> dvec4: ... + + +f32quat = quat +fquat = quat + +class quat: + w: float + x: float + y: float + z: float + + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, w: glm_typing.Number, x: glm_typing.Number, y: glm_typing.Number, z: glm_typing.Number) -> None: ... + @overload + def __init__(self, w: Union[glm_typing.AnyAnyQuaternion, glm_typing.F32Matrix3x3, glm_typing.F32Matrix4x4, glm_typing.F32Vector3]) -> None: ... + + def length(self) -> Literal[4]: ... + def __len__(self) -> Literal[4]: ... + def __getitem__(self, index: int) -> float: ... + def __setitem__(self, index: int, value: glm_typing.Number) -> None: ... + def __contains__(self, value: Any) -> bool: ... + def __iter__(self) -> Generator[float, None, None]: ... + + def to_list(self) -> List[float]: ... + def to_tuple(self) -> Tuple[float, float, float, float]: ... + def to_bytes(self) -> bytes: ... + + @staticmethod + def from_bytes(bytes: bytes, /) -> quat: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + @overload + def __mul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __mul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __mul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __imul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imul__(self, other: glm_typing.F32Vector4) -> vec4: ... + + @overload + def __matmul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __matmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __rmatmul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __rmatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + @overload + def __imatmul__(self, other: Union[quat, glm_typing.Number]) -> quat: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector3) -> vec3: ... + @overload + def __imatmul__(self, other: glm_typing.F32Vector4) -> vec4: ... + + + +_AT = TypeVar('_AT', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_float, ctypes.c_double, ctypes.c_longdouble, dmat2x2, dmat2x3, dmat2x4, dmat3x2, dmat3x3, dmat3x4, dmat4x2, dmat4x3, dmat4x4, imat2x2, imat2x3, imat2x4, imat3x2, imat3x3, imat3x4, imat4x2, imat4x3, imat4x4, mat2x2, mat2x3, mat2x4, mat3x2, mat3x3, mat3x4, mat4x2, mat4x3, mat4x4, umat2x2, umat2x3, umat2x4, umat3x2, umat3x3, umat3x4, umat4x2, umat4x3, umat4x4, dquat, quat, bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, mvec2, mvec3, mvec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4, vec1, vec2, vec3, vec4) +_AT2 = TypeVar('_AT2', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_float, ctypes.c_double, ctypes.c_longdouble, dmat2x2, dmat2x3, dmat2x4, dmat3x2, dmat3x3, dmat3x4, dmat4x2, dmat4x3, dmat4x4, imat2x2, imat2x3, imat2x4, imat3x2, imat3x3, imat3x4, imat4x2, imat4x3, imat4x4, mat2x2, mat2x3, mat2x4, mat3x2, mat3x3, mat3x4, mat4x2, mat4x3, mat4x4, umat2x2, umat2x3, umat2x4, umat3x2, umat3x3, umat3x4, umat4x2, umat4x3, umat4x4, dquat, quat, bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, mvec2, mvec3, mvec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4, vec1, vec2, vec3, vec4) +_GLMT = TypeVar('_GLMT', dmat2x2, dmat2x3, dmat2x4, dmat3x2, dmat3x3, dmat3x4, dmat4x2, dmat4x3, dmat4x4, imat2x2, imat2x3, imat2x4, imat3x2, imat3x3, imat3x4, imat4x2, imat4x3, imat4x4, mat2x2, mat2x3, mat2x4, mat3x2, mat3x3, mat3x4, mat4x2, mat4x3, mat4x4, umat2x2, umat2x3, umat2x4, umat3x2, umat3x3, umat3x4, umat4x2, umat4x3, umat4x4, dquat, quat, bvec1, bvec2, bvec3, bvec4, dmvec2, dmvec3, dmvec4, dvec1, dvec2, dvec3, dvec4, i16vec1, i16vec2, i16vec3, i16vec4, i64vec1, i64vec2, i64vec3, i64vec4, i8vec1, i8vec2, i8vec3, i8vec4, imvec2, imvec3, imvec4, ivec1, ivec2, ivec3, ivec4, mvec2, mvec3, mvec4, u16vec1, u16vec2, u16vec3, u16vec4, u64vec1, u64vec2, u64vec3, u64vec4, u8vec1, u8vec2, u8vec3, u8vec4, umvec2, umvec3, umvec4, uvec1, uvec2, uvec3, uvec4, vec1, vec2, vec3, vec4) +_CT = TypeVar('_CT', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_float, ctypes.c_double, ctypes.c_longdouble) +_ICT = TypeVar('_ICT', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t) +_FCT = TypeVar('_FCT', ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t) + +class array(Generic[_AT]): + + nbytes: int + typecode: str + element_type: Type[_AT] + itemsize: int + dt_size: int + address: int + length: int + readonly: bool + reference: Any + + @property + def ptr(self) -> ctypes.c_void_p: ... + + @property + def dtype(self) -> str: ... + + @property + def ctype(self) -> Type[Union[ctypes.c_bool, ctypes.c_byte, ctypes.c_int8, ctypes.c_ubyte, ctypes.c_uint8, ctypes.c_short, ctypes.c_int16, ctypes.c_ushort, ctypes.c_uint16, ctypes.c_int, ctypes.c_int32, ctypes.c_uint, ctypes.c_uint32, ctypes.c_long, ctypes.c_int64, ctypes.c_ulong, ctypes.c_uint64, ctypes.c_longlong, ctypes.c_ulonglong, ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_float, ctypes.c_double, ctypes.c_longdouble]]: ... + + @overload + def __init__(self, _1: _AT, /, *_: _AT) -> None: ... + @overload + def __init__(self, _: array[_AT], /) -> None: ... + @overload + def __init__(self, _: Iterable[_AT], /) -> None: ... + + def __len__(self) -> int: ... + def __contains__(self, value: Any) -> bool: ... + + @overload + def __iter__(self: Union[array[ctypes.c_bool], array[ctypes.c_byte], array[ctypes.c_int8], array[ctypes.c_ubyte], array[ctypes.c_uint8], array[ctypes.c_short], array[ctypes.c_int16], array[ctypes.c_ushort], array[ctypes.c_uint16], array[ctypes.c_int], array[ctypes.c_int32], array[ctypes.c_uint], array[ctypes.c_uint32], array[ctypes.c_long], array[ctypes.c_int64], array[ctypes.c_ulong], array[ctypes.c_uint64], array[ctypes.c_longlong], array[ctypes.c_ulonglong], array[ctypes.c_size_t], array[ctypes.c_ssize_t]]) -> Generator[int, None, None]: ... + @overload + def __iter__(self: Union[array[ctypes.c_float], array[ctypes.c_double], array[ctypes.c_longdouble]]) -> Generator[float, None, None]: ... + @overload + def __iter__(self: array[_GLMT]) -> Generator[_AT, None, None]: ... + + @overload + def __getitem__(self: Union[array[ctypes.c_bool], array[ctypes.c_byte], array[ctypes.c_int8], array[ctypes.c_ubyte], array[ctypes.c_uint8], array[ctypes.c_short], array[ctypes.c_int16], array[ctypes.c_ushort], array[ctypes.c_uint16], array[ctypes.c_int], array[ctypes.c_int32], array[ctypes.c_uint], array[ctypes.c_uint32], array[ctypes.c_long], array[ctypes.c_int64], array[ctypes.c_ulong], array[ctypes.c_uint64], array[ctypes.c_longlong], array[ctypes.c_ulonglong], array[ctypes.c_size_t], array[ctypes.c_ssize_t]], index: int) -> int: ... + @overload + def __getitem__(self: Union[array[ctypes.c_float], array[ctypes.c_double], array[ctypes.c_longdouble]], index: int) -> float: ... + @overload + def __getitem__(self: array[_GLMT], index: int) -> _AT: ... + @overload + def __getitem__(self, index: slice) -> array[_AT]: ... + + @overload + def __setitem__(self: array[_ICT], index: int, value: _ICT) -> None: ... + @overload + def __setitem__(self: array[_FCT], index: int, value: _FCT) -> None: ... + @overload + def __setitem__(self: array[_GLMT], index: int, value: _AT) -> None: ... + @overload + def __setitem__(self, index: slice, value: array[_AT]) -> None: ... + + @staticmethod + def from_bytes(bytes: bytes, type: Type[_AT], /) -> array[_AT]: ... + + @staticmethod + def from_numbers(type: Type[_CT], /, *numbers: glm_typing.Number) -> array[_CT]: ... + + @staticmethod + def zeros(length: int, type: Type[_AT], /) -> array[_AT]: ... + + @overload + def to_list(self: array[_GLMT]) -> List[_GLMT]: ... + @overload + def to_list(self: Union[array[ctypes.c_bool], array[ctypes.c_byte], array[ctypes.c_int8], array[ctypes.c_ubyte], array[ctypes.c_uint8], array[ctypes.c_short], array[ctypes.c_int16], array[ctypes.c_ushort], array[ctypes.c_uint16], array[ctypes.c_int], array[ctypes.c_int32], array[ctypes.c_uint], array[ctypes.c_uint32], array[ctypes.c_long], array[ctypes.c_int64], array[ctypes.c_ulong], array[ctypes.c_uint64], array[ctypes.c_longlong], array[ctypes.c_ulonglong], array[ctypes.c_size_t], array[ctypes.c_ssize_t]]) -> List[int]: ... + @overload + def to_list(self: Union[array[ctypes.c_float], array[ctypes.c_double], array[ctypes.c_longdouble]]) -> List[float]: ... + + @overload + def to_tuple(self: array[_GLMT]) -> Tuple[_GLMT, ...]: ... + @overload + def to_tuple(self: Union[array[ctypes.c_bool], array[ctypes.c_byte], array[ctypes.c_int8], array[ctypes.c_ubyte], array[ctypes.c_uint8], array[ctypes.c_short], array[ctypes.c_int16], array[ctypes.c_ushort], array[ctypes.c_uint16], array[ctypes.c_int], array[ctypes.c_int32], array[ctypes.c_uint], array[ctypes.c_uint32], array[ctypes.c_long], array[ctypes.c_int64], array[ctypes.c_ulong], array[ctypes.c_uint64], array[ctypes.c_longlong], array[ctypes.c_ulonglong], array[ctypes.c_size_t], array[ctypes.c_ssize_t]]) -> Tuple[int, ...]: ... + @overload + def to_tuple(self: Union[array[ctypes.c_float], array[ctypes.c_double], array[ctypes.c_longdouble]]) -> Tuple[float, ...]: ... + + @overload + def split_components(self: array[bvec1]) -> Tuple[array[ctypes.c_bool]]: ... + @overload + def split_components(self: array[bvec2]) -> Tuple[array[ctypes.c_bool], array[ctypes.c_bool]]: ... + @overload + def split_components(self: array[bvec3]) -> Tuple[array[ctypes.c_bool], array[ctypes.c_bool], array[ctypes.c_bool]]: ... + @overload + def split_components(self: array[bvec4]) -> Tuple[array[ctypes.c_bool], array[ctypes.c_bool], array[ctypes.c_bool], array[ctypes.c_bool]]: ... + @overload + def split_components(self: array[dmvec2]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dmvec3]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dmvec4]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dvec1]) -> Tuple[array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dvec2]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dvec3]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[dvec4]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[i16vec1]) -> Tuple[array[ctypes.c_short]]: ... + @overload + def split_components(self: array[i16vec2]) -> Tuple[array[ctypes.c_short], array[ctypes.c_short]]: ... + @overload + def split_components(self: array[i16vec3]) -> Tuple[array[ctypes.c_short], array[ctypes.c_short], array[ctypes.c_short]]: ... + @overload + def split_components(self: array[i16vec4]) -> Tuple[array[ctypes.c_short], array[ctypes.c_short], array[ctypes.c_short], array[ctypes.c_short]]: ... + @overload + def split_components(self: array[i64vec1]) -> Tuple[array[ctypes.c_longlong]]: ... + @overload + def split_components(self: array[i64vec2]) -> Tuple[array[ctypes.c_longlong], array[ctypes.c_longlong]]: ... + @overload + def split_components(self: array[i64vec3]) -> Tuple[array[ctypes.c_longlong], array[ctypes.c_longlong], array[ctypes.c_longlong]]: ... + @overload + def split_components(self: array[i64vec4]) -> Tuple[array[ctypes.c_longlong], array[ctypes.c_longlong], array[ctypes.c_longlong], array[ctypes.c_longlong]]: ... + @overload + def split_components(self: array[i8vec1]) -> Tuple[array[ctypes.c_byte]]: ... + @overload + def split_components(self: array[i8vec2]) -> Tuple[array[ctypes.c_byte], array[ctypes.c_byte]]: ... + @overload + def split_components(self: array[i8vec3]) -> Tuple[array[ctypes.c_byte], array[ctypes.c_byte], array[ctypes.c_byte]]: ... + @overload + def split_components(self: array[i8vec4]) -> Tuple[array[ctypes.c_byte], array[ctypes.c_byte], array[ctypes.c_byte], array[ctypes.c_byte]]: ... + @overload + def split_components(self: array[imvec2]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[imvec3]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[imvec4]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[ivec1]) -> Tuple[array[ctypes.c_long]]: ... + @overload + def split_components(self: array[ivec2]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[ivec3]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[ivec4]) -> Tuple[array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long], array[ctypes.c_long]]: ... + @overload + def split_components(self: array[mvec2]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[mvec3]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[mvec4]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[u16vec1]) -> Tuple[array[ctypes.c_ushort]]: ... + @overload + def split_components(self: array[u16vec2]) -> Tuple[array[ctypes.c_ushort], array[ctypes.c_ushort]]: ... + @overload + def split_components(self: array[u16vec3]) -> Tuple[array[ctypes.c_ushort], array[ctypes.c_ushort], array[ctypes.c_ushort]]: ... + @overload + def split_components(self: array[u16vec4]) -> Tuple[array[ctypes.c_ushort], array[ctypes.c_ushort], array[ctypes.c_ushort], array[ctypes.c_ushort]]: ... + @overload + def split_components(self: array[u64vec1]) -> Tuple[array[ctypes.c_ulonglong]]: ... + @overload + def split_components(self: array[u64vec2]) -> Tuple[array[ctypes.c_ulonglong], array[ctypes.c_ulonglong]]: ... + @overload + def split_components(self: array[u64vec3]) -> Tuple[array[ctypes.c_ulonglong], array[ctypes.c_ulonglong], array[ctypes.c_ulonglong]]: ... + @overload + def split_components(self: array[u64vec4]) -> Tuple[array[ctypes.c_ulonglong], array[ctypes.c_ulonglong], array[ctypes.c_ulonglong], array[ctypes.c_ulonglong]]: ... + @overload + def split_components(self: array[u8vec1]) -> Tuple[array[ctypes.c_ubyte]]: ... + @overload + def split_components(self: array[u8vec2]) -> Tuple[array[ctypes.c_ubyte], array[ctypes.c_ubyte]]: ... + @overload + def split_components(self: array[u8vec3]) -> Tuple[array[ctypes.c_ubyte], array[ctypes.c_ubyte], array[ctypes.c_ubyte]]: ... + @overload + def split_components(self: array[u8vec4]) -> Tuple[array[ctypes.c_ubyte], array[ctypes.c_ubyte], array[ctypes.c_ubyte], array[ctypes.c_ubyte]]: ... + @overload + def split_components(self: array[umvec2]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[umvec3]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[umvec4]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[uvec1]) -> Tuple[array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[uvec2]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[uvec3]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[uvec4]) -> Tuple[array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong], array[ctypes.c_ulong]]: ... + @overload + def split_components(self: array[vec1]) -> Tuple[array[ctypes.c_float]]: ... + @overload + def split_components(self: array[vec2]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[vec3]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[vec4]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[dquat]) -> Tuple[array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double], array[ctypes.c_double]]: ... + @overload + def split_components(self: array[quat]) -> Tuple[array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float], array[ctypes.c_float]]: ... + @overload + def split_components(self: array[dmat2x2]) -> Tuple[array[dvec2], array[dvec2]]: ... + @overload + def split_components(self: array[dmat2x3]) -> Tuple[array[dvec3], array[dvec3]]: ... + @overload + def split_components(self: array[dmat2x4]) -> Tuple[array[dvec4], array[dvec4]]: ... + @overload + def split_components(self: array[dmat3x2]) -> Tuple[array[dvec2], array[dvec2], array[dvec2]]: ... + @overload + def split_components(self: array[dmat3x3]) -> Tuple[array[dvec3], array[dvec3], array[dvec3]]: ... + @overload + def split_components(self: array[dmat3x4]) -> Tuple[array[dvec4], array[dvec4], array[dvec4]]: ... + @overload + def split_components(self: array[dmat4x2]) -> Tuple[array[dvec2], array[dvec2], array[dvec2], array[dvec2]]: ... + @overload + def split_components(self: array[dmat4x3]) -> Tuple[array[dvec3], array[dvec3], array[dvec3], array[dvec3]]: ... + @overload + def split_components(self: array[dmat4x4]) -> Tuple[array[dvec4], array[dvec4], array[dvec4], array[dvec4]]: ... + @overload + def split_components(self: array[imat2x2]) -> Tuple[array[ivec2], array[ivec2]]: ... + @overload + def split_components(self: array[imat2x3]) -> Tuple[array[ivec3], array[ivec3]]: ... + @overload + def split_components(self: array[imat2x4]) -> Tuple[array[ivec4], array[ivec4]]: ... + @overload + def split_components(self: array[imat3x2]) -> Tuple[array[ivec2], array[ivec2], array[ivec2]]: ... + @overload + def split_components(self: array[imat3x3]) -> Tuple[array[ivec3], array[ivec3], array[ivec3]]: ... + @overload + def split_components(self: array[imat3x4]) -> Tuple[array[ivec4], array[ivec4], array[ivec4]]: ... + @overload + def split_components(self: array[imat4x2]) -> Tuple[array[ivec2], array[ivec2], array[ivec2], array[ivec2]]: ... + @overload + def split_components(self: array[imat4x3]) -> Tuple[array[ivec3], array[ivec3], array[ivec3], array[ivec3]]: ... + @overload + def split_components(self: array[imat4x4]) -> Tuple[array[ivec4], array[ivec4], array[ivec4], array[ivec4]]: ... + @overload + def split_components(self: array[mat2x2]) -> Tuple[array[vec2], array[vec2]]: ... + @overload + def split_components(self: array[mat2x3]) -> Tuple[array[vec3], array[vec3]]: ... + @overload + def split_components(self: array[mat2x4]) -> Tuple[array[vec4], array[vec4]]: ... + @overload + def split_components(self: array[mat3x2]) -> Tuple[array[vec2], array[vec2], array[vec2]]: ... + @overload + def split_components(self: array[mat3x3]) -> Tuple[array[vec3], array[vec3], array[vec3]]: ... + @overload + def split_components(self: array[mat3x4]) -> Tuple[array[vec4], array[vec4], array[vec4]]: ... + @overload + def split_components(self: array[mat4x2]) -> Tuple[array[vec2], array[vec2], array[vec2], array[vec2]]: ... + @overload + def split_components(self: array[mat4x3]) -> Tuple[array[vec3], array[vec3], array[vec3], array[vec3]]: ... + @overload + def split_components(self: array[mat4x4]) -> Tuple[array[vec4], array[vec4], array[vec4], array[vec4]]: ... + @overload + def split_components(self: array[umat2x2]) -> Tuple[array[uvec2], array[uvec2]]: ... + @overload + def split_components(self: array[umat2x3]) -> Tuple[array[uvec3], array[uvec3]]: ... + @overload + def split_components(self: array[umat2x4]) -> Tuple[array[uvec4], array[uvec4]]: ... + @overload + def split_components(self: array[umat3x2]) -> Tuple[array[uvec2], array[uvec2], array[uvec2]]: ... + @overload + def split_components(self: array[umat3x3]) -> Tuple[array[uvec3], array[uvec3], array[uvec3]]: ... + @overload + def split_components(self: array[umat3x4]) -> Tuple[array[uvec4], array[uvec4], array[uvec4]]: ... + @overload + def split_components(self: array[umat4x2]) -> Tuple[array[uvec2], array[uvec2], array[uvec2], array[uvec2]]: ... + @overload + def split_components(self: array[umat4x3]) -> Tuple[array[uvec3], array[uvec3], array[uvec3], array[uvec3]]: ... + @overload + def split_components(self: array[umat4x4]) -> Tuple[array[uvec4], array[uvec4], array[uvec4], array[uvec4]]: ... + + def to_bytes(self) -> bytes: ... + + def reduce(self, func: Callable[[_AT, _AT], _AT], init: Optional[_AT] = ..., /) -> _AT: ... + def filter(self, _: Callable[[_AT], Any], /) -> array[_AT]: ... + def map(self, _: Callable[[_AT], _AT2], /) -> array[_AT2]: ... + def sort(self, _: Callable[[_AT], SupportsInt], /) -> array[_AT]: ... + def concat(self, other: array[_AT], /) -> array[_AT]: ... + def iconcat(self, other: array[_AT], /) -> None: ... + def repeat(self, count: int, /) -> array[_AT]: ... + def irepeat(self, count: int, /) -> None: ... + + @overload + @staticmethod + def as_reference(array: array[_AT], /) -> array[_AT]: ... + @overload + @staticmethod + def as_reference(obj: _GLMT, /) -> array[_GLMT]: ... + + def reinterpret_cast(self, type: Type[_AT], /) -> array[_AT]: ... + + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + + def __add__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __radd__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __iadd__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __sub__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rsub__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __isub__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __mul__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rmul__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __imul__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __mod__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rmod__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __imod__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __pow__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rpow__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ipow__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __lshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rlshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ilshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rrshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __irshift__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __and__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rand__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __iand__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __xor__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rxor__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ixor__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __or__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ror__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __ior__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __truediv__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __rtruediv__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + def __itruediv__(self, other: Union[glm_typing.Number, _AT, array[_AT]]) -> array[_AT]: ... + + def __neg__(self) -> array[_AT]: ... + def __pos__(self) -> array[_AT]: ... + def __abs__(self) -> array[_AT]: ... + def __inv__(self) -> array[_AT]: ... + + +@overload +def abs(x: glm_typing.Number, /) -> float: ... +@overload +def abs(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def abs(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def abs(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def abs(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def abs(x: _VT, /) -> _VT: ... + +@overload +def ceil(x: glm_typing.Number, /) -> float: ... +@overload +def ceil(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def ceil(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def ceil(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def ceil(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def ceil(x: _VT, /) -> _VT: ... + +@overload +def clamp(x: glm_typing.Number, min: glm_typing.Number, max: glm_typing.Number, /) -> glm_typing.Number: ... +@overload +def clamp(x: glm_typing.F32Vector1, min: glm_typing.Number, max: glm_typing.Number, /) -> vec1: ... +@overload +def clamp(x: glm_typing.F32Vector1, min: glm_typing.F32Vector1, max: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def clamp(x: glm_typing.F32Vector2, min: glm_typing.Number, max: glm_typing.Number, /) -> vec2: ... +@overload +def clamp(x: glm_typing.F32Vector2, min: glm_typing.F32Vector2, max: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def clamp(x: glm_typing.F32Vector3, min: glm_typing.Number, max: glm_typing.Number, /) -> vec3: ... +@overload +def clamp(x: glm_typing.F32Vector3, min: glm_typing.F32Vector3, max: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def clamp(x: glm_typing.F32Vector4, min: glm_typing.Number, max: glm_typing.Number, /) -> vec4: ... +@overload +def clamp(x: glm_typing.F32Vector4, min: glm_typing.F32Vector4, max: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def clamp(x: _NF32VT, min: glm_typing.Number, max: glm_typing.Number, /) -> _NF32VT: ... +@overload +def clamp(x: _NF32VT, min: _NF32VT, max: _NF32VT, /) -> _NF32VT: ... + +@overload +def floatBitsToInt(x: float, /) -> int: ... +@overload +def floatBitsToInt(x: glm_typing.F32Vector2, /) -> ivec2: ... +@overload +def floatBitsToInt(x: glm_typing.F32Vector3, /) -> ivec3: ... +@overload +def floatBitsToInt(x: glm_typing.F32Vector4, /) -> ivec4: ... +@overload +def floatBitsToInt(x: glm_typing.F32Vector1, /) -> ivec1: ... + +@overload +def floatBitsToUint(x: float, /) -> int: ... +@overload +def floatBitsToUint(x: glm_typing.F32Vector2, /) -> uvec2: ... +@overload +def floatBitsToUint(x: glm_typing.F32Vector3, /) -> uvec3: ... +@overload +def floatBitsToUint(x: glm_typing.F32Vector4, /) -> uvec4: ... +@overload +def floatBitsToUint(x: glm_typing.F32Vector1, /) -> uvec1: ... + +@overload +def floor(x: glm_typing.Number, /) -> float: ... +@overload +def floor(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def floor(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def floor(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def floor(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def floor(x: _VT, /) -> _VT: ... + +def fma(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... + +@overload +def fmax(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def fmax(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... +@overload +def fmax(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, d: glm_typing.Number, /) -> float: ... +@overload +def fmax(x: glm_typing.F32Vector1, y: glm_typing.Number, /) -> vec1: ... +@overload +def fmax(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmax(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmax(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, d: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmax(x: glm_typing.F32Vector2, y: glm_typing.Number, /) -> vec2: ... +@overload +def fmax(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmax(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmax(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, d: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmax(x: glm_typing.F32Vector3, y: glm_typing.Number, /) -> vec3: ... +@overload +def fmax(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmax(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmax(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, d: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmax(x: glm_typing.F32Vector4, y: glm_typing.Number, /) -> vec4: ... +@overload +def fmax(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmax(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmax(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, d: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmax(x: _NF32VT, y: glm_typing.Number, /) -> _NF32VT: ... +@overload +def fmax(x: _NF32VT, y: _NF32VT, /) -> _NF32VT: ... +@overload +def fmax(a: _NF32VT, b: _NF32VT, c: _NF32VT, /) -> _NF32VT: ... +@overload +def fmax(a: _NF32VT, b: _NF32VT, c: _NF32VT, d: _NF32VT, /) -> _NF32VT: ... + +@overload +def fmin(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def fmin(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... +@overload +def fmin(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, d: glm_typing.Number, /) -> float: ... +@overload +def fmin(x: glm_typing.F32Vector1, y: glm_typing.Number, /) -> vec1: ... +@overload +def fmin(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmin(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmin(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, d: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def fmin(x: glm_typing.F32Vector2, y: glm_typing.Number, /) -> vec2: ... +@overload +def fmin(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmin(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmin(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, d: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def fmin(x: glm_typing.F32Vector3, y: glm_typing.Number, /) -> vec3: ... +@overload +def fmin(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmin(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmin(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, d: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def fmin(x: glm_typing.F32Vector4, y: glm_typing.Number, /) -> vec4: ... +@overload +def fmin(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmin(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmin(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, d: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def fmin(x: _NF32VT, y: glm_typing.Number, /) -> _NF32VT: ... +@overload +def fmin(x: _NF32VT, y: _NF32VT, /) -> _NF32VT: ... +@overload +def fmin(a: _NF32VT, b: _NF32VT, c: _NF32VT, /) -> _NF32VT: ... +@overload +def fmin(a: _NF32VT, b: _NF32VT, c: _NF32VT, d: _NF32VT, /) -> _NF32VT: ... + +@overload +def fract(x: glm_typing.Number, /) -> float: ... +@overload +def fract(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def fract(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def fract(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def fract(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def fract(x: _VT, /) -> _VT: ... + +@overload +def frexp(x: glm_typing.Number, /) -> Tuple[float, int]: ... +@overload +def frexp(x: dvec1, exp: ivec1, /) -> dvec1: ... +@overload +def frexp(x: dvec2, exp: ivec2, /) -> dvec2: ... +@overload +def frexp(x: dvec3, exp: ivec3, /) -> dvec3: ... +@overload +def frexp(x: dvec4, exp: ivec4, /) -> dvec4: ... +@overload +def frexp(x: glm_typing.F32Vector1, exp: ivec1, /) -> vec1: ... +@overload +def frexp(x: glm_typing.F32Vector2, exp: ivec2, /) -> vec2: ... +@overload +def frexp(x: glm_typing.F32Vector3, exp: ivec3, /) -> vec3: ... +@overload +def frexp(x: glm_typing.F32Vector4, exp: ivec4, /) -> vec4: ... + +@overload +def intBitsToFloat(x: int, /) -> float: ... +@overload +def intBitsToFloat(x: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def intBitsToFloat(x: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def intBitsToFloat(x: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def intBitsToFloat(x: glm_typing.I32Vector1, /) -> vec1: ... + +@overload +def isinf(x: glm_typing.Number, /) -> bool: ... +@overload +def isinf(x: glm_typing.FDAnyVector1, /) -> bvec1: ... +@overload +def isinf(x: glm_typing.FDAnyVector2, /) -> bvec2: ... +@overload +def isinf(x: glm_typing.FDAnyVector3, /) -> bvec3: ... +@overload +def isinf(x: glm_typing.FDAnyQuaternionVector4, /) -> bvec4: ... + +@overload +def isnan(x: glm_typing.Number, /) -> bool: ... +@overload +def isnan(x: glm_typing.FDAnyVector1, /) -> bvec1: ... +@overload +def isnan(x: glm_typing.FDAnyVector2, /) -> bvec2: ... +@overload +def isnan(x: glm_typing.FDAnyVector3, /) -> bvec3: ... +@overload +def isnan(x: glm_typing.FDAnyQuaternionVector4, /) -> bvec4: ... + +@overload +def ldexp(x: glm_typing.Number, exp: glm_typing.Number, /) -> float: ... +@overload +def ldexp(x: dmvec2, exp: ivec2, /) -> dmvec2: ... +@overload +def ldexp(x: dmvec3, exp: ivec3, /) -> dmvec3: ... +@overload +def ldexp(x: dmvec4, exp: ivec4, /) -> dmvec4: ... +@overload +def ldexp(x: dvec1, exp: ivec1, /) -> dvec1: ... +@overload +def ldexp(x: dvec2, exp: ivec2, /) -> dvec2: ... +@overload +def ldexp(x: dvec3, exp: ivec3, /) -> dvec3: ... +@overload +def ldexp(x: dvec4, exp: ivec4, /) -> dvec4: ... +@overload +def ldexp(x: mvec2, exp: ivec2, /) -> mvec2: ... +@overload +def ldexp(x: mvec3, exp: ivec3, /) -> mvec3: ... +@overload +def ldexp(x: mvec4, exp: ivec4, /) -> mvec4: ... +@overload +def ldexp(x: Union[vec1, Tuple[glm_typing.Number]], exp: ivec1, /) -> vec1: ... +@overload +def ldexp(x: Union[vec2, Tuple[glm_typing.Number, glm_typing.Number]], exp: ivec2, /) -> vec2: ... +@overload +def ldexp(x: Union[vec3, Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number]], exp: ivec3, /) -> vec3: ... +@overload +def ldexp(x: Union[vec4, Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number]], exp: ivec4, /) -> vec4: ... + +@overload +def max(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def max(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... +@overload +def max(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, d: glm_typing.Number, /) -> float: ... +@overload +def max(x: glm_typing.F32Vector1, y: glm_typing.Number, /) -> vec1: ... +@overload +def max(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def max(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def max(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, d: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def max(x: glm_typing.F32Vector2, y: glm_typing.Number, /) -> vec2: ... +@overload +def max(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def max(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def max(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, d: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def max(x: glm_typing.F32Vector3, y: glm_typing.Number, /) -> vec3: ... +@overload +def max(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def max(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def max(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, d: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def max(x: glm_typing.F32Vector4, y: glm_typing.Number, /) -> vec4: ... +@overload +def max(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def max(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def max(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, d: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def max(x: _NF32VT, y: glm_typing.Number, /) -> _NF32VT: ... +@overload +def max(x: _NF32VT, y: _NF32VT, /) -> _NF32VT: ... +@overload +def max(a: _NF32VT, b: _NF32VT, c: _NF32VT, /) -> _NF32VT: ... +@overload +def max(a: _NF32VT, b: _NF32VT, c: _NF32VT, d: _NF32VT, /) -> _NF32VT: ... +@overload +def max(_: Iterable[_T], /) -> _T: ... + +@overload +def min(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def min(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, /) -> float: ... +@overload +def min(a: glm_typing.Number, b: glm_typing.Number, c: glm_typing.Number, d: glm_typing.Number, /) -> float: ... +@overload +def min(x: glm_typing.F32Vector1, y: glm_typing.Number, /) -> vec1: ... +@overload +def min(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def min(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def min(a: glm_typing.F32Vector1, b: glm_typing.F32Vector1, c: glm_typing.F32Vector1, d: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def min(x: glm_typing.F32Vector2, y: glm_typing.Number, /) -> vec2: ... +@overload +def min(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def min(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def min(a: glm_typing.F32Vector2, b: glm_typing.F32Vector2, c: glm_typing.F32Vector2, d: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def min(x: glm_typing.F32Vector3, y: glm_typing.Number, /) -> vec3: ... +@overload +def min(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def min(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def min(a: glm_typing.F32Vector3, b: glm_typing.F32Vector3, c: glm_typing.F32Vector3, d: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def min(x: glm_typing.F32Vector4, y: glm_typing.Number, /) -> vec4: ... +@overload +def min(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def min(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def min(a: glm_typing.F32Vector4, b: glm_typing.F32Vector4, c: glm_typing.F32Vector4, d: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def min(x: _NF32VT, y: glm_typing.Number, /) -> _NF32VT: ... +@overload +def min(x: _NF32VT, y: _NF32VT, /) -> _NF32VT: ... +@overload +def min(a: _NF32VT, b: _NF32VT, c: _NF32VT, /) -> _NF32VT: ... +@overload +def min(a: _NF32VT, b: _NF32VT, c: _NF32VT, d: _NF32VT, /) -> _NF32VT: ... +@overload +def min(_: Iterable[_T], /) -> _T: ... + +@overload +def mix(x: glm_typing.Number, y: glm_typing.Number, a: glm_typing.Number, /) -> float: ... +@overload +def mix(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, a: Union[glm_typing.FDAnyVector1, glm_typing.BAnyVector1, glm_typing.Number], /) -> vec1: ... +@overload +def mix(x: _NF32V1T, y: _NF32V1T, a: Union[glm_typing.FDAnyVector1, glm_typing.BAnyVector1, glm_typing.Number], /) -> _NF32V1T: ... +@overload +def mix(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, a: Union[glm_typing.FDAnyVector2, glm_typing.BAnyVector2, glm_typing.Number], /) -> vec2: ... +@overload +def mix(x: _NF32V2T, y: _NF32V2T, a: Union[glm_typing.FDAnyVector2, glm_typing.BAnyVector2, glm_typing.Number], /) -> _NF32V2T: ... +@overload +def mix(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, a: Union[glm_typing.FDAnyVector3, glm_typing.BAnyVector3, glm_typing.Number], /) -> vec3: ... +@overload +def mix(x: _NF32V3T, y: _NF32V3T, a: Union[glm_typing.FDAnyVector3, glm_typing.BAnyVector3, glm_typing.Number], /) -> _NF32V3T: ... +@overload +def mix(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, a: Union[glm_typing.FDAnyVector4, glm_typing.BAnyVector4, glm_typing.Number], /) -> vec4: ... +@overload +def mix(x: _NF32V4T, y: _NF32V4T, a: Union[glm_typing.FDAnyVector4, glm_typing.BAnyVector4, glm_typing.Number], /) -> _NF32V4T: ... +@overload +def mix(x: glm_typing.F32Matrix2x2, y: glm_typing.F32Matrix2x2, a: Union[glm_typing.FAnyMatrix2x2, glm_typing.Number], /) -> mat2x2: ... +@overload +def mix(x: _NF32M2X2T, y: _NF32M2X2T, a: Union[glm_typing.FAnyMatrix2x2, glm_typing.Number], /) -> _NF32M2X2T: ... +@overload +def mix(x: glm_typing.F32Matrix2x3, y: glm_typing.F32Matrix2x3, a: Union[glm_typing.FAnyMatrix2x3, glm_typing.Number], /) -> mat2x3: ... +@overload +def mix(x: _NF32M2X3T, y: _NF32M2X3T, a: Union[glm_typing.FAnyMatrix2x3, glm_typing.Number], /) -> _NF32M2X3T: ... +@overload +def mix(x: glm_typing.F32Matrix2x4, y: glm_typing.F32Matrix2x4, a: Union[glm_typing.FAnyMatrix2x4, glm_typing.Number], /) -> mat2x4: ... +@overload +def mix(x: _NF32M2X4T, y: _NF32M2X4T, a: Union[glm_typing.FAnyMatrix2x4, glm_typing.Number], /) -> _NF32M2X4T: ... +@overload +def mix(x: glm_typing.F32Matrix3x2, y: glm_typing.F32Matrix3x2, a: Union[glm_typing.FAnyMatrix3x2, glm_typing.Number], /) -> mat3x2: ... +@overload +def mix(x: _NF32M3X2T, y: _NF32M3X2T, a: Union[glm_typing.FAnyMatrix3x2, glm_typing.Number], /) -> _NF32M3X2T: ... +@overload +def mix(x: glm_typing.F32Matrix3x3, y: glm_typing.F32Matrix3x3, a: Union[glm_typing.FAnyMatrix3x3, glm_typing.Number], /) -> mat3x3: ... +@overload +def mix(x: _NF32M3X3T, y: _NF32M3X3T, a: Union[glm_typing.FAnyMatrix3x3, glm_typing.Number], /) -> _NF32M3X3T: ... +@overload +def mix(x: glm_typing.F32Matrix3x4, y: glm_typing.F32Matrix3x4, a: Union[glm_typing.FAnyMatrix3x4, glm_typing.Number], /) -> mat3x4: ... +@overload +def mix(x: _NF32M3X4T, y: _NF32M3X4T, a: Union[glm_typing.FAnyMatrix3x4, glm_typing.Number], /) -> _NF32M3X4T: ... +@overload +def mix(x: glm_typing.F32Matrix4x2, y: glm_typing.F32Matrix4x2, a: Union[glm_typing.FAnyMatrix4x2, glm_typing.Number], /) -> mat4x2: ... +@overload +def mix(x: _NF32M4X2T, y: _NF32M4X2T, a: Union[glm_typing.FAnyMatrix4x2, glm_typing.Number], /) -> _NF32M4X2T: ... +@overload +def mix(x: glm_typing.F32Matrix4x3, y: glm_typing.F32Matrix4x3, a: Union[glm_typing.FAnyMatrix4x3, glm_typing.Number], /) -> mat4x3: ... +@overload +def mix(x: _NF32M4X3T, y: _NF32M4X3T, a: Union[glm_typing.FAnyMatrix4x3, glm_typing.Number], /) -> _NF32M4X3T: ... +@overload +def mix(x: glm_typing.F32Matrix4x4, y: glm_typing.F32Matrix4x4, a: Union[glm_typing.FAnyMatrix4x4, glm_typing.Number], /) -> mat4x4: ... +@overload +def mix(x: _NF32M4X4T, y: _NF32M4X4T, a: Union[glm_typing.FAnyMatrix4x4, glm_typing.Number], /) -> _NF32M4X4T: ... +@overload +def mix(x: _QT, y: _QT, a: glm_typing.Number, /) -> _QT: ... + +@overload +def modf(x: glm_typing.Number, /) -> Tuple[float, float]: ... +@overload +def modf(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def modf(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def modf(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def modf(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def modf(x: _FDVT, i: _FDVT, /) -> _FDVT: ... + +@overload +def round(x: glm_typing.Number, /) -> float: ... +@overload +def round(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def round(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def round(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def round(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def round(x: _FDVT, i: _FDVT, /) -> _FDVT: ... + +@overload +def roundEven(x: glm_typing.Number, /) -> float: ... +@overload +def roundEven(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def roundEven(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def roundEven(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def roundEven(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def roundEven(x: _FDVT, i: _FDVT, /) -> _FDVT: ... + +@overload +def sign(x: glm_typing.Number, /) -> float: ... +@overload +def sign(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def sign(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def sign(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def sign(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def sign(x: _FDVT, i: _FDVT, /) -> _FDVT: ... + +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.Number, /) -> float: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def smoothstep(edge0: glm_typing.F32Vector1, edge1: glm_typing.F32Vector1, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def smoothstep(edge0: glm_typing.F32Vector2, edge1: glm_typing.F32Vector2, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def smoothstep(edge0: glm_typing.F32Vector3, edge1: glm_typing.F32Vector3, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def smoothstep(edge0: glm_typing.F32Vector4, edge1: glm_typing.F32Vector4, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def smoothstep(edge0: glm_typing.Number, edge1: glm_typing.Number, x: _NF32VT, /) -> _FDVT: ... +@overload +def smoothstep(edge0: _NF32VT, edge1: _NF32VT, x: _NF32VT, /) -> _NF32VT: ... + +@overload +def step(edge: glm_typing.Number, x: glm_typing.Number, /) -> float: ... +@overload +def step(edge: glm_typing.Number, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def step(edge: glm_typing.F32Vector1, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def step(edge: glm_typing.Number, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def step(edge: glm_typing.F32Vector2, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def step(edge: glm_typing.Number, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def step(edge: glm_typing.F32Vector3, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def step(edge: glm_typing.Number, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def step(edge: glm_typing.F32Vector4, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def step(edge: glm_typing.Number, x: _NF32VT, /) -> _NF32VT: ... +@overload +def step(edge: _NF32VT, x: _NF32VT, /) -> _NF32VT: ... + +@overload +def trunc(x: glm_typing.Number, /) -> float: ... +@overload +def trunc(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def trunc(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def trunc(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def trunc(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def trunc(x: _FDVT, /) -> _FDVT: ... + +@overload +def uintBitsToFloat(x: int, /) -> float: ... +@overload +def uintBitsToFloat(x: glm_typing.U32Vector2, /) -> vec2: ... +@overload +def uintBitsToFloat(x: glm_typing.U32Vector3, /) -> vec3: ... +@overload +def uintBitsToFloat(x: glm_typing.U32Vector4, /) -> vec4: ... +@overload +def uintBitsToFloat(x: glm_typing.U32Vector1, /) -> vec1: ... + + +@overload +def exp(x: glm_typing.Number, /) -> float: ... +@overload +def exp(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def exp(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def exp(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def exp(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def exp(x: _FDVT, /) -> _FDVT: ... +@overload +def exp(x: _QT, /) -> _QT: ... + +@overload +def exp2(x: glm_typing.Number, /) -> float: ... +@overload +def exp2(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def exp2(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def exp2(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def exp2(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def exp2(x: _FDVT, /) -> _FDVT: ... + +@overload +def inversesqrt(x: glm_typing.Number, /) -> float: ... +@overload +def inversesqrt(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def inversesqrt(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def inversesqrt(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def inversesqrt(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def inversesqrt(x: _FDVT, /) -> _FDVT: ... + +@overload +def log(x: glm_typing.Number, /) -> float: ... +@overload +def log(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def log(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def log(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def log(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def log(x: _FDVT, /) -> _FDVT: ... +@overload +def log(x: _QT, /) -> _QT: ... + +@overload +def log2(x: glm_typing.Number, /) -> float: ... +@overload +def log2(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def log2(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def log2(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def log2(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def log2(x: _FDVT, /) -> _FDVT: ... + +@overload +def pow(base: glm_typing.Number, exponent: glm_typing.Number, /) -> float: ... +@overload +def pow(base: glm_typing.F32Vector1, exponent: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def pow(base: glm_typing.F32Vector2, exponent: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def pow(base: glm_typing.F32Vector3, exponent: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def pow(base: glm_typing.F32Vector4, exponent: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def pow(base: _NF32DFVT, exponent: _NF32DFVT, /) -> _NF32DFVT: ... +@overload +def pow(base: _QT, exponent: _QT, /) -> _QT: ... + +@overload +def sqrt(x: glm_typing.Number, /) -> float: ... +@overload +def sqrt(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def sqrt(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def sqrt(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def sqrt(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def sqrt(x: _FDVT, /) -> _FDVT: ... +@overload +def sqrt(x: _QT, /) -> _QT: ... + + +@overload +def cross(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def cross(x: _NF32DFV3T, y: _NF32DFV3T, /) -> _NF32DFV3T: ... +@overload +def cross(x: _QT, y: _QT, /) -> _QT: ... + +@overload +def distance(p0: glm_typing.Number, p1: glm_typing.Number, /) -> float: ... +@overload +def distance(p0: glm_typing.F32Vector1, p1: glm_typing.F32Vector1, /) -> float: ... +@overload +def distance(p0: glm_typing.F32Vector2, p1: glm_typing.F32Vector2, /) -> float: ... +@overload +def distance(p0: glm_typing.F32Vector3, p1: glm_typing.F32Vector3, /) -> float: ... +@overload +def distance(p0: glm_typing.F32Vector4, p1: glm_typing.F32Vector4, /) -> float: ... +@overload +def distance(p0: _NF32DFVT, p1: _NF32DFVT, /) -> float: ... + +@overload +def dot(x: glm_typing.Number, y: glm_typing.Number, /) -> float: ... +@overload +def dot(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> float: ... +@overload +def dot(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> float: ... +@overload +def dot(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def dot(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> float: ... +@overload +def dot(x: _NF32DFVT, y: _NF32DFVT, /) -> float: ... +@overload +def dot(x: _QT, y: _QT, /) -> float: ... + +@overload +def faceforward(N: glm_typing.Number, I: glm_typing.Number, Nref: float, /) -> float: ... +@overload +def faceforward(x: glm_typing.F32Vector1, I: glm_typing.F32Vector1, Nref: glm_typing.F32Vector1, /) -> float: ... +@overload +def faceforward(x: glm_typing.F32Vector2, I: glm_typing.F32Vector2, Nref: glm_typing.F32Vector2, /) -> float: ... +@overload +def faceforward(x: glm_typing.F32Vector3, I: glm_typing.F32Vector3, Nref: glm_typing.F32Vector3, /) -> float: ... +@overload +def faceforward(x: glm_typing.F32Vector4, I: glm_typing.F32Vector4, Nref: glm_typing.F32Vector4, /) -> float: ... +@overload +def faceforward(N: _NF32DFVT, I: _NF32DFVT, Nref: _NF32DFVT, /) -> _NF32DFVT: ... + +def length(x: Union[glm_typing.Number, glm_typing.FDAnyVectorAny, glm_typing.FDAnyQuaternion], /) -> float: ... + +@overload +def normalize(x: Tuple[glm_typing.Number], /) -> vec1: ... +@overload +def normalize(x: Tuple[glm_typing.Number, glm_typing.Number], /) -> vec2: ... +@overload +def normalize(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec3: ... +@overload +def normalize(x: Tuple[glm_typing.Number, glm_typing.Number, glm_typing.Number, glm_typing.Number], /) -> vec4: ... +@overload +def normalize(x: _FDVT, /) -> _FDVT: ... +@overload +def normalize(x: _QT, /) -> _QT: ... + +@overload +def reflect(I: glm_typing.Number, N: glm_typing.Number, /) -> float: ... +@overload +def reflect(I: glm_typing.F32Vector1, N: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def reflect(I: glm_typing.F32Vector2, N: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def reflect(I: glm_typing.F32Vector3, N: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def reflect(I: glm_typing.F32Vector4, N: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def reflect(I: _NF32DFVT, N: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def refract(I: glm_typing.Number, N: glm_typing.Number, eta: float, /) -> float: ... +@overload +def refract(I: glm_typing.F32Vector1, N: glm_typing.F32Vector1, eta: float, /) -> vec1: ... +@overload +def refract(I: glm_typing.F32Vector2, N: glm_typing.F32Vector2, eta: float, /) -> vec2: ... +@overload +def refract(I: glm_typing.F32Vector3, N: glm_typing.F32Vector3, eta: float, /) -> vec3: ... +@overload +def refract(I: glm_typing.F32Vector4, N: glm_typing.F32Vector4, eta: float, /) -> vec4: ... +@overload +def refract(I: _NF32DFVT, N: _NF32DFVT, eta: float, /) -> _NF32DFVT: ... + + +@overload +def bitCount(v: int, /) -> int: ... +@overload +def bitCount(v: glm_typing.IUAnyVector1, /) -> ivec1: ... +@overload +def bitCount(v: glm_typing.IUAnyVector2, /) -> ivec2: ... +@overload +def bitCount(v: glm_typing.IUAnyVector3, /) -> ivec3: ... +@overload +def bitCount(v: glm_typing.IUAnyVector4, /) -> ivec4: ... + +@overload +def bitfieldExtract(value: int, offset: int, bits: int, /) -> int: ... +@overload +def bitfieldExtract(v: glm_typing.I32Vector1, offset: int, bits: int, /) -> ivec1: ... +@overload +def bitfieldExtract(v: glm_typing.I32Vector2, offset: int, bits: int, /) -> ivec2: ... +@overload +def bitfieldExtract(v: glm_typing.I32Vector3, offset: int, bits: int, /) -> ivec3: ... +@overload +def bitfieldExtract(v: glm_typing.I32Vector4, offset: int, bits: int, /) -> ivec4: ... +@overload +def bitfieldExtract(value: _NI32IUVT, offset: int, bits: int, /) -> _NI32IUVT: ... + +@overload +def bitfieldInsert(base: int, insert: int, offset: int, bits: int, /) -> int: ... +@overload +def bitfieldInsert(base: glm_typing.I32Vector1, insert: glm_typing.I32Vector1, offset: int, bits: int, /) -> ivec1: ... +@overload +def bitfieldInsert(base: glm_typing.I32Vector2, insert: glm_typing.I32Vector2, offset: int, bits: int, /) -> ivec2: ... +@overload +def bitfieldInsert(base: glm_typing.I32Vector3, insert: glm_typing.I32Vector3, offset: int, bits: int, /) -> ivec3: ... +@overload +def bitfieldInsert(base: glm_typing.I32Vector4, insert: glm_typing.I32Vector4, offset: int, bits: int, /) -> ivec4: ... +@overload +def bitfieldInsert(base: _NI32IUVT, insert: _NI32IUVT, offset: int, bits: int, /) -> _NI32IUVT: ... + +@overload +def bitfieldReverse(value: int, /) -> int: ... +@overload +def bitfieldReverse(value: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def bitfieldReverse(value: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def bitfieldReverse(value: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def bitfieldReverse(value: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def bitfieldReverse(value: _NI32IUVT, /) -> _NI32IUVT: ... + +@overload +def findLSB(value: int, /) -> int: ... +@overload +def findLSB(value: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def findLSB(value: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def findLSB(value: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def findLSB(value: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def findLSB(value: _NI32IUVT, /) -> _NI32IUVT: ... + +@overload +def findMSB(value: int, /) -> int: ... +@overload +def findMSB(value: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def findMSB(value: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def findMSB(value: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def findMSB(value: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def findMSB(value: _NI32IUVT, /) -> _NI32IUVT: ... + +def imulExtended(x: _IVT, y: _IVT, msb: _IVT, lsb: _IVT, /) -> None: ... + +def uaddCarry(x: _UVT, y: _UVT, carry: _UVT, /) -> _UVT: ... + +def umulExtended(x: _UVT, y: _UVT, msb: _UVT, lsb: _UVT, /) -> None: ... + +def usubBorrow(x: _UVT, y: _UVT, borrow: _UVT, /) -> _UVT: ... + + +def determinant(m: glm_typing.AnyAnyMatrixSquare, /) -> float: ... + +@overload +def inverse(m: glm_typing.F32Matrix2x2, /) -> mat2x2: ... +@overload +def inverse(m: glm_typing.F32Matrix3x3, /) -> mat3x3: ... +@overload +def inverse(m: glm_typing.F32Matrix4x4, /) -> mat4x4: ... +@overload +def inverse(m: _NF32FDMSQRT, /) -> _NF32FDMSQRT: ... +@overload +def inverse(q: _QT, /) -> _QT: ... + +@overload +def matrixCompMult(x: glm_typing.F32Matrix2x2, y: glm_typing.F32Matrix2x2, /) -> mat2x2: ... +@overload +def matrixCompMult(x: glm_typing.F32Matrix3x3, y: glm_typing.F32Matrix3x3, /) -> mat3x3: ... +@overload +def matrixCompMult(x: glm_typing.F32Matrix4x4, y: glm_typing.F32Matrix4x4, /) -> mat4x4: ... +@overload +def matrixCompMult(x: _NF32FDMSQRT, y: _NF32FDMSQRT, /) -> _NF32FDMSQRT: ... + +@overload +def outerProduct(c: glm_typing.F32Vector2, r: glm_typing.F32Vector2, /) -> mat2x2: ... +@overload +def outerProduct(c: dvec2, r: dvec2, /) -> mat2x2: ... +@overload +def outerProduct(c: glm_typing.F32Vector2, r: glm_typing.F32Vector3, /) -> mat3x2: ... +@overload +def outerProduct(c: dvec2, r: dvec3, /) -> mat3x2: ... +@overload +def outerProduct(c: glm_typing.F32Vector2, r: glm_typing.F32Vector4, /) -> mat4x2: ... +@overload +def outerProduct(c: dvec2, r: dvec4, /) -> mat4x2: ... +@overload +def outerProduct(c: glm_typing.F32Vector3, r: glm_typing.F32Vector2, /) -> mat2x3: ... +@overload +def outerProduct(c: dvec3, r: dvec2, /) -> mat2x3: ... +@overload +def outerProduct(c: glm_typing.F32Vector3, r: glm_typing.F32Vector3, /) -> mat3x3: ... +@overload +def outerProduct(c: dvec3, r: dvec3, /) -> mat3x3: ... +@overload +def outerProduct(c: glm_typing.F32Vector3, r: glm_typing.F32Vector4, /) -> mat4x3: ... +@overload +def outerProduct(c: dvec3, r: dvec4, /) -> mat4x3: ... +@overload +def outerProduct(c: glm_typing.F32Vector4, r: glm_typing.F32Vector2, /) -> mat2x4: ... +@overload +def outerProduct(c: dvec4, r: dvec2, /) -> mat2x4: ... +@overload +def outerProduct(c: glm_typing.F32Vector4, r: glm_typing.F32Vector3, /) -> mat3x4: ... +@overload +def outerProduct(c: dvec4, r: dvec3, /) -> mat3x4: ... +@overload +def outerProduct(c: glm_typing.F32Vector4, r: glm_typing.F32Vector4, /) -> mat4x4: ... +@overload +def outerProduct(c: dvec4, r: dvec4, /) -> mat4x4: ... + +@overload +def transpose(x: glm_typing.F32Matrix2x2, /) -> fmat2x2: ... +@overload +def transpose(x: glm_typing.F32Matrix2x3, /) -> fmat3x2: ... +@overload +def transpose(x: glm_typing.F32Matrix2x4, /) -> fmat4x2: ... +@overload +def transpose(x: glm_typing.F32Matrix3x2, /) -> fmat2x3: ... +@overload +def transpose(x: glm_typing.F32Matrix3x3, /) -> fmat3x3: ... +@overload +def transpose(x: glm_typing.F32Matrix3x4, /) -> fmat4x3: ... +@overload +def transpose(x: glm_typing.F32Matrix4x2, /) -> fmat2x4: ... +@overload +def transpose(x: glm_typing.F32Matrix4x3, /) -> fmat3x4: ... +@overload +def transpose(x: glm_typing.F32Matrix4x4, /) -> fmat4x4: ... +@overload +def transpose(x: dmat2x2, /) -> dmat2x2: ... +@overload +def transpose(x: dmat2x3, /) -> dmat3x2: ... +@overload +def transpose(x: dmat2x4, /) -> dmat4x2: ... +@overload +def transpose(x: dmat3x2, /) -> dmat2x3: ... +@overload +def transpose(x: dmat3x3, /) -> dmat3x3: ... +@overload +def transpose(x: dmat3x4, /) -> dmat4x3: ... +@overload +def transpose(x: dmat4x2, /) -> dmat2x4: ... +@overload +def transpose(x: dmat4x3, /) -> dmat3x4: ... +@overload +def transpose(x: dmat4x4, /) -> dmat4x4: ... +@overload +def transpose(x: imat2x2, /) -> imat2x2: ... +@overload +def transpose(x: imat2x3, /) -> imat3x2: ... +@overload +def transpose(x: imat2x4, /) -> imat4x2: ... +@overload +def transpose(x: imat3x2, /) -> imat2x3: ... +@overload +def transpose(x: imat3x3, /) -> imat3x3: ... +@overload +def transpose(x: imat3x4, /) -> imat4x3: ... +@overload +def transpose(x: imat4x2, /) -> imat2x4: ... +@overload +def transpose(x: imat4x3, /) -> imat3x4: ... +@overload +def transpose(x: imat4x4, /) -> imat4x4: ... +@overload +def transpose(x: umat2x2, /) -> umat2x2: ... +@overload +def transpose(x: umat2x3, /) -> umat3x2: ... +@overload +def transpose(x: umat2x4, /) -> umat4x2: ... +@overload +def transpose(x: umat3x2, /) -> umat2x3: ... +@overload +def transpose(x: umat3x3, /) -> umat3x3: ... +@overload +def transpose(x: umat3x4, /) -> umat4x3: ... +@overload +def transpose(x: umat4x2, /) -> umat2x4: ... +@overload +def transpose(x: umat4x3, /) -> umat3x4: ... +@overload +def transpose(x: umat4x4, /) -> umat4x4: ... + + +def packDouble2x32(v: glm_typing.U32Vector2, /) -> float: ... + +def packHalf2x16(v: glm_typing.F32Vector2, /) -> int: ... + +def packSnorm2x16(v: glm_typing.F32Vector2, /) -> int: ... + +def packSnorm4x8(v: glm_typing.F32Vector4, /) -> int: ... + +def packUnorm2x16(v: glm_typing.F32Vector2, /) -> int: ... + +def packUnorm4x8(v: glm_typing.F32Vector4, /) -> int: ... + +def unpackDouble2x32(v: float, /) -> uvec2: ... + +def unpackHalf2x16(v: int, /) -> vec2: ... + +def unpackSnorm2x16(p: int, /) -> vec2: ... + +def unpackSnorm4x8(p: int, /) -> vec4: ... + +def unpackUnorm2x16(p: int, /) -> vec2: ... + +def unpackUnorm4x8(p: int, /) -> vec4: ... + + +@overload +def acos(x: glm_typing.Number, /) -> float: ... +@overload +def acos(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def acos(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def acos(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def acos(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def acos(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def acosh(x: glm_typing.Number, /) -> float: ... +@overload +def acosh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def acosh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def acosh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def acosh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def acosh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def asin(x: glm_typing.Number, /) -> float: ... +@overload +def asin(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def asin(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def asin(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def asin(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def asin(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def asinh(x: glm_typing.Number, /) -> float: ... +@overload +def asinh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def asinh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def asinh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def asinh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def asinh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def atan(y_over_x: glm_typing.Number, /) -> float: ... +@overload +def atan(y_over_x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def atan(y_over_x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def atan(y_over_x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def atan(y_over_x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def atan(y_over_x: _NF32DFVT, /) -> _NF32DFVT: ... +@overload +def atan(y: glm_typing.Number, x: glm_typing.Number, /) -> float: ... +@overload +def atan(y: glm_typing.F32Vector1, x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def atan(y: glm_typing.F32Vector2, x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def atan(y: glm_typing.F32Vector3, x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def atan(y: glm_typing.F32Vector4, x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def atan(y: _NF32DFVT, x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def atanh(x: glm_typing.Number, /) -> float: ... +@overload +def atanh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def atanh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def atanh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def atanh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def atanh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def cos(x: glm_typing.Number, /) -> float: ... +@overload +def cos(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def cos(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def cos(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def cos(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def cos(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def cosh(x: glm_typing.Number, /) -> float: ... +@overload +def cosh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def cosh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def cosh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def cosh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def cosh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def degrees(x: glm_typing.Number, /) -> float: ... +@overload +def degrees(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def degrees(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def degrees(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def degrees(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def degrees(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def radians(x: glm_typing.Number, /) -> float: ... +@overload +def radians(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def radians(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def radians(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def radians(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def radians(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def sin(x: glm_typing.Number, /) -> float: ... +@overload +def sin(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def sin(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def sin(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def sin(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def sin(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def sinh(x: glm_typing.Number, /) -> float: ... +@overload +def sinh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def sinh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def sinh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def sinh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def sinh(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def tan(x: glm_typing.Number, /) -> float: ... +@overload +def tan(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def tan(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def tan(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def tan(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def tan(x: _NF32DFVT, /) -> _NF32DFVT: ... + +@overload +def tanh(x: glm_typing.Number, /) -> float: ... +@overload +def tanh(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def tanh(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def tanh(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def tanh(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def tanh(x: _NF32DFVT, /) -> _NF32DFVT: ... + + + +def all(v: glm_typing.BAnyVectorAny, /) -> bool: ... + +def any(v: glm_typing.BAnyVectorAny, /) -> bool: ... + +@overload +def equal(x: glm_typing.Number, y: glm_typing.Number, ULPs: int, /) -> int: ... +@overload +def equal(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def equal(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def equal(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, ULPs_epsilon: Union[glm_typing.Number, ivec1, glm_typing.F32Vector1], /) -> bvec1: ... +@overload +def equal(x: _NF32V1T, y: _NF32V1T, ULPs_epsilon: Union[glm_typing.Number, ivec1, glm_typing.F32Vector1], /) -> bvec1: ... +@overload +def equal(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def equal(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def equal(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, ULPs_epsilon: Union[glm_typing.Number, ivec2, glm_typing.F32Vector2], /) -> bvec2: ... +@overload +def equal(x: _NF32V2T, y: _NF32V2T, ULPs_epsilon: Union[glm_typing.Number, ivec2, glm_typing.F32Vector2], /) -> bvec2: ... +@overload +def equal(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def equal(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def equal(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, ULPs_epsilon: Union[glm_typing.Number, ivec3, glm_typing.F32Vector3], /) -> bvec3: ... +@overload +def equal(x: _NF32V3T, y: _NF32V3T, ULPs_epsilon: Union[glm_typing.Number, ivec3, glm_typing.F32Vector3], /) -> bvec3: ... +@overload +def equal(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def equal(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... +@overload +def equal(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, ULPs_epsilon: Union[glm_typing.Number, ivec4, glm_typing.F32Vector4], /) -> bvec4: ... +@overload +def equal(x: _NF32V4T, y: _NF32V4T, ULPs_epsilon: Union[glm_typing.Number, ivec4, glm_typing.F32Vector4], /) -> bvec4: ... +@overload +def equal(x: glm_typing.F32Matrix2xAny, y: glm_typing.F32Matrix2xAny, /) -> bvec2: ... +@overload +def equal(x: _NF32M2XNT, y: _NF32M2XNT, /) -> bvec2: ... +@overload +def equal(x: glm_typing.F32Matrix2xAny, y: glm_typing.F32Matrix2xAny, ULPs_epsilon: Union[glm_typing.Number, ivec2, glm_typing.F32Vector2], /) -> bvec2: ... +@overload +def equal(x: _NF32M2XNT, y: _NF32M2XNT, ULPs_epsilon: Union[glm_typing.Number, ivec2, glm_typing.F32Vector2], /) -> bvec2: ... +@overload +def equal(x: glm_typing.F32Matrix3xAny, y: glm_typing.F32Matrix3xAny, /) -> bvec3: ... +@overload +def equal(x: _NF32M3XNT, y: _NF32M3XNT, /) -> bvec3: ... +@overload +def equal(x: glm_typing.F32Matrix3xAny, y: glm_typing.F32Matrix3xAny, ULPs_epsilon: Union[glm_typing.Number, ivec3, glm_typing.F32Vector3], /) -> bvec3: ... +@overload +def equal(x: _NF32M3XNT, y: _NF32M3XNT, ULPs_epsilon: Union[glm_typing.Number, ivec3, glm_typing.F32Vector3], /) -> bvec3: ... +@overload +def equal(x: glm_typing.F32Matrix4xAny, y: glm_typing.F32Matrix4xAny, /) -> bvec4: ... +@overload +def equal(x: _NF32M4XNT, y: _NF32M4XNT, /) -> bvec4: ... +@overload +def equal(x: glm_typing.F32Matrix4xAny, y: glm_typing.F32Matrix4xAny, ULPs_epsilon: Union[glm_typing.Number, ivec4, glm_typing.F32Vector4], /) -> bvec4: ... +@overload +def equal(x: _NF32M4XNT, y: _NF32M4XNT, ULPs_epsilon: Union[glm_typing.Number, ivec4, glm_typing.F32Vector4], /) -> bvec4: ... +@overload +def equal(x: _QT, y: _QT, /) -> int: ... + +@overload +def greaterThan(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def greaterThan(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def greaterThan(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def greaterThan(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def greaterThan(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def greaterThan(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def greaterThan(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def greaterThan(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def greaterThan(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +@overload +def greaterThanEqual(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def greaterThanEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def greaterThanEqual(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def greaterThanEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def greaterThanEqual(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def greaterThanEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def greaterThanEqual(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def greaterThanEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def greaterThanEqual(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +@overload +def lessThan(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def lessThan(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def lessThan(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def lessThan(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def lessThan(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def lessThan(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def lessThan(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def lessThan(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def lessThan(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +@overload +def lessThanEqual(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def lessThanEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def lessThanEqual(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def lessThanEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def lessThanEqual(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def lessThanEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def lessThanEqual(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def lessThanEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def lessThanEqual(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +@overload +def notEqual(x: _QT, y: _QT, /) -> bvec4: ... +@overload +def notEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> bvec1: ... +@overload +def notEqual(x: _NF32V1T, y: _NF32V1T, /) -> bvec1: ... +@overload +def notEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> bvec2: ... +@overload +def notEqual(x: _NF32V2T, y: _NF32V2T, /) -> bvec2: ... +@overload +def notEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> bvec3: ... +@overload +def notEqual(x: _NF32V3T, y: _NF32V3T, /) -> bvec3: ... +@overload +def notEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> bvec4: ... +@overload +def notEqual(x: _NF32V4T, y: _NF32V4T, /) -> bvec4: ... + +def not_(v: glm_typing.BAnyVectorAny, /) -> bool: ... + + +def add(a: Any, b: Any, /) -> Any: ... + +def and_(a: Any, b: Any, /) -> Any: ... + +def cmp(a: Any, b: Any, /) -> Any: ... + +def div(a: Any, b: Any, /) -> Any: ... + +def floordiv(a: Any, b: Any, /) -> Any: ... + +def if_else(b: Any, x: Any, y: Any, /) -> Any: ... + +def inv(a: Any, /) -> Any: ... + +def lshift(a: Any, b: Any, /) -> Any: ... + +def mul(a: Any, b: Any, /) -> Any: ... + +def neg(a: Any, /) -> Any: ... + +def or_(a: Any, b: Any, /) -> Any: ... + +def pos(a: Any, /) -> Any: ... + +def rshift(a: Any, b: Any, /) -> Any: ... + +def sub(a: Any, b: Any, /) -> Any: ... + +def xor(a: Any, b: Any, /) -> Any: ... + + + +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector1) -> vec1: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector1, Gamma: glm_typing.Number) -> vec1: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector2) -> vec2: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector2, Gamma: glm_typing.Number) -> vec2: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector3) -> vec3: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector3, Gamma: glm_typing.Number) -> vec3: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector4) -> vec4: ... +@overload +def convertLinearToSRGB(ColorLinear: glm_typing.F32Vector4, Gamma: glm_typing.Number) -> vec4: ... +@overload +def convertLinearToSRGB(ColorLinear: _NF32DFVT) -> _NF32DFVT: ... +@overload +def convertLinearToSRGB(ColorLinear: _NF32DFVT, Gamma: glm_typing.Number) -> _NF32DFVT: ... + +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector1) -> vec1: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector1, Gamma: glm_typing.Number) -> vec1: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector2) -> vec2: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector2, Gamma: glm_typing.Number) -> vec2: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector3) -> vec3: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector3, Gamma: glm_typing.Number) -> vec3: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector4) -> vec4: ... +@overload +def convertSRGBToLinear(ColorLinear: glm_typing.F32Vector4, Gamma: glm_typing.Number) -> vec4: ... +@overload +def convertSRGBToLinear(ColorLinear: _NF32DFVT) -> _NF32DFVT: ... +@overload +def convertSRGBToLinear(ColorLinear: _NF32DFVT, Gamma: glm_typing.Number) -> _NF32DFVT: ... + + +def e() -> float: ... + +def epsilon() -> float: ... + +def euler() -> float: ... + +def four_over_pi() -> float: ... + +def golden_ratio() -> float: ... + +def half_pi() -> float: ... + +def ln_ln_two() -> float: ... + +def ln_ten() -> float: ... + +def ln_two() -> float: ... + +def one() -> float: ... + +def one_over_pi() -> float: ... + +def one_over_root_two() -> float: ... + +def one_over_two_pi() -> float: ... + +def pi() -> float: ... + +def quarter_pi() -> float: ... + +def root_five() -> float: ... + +def root_half_pi() -> float: ... + +def root_ln_four() -> float: ... + +def root_pi() -> float: ... + +def root_three() -> float: ... + +def root_two() -> float: ... + +def root_two_pi() -> float: ... + +def third() -> float: ... + +def three_over_two_pi() -> float: ... + +def two_over_pi() -> float: ... + +def two_over_root_pi() -> float: ... + +def two_pi() -> float: ... + +def two_thirds() -> float: ... + +def zero() -> float: ... + + +@overload +def epsilonEqual(x: glm_typing.Number, y: glm_typing.Number, epsilon: glm_typing.Number, /) -> bool: ... +@overload +def epsilonEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, epsilon: glm_typing.Number, /) -> bvec1: ... +@overload +def epsilonEqual(x: _NF32DFV1T, y: _NF32DFV1T, epsilon: glm_typing.Number, /) -> bvec1: ... +@overload +def epsilonEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, epsilon: glm_typing.Number, /) -> bvec2: ... +@overload +def epsilonEqual(x: _NF32DFV2T, y: _NF32DFV2T, epsilon: glm_typing.Number, /) -> bvec2: ... +@overload +def epsilonEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, epsilon: glm_typing.Number, /) -> bvec3: ... +@overload +def epsilonEqual(x: _NF32DFV3T, y: _NF32DFV3T, epsilon: glm_typing.Number, /) -> bvec3: ... +@overload +def epsilonEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, epsilon: glm_typing.Number, /) -> bvec4: ... +@overload +def epsilonEqual(x: _NF32DFV4T, y: _NF32DFV4T, epsilon: glm_typing.Number, /) -> bvec4: ... + +@overload +def epsilonNotEqual(x: glm_typing.Number, y: glm_typing.Number, epsilon: glm_typing.Number, /) -> bool: ... +@overload +def epsilonNotEqual(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, epsilon: glm_typing.Number, /) -> bvec1: ... +@overload +def epsilonNotEqual(x: _NF32DFV1T, y: _NF32DFV1T, epsilon: glm_typing.Number, /) -> bvec1: ... +@overload +def epsilonNotEqual(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, epsilon: glm_typing.Number, /) -> bvec2: ... +@overload +def epsilonNotEqual(x: _NF32DFV2T, y: _NF32DFV2T, epsilon: glm_typing.Number, /) -> bvec2: ... +@overload +def epsilonNotEqual(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, epsilon: glm_typing.Number, /) -> bvec3: ... +@overload +def epsilonNotEqual(x: _NF32DFV3T, y: _NF32DFV3T, epsilon: glm_typing.Number, /) -> bvec3: ... +@overload +def epsilonNotEqual(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, epsilon: glm_typing.Number, /) -> bvec4: ... +@overload +def epsilonNotEqual(x: _NF32DFV4T, y: _NF32DFV4T, epsilon: glm_typing.Number, /) -> bvec4: ... + + +@overload +def iround(x: glm_typing.Number, /) -> int: ... +@overload +def iround(x: glm_typing.F32Vector1, /) -> ivec1: ... +@overload +def iround(x: _NF32DFV1T, /) -> ivec1: ... +@overload +def iround(x: glm_typing.F32Vector2, /) -> ivec2: ... +@overload +def iround(x: _NF32DFV2T, /) -> ivec2: ... +@overload +def iround(x: glm_typing.F32Vector3, /) -> ivec3: ... +@overload +def iround(x: _NF32DFV3T, /) -> ivec3: ... +@overload +def iround(x: glm_typing.F32Vector4, /) -> ivec4: ... +@overload +def iround(x: _NF32DFV4T, /) -> ivec4: ... + +@overload +def uround(x: glm_typing.Number, /) -> int: ... +@overload +def uround(x: glm_typing.F32Vector1, /) -> uvec1: ... +@overload +def uround(x: _NF32DFV1T, /) -> uvec1: ... +@overload +def uround(x: glm_typing.F32Vector2, /) -> uvec2: ... +@overload +def uround(x: _NF32DFV2T, /) -> uvec2: ... +@overload +def uround(x: glm_typing.F32Vector3, /) -> uvec3: ... +@overload +def uround(x: _NF32DFV3T, /) -> uvec3: ... +@overload +def uround(x: glm_typing.F32Vector4, /) -> uvec4: ... +@overload +def uround(x: _NF32DFV4T, /) -> uvec4: ... + + + +@overload +def column(m: glm_typing.F32Matrix2x2, index: int, /) -> vec2: ... +@overload +def column(m: glm_typing.F32Matrix2x2, index: int, x: glm_typing.F32Vector2, /) -> mat2x2: ... +@overload +def column(m: glm_typing.F32Matrix2x3, index: int, /) -> vec3: ... +@overload +def column(m: glm_typing.F32Matrix2x3, index: int, x: glm_typing.F32Vector3, /) -> mat2x3: ... +@overload +def column(m: glm_typing.F32Matrix2x4, index: int, /) -> vec4: ... +@overload +def column(m: glm_typing.F32Matrix2x4, index: int, x: glm_typing.F32Vector4, /) -> mat2x4: ... +@overload +def column(m: glm_typing.F32Matrix3x2, index: int, /) -> vec2: ... +@overload +def column(m: glm_typing.F32Matrix3x2, index: int, x: glm_typing.F32Vector2, /) -> mat3x2: ... +@overload +def column(m: glm_typing.F32Matrix3x3, index: int, /) -> vec3: ... +@overload +def column(m: glm_typing.F32Matrix3x3, index: int, x: glm_typing.F32Vector3, /) -> mat3x3: ... +@overload +def column(m: glm_typing.F32Matrix3x4, index: int, /) -> vec4: ... +@overload +def column(m: glm_typing.F32Matrix3x4, index: int, x: glm_typing.F32Vector4, /) -> mat3x4: ... +@overload +def column(m: glm_typing.F32Matrix4x2, index: int, /) -> vec2: ... +@overload +def column(m: glm_typing.F32Matrix4x2, index: int, x: glm_typing.F32Vector2, /) -> mat4x2: ... +@overload +def column(m: glm_typing.F32Matrix4x3, index: int, /) -> vec3: ... +@overload +def column(m: glm_typing.F32Matrix4x3, index: int, x: glm_typing.F32Vector3, /) -> mat4x3: ... +@overload +def column(m: glm_typing.F32Matrix4x4, index: int, /) -> vec4: ... +@overload +def column(m: glm_typing.F32Matrix4x4, index: int, x: glm_typing.F32Vector4, /) -> mat4x4: ... +@overload +def column(m: dmat2x2, index: int, /) -> dvec2: ... +@overload +def column(m: dmat2x2, index: int, x: Union[dvec2, dmvec2], /) -> dmat2x2: ... +@overload +def column(m: dmat2x3, index: int, /) -> dvec3: ... +@overload +def column(m: dmat2x3, index: int, x: Union[dvec3, dmvec3], /) -> dmat2x3: ... +@overload +def column(m: dmat2x4, index: int, /) -> dvec4: ... +@overload +def column(m: dmat2x4, index: int, x: Union[dvec4, dmvec4], /) -> dmat2x4: ... +@overload +def column(m: dmat3x2, index: int, /) -> dvec2: ... +@overload +def column(m: dmat3x2, index: int, x: Union[dvec2, dmvec2], /) -> dmat3x2: ... +@overload +def column(m: dmat3x3, index: int, /) -> dvec3: ... +@overload +def column(m: dmat3x3, index: int, x: Union[dvec3, dmvec3], /) -> dmat3x3: ... +@overload +def column(m: dmat3x4, index: int, /) -> dvec4: ... +@overload +def column(m: dmat3x4, index: int, x: Union[dvec4, dmvec4], /) -> dmat3x4: ... +@overload +def column(m: dmat4x2, index: int, /) -> dvec2: ... +@overload +def column(m: dmat4x2, index: int, x: Union[dvec2, dmvec2], /) -> dmat4x2: ... +@overload +def column(m: dmat4x3, index: int, /) -> dvec3: ... +@overload +def column(m: dmat4x3, index: int, x: Union[dvec3, dmvec3], /) -> dmat4x3: ... +@overload +def column(m: dmat4x4, index: int, /) -> dvec4: ... +@overload +def column(m: dmat4x4, index: int, x: Union[dvec4, dmvec4], /) -> dmat4x4: ... +@overload +def column(m: imat2x2, index: int, /) -> ivec2: ... +@overload +def column(m: imat2x2, index: int, x: Union[ivec2, imvec2], /) -> imat2x2: ... +@overload +def column(m: imat2x3, index: int, /) -> ivec3: ... +@overload +def column(m: imat2x3, index: int, x: Union[ivec3, imvec3], /) -> imat2x3: ... +@overload +def column(m: imat2x4, index: int, /) -> ivec4: ... +@overload +def column(m: imat2x4, index: int, x: Union[ivec4, imvec4], /) -> imat2x4: ... +@overload +def column(m: imat3x2, index: int, /) -> ivec2: ... +@overload +def column(m: imat3x2, index: int, x: Union[ivec2, imvec2], /) -> imat3x2: ... +@overload +def column(m: imat3x3, index: int, /) -> ivec3: ... +@overload +def column(m: imat3x3, index: int, x: Union[ivec3, imvec3], /) -> imat3x3: ... +@overload +def column(m: imat3x4, index: int, /) -> ivec4: ... +@overload +def column(m: imat3x4, index: int, x: Union[ivec4, imvec4], /) -> imat3x4: ... +@overload +def column(m: imat4x2, index: int, /) -> ivec2: ... +@overload +def column(m: imat4x2, index: int, x: Union[ivec2, imvec2], /) -> imat4x2: ... +@overload +def column(m: imat4x3, index: int, /) -> ivec3: ... +@overload +def column(m: imat4x3, index: int, x: Union[ivec3, imvec3], /) -> imat4x3: ... +@overload +def column(m: imat4x4, index: int, /) -> ivec4: ... +@overload +def column(m: imat4x4, index: int, x: Union[ivec4, imvec4], /) -> imat4x4: ... +@overload +def column(m: umat2x2, index: int, /) -> uvec2: ... +@overload +def column(m: umat2x2, index: int, x: Union[uvec2, umvec2], /) -> umat2x2: ... +@overload +def column(m: umat2x3, index: int, /) -> uvec3: ... +@overload +def column(m: umat2x3, index: int, x: Union[uvec3, umvec3], /) -> umat2x3: ... +@overload +def column(m: umat2x4, index: int, /) -> uvec4: ... +@overload +def column(m: umat2x4, index: int, x: Union[uvec4, umvec4], /) -> umat2x4: ... +@overload +def column(m: umat3x2, index: int, /) -> uvec2: ... +@overload +def column(m: umat3x2, index: int, x: Union[uvec2, umvec2], /) -> umat3x2: ... +@overload +def column(m: umat3x3, index: int, /) -> uvec3: ... +@overload +def column(m: umat3x3, index: int, x: Union[uvec3, umvec3], /) -> umat3x3: ... +@overload +def column(m: umat3x4, index: int, /) -> uvec4: ... +@overload +def column(m: umat3x4, index: int, x: Union[uvec4, umvec4], /) -> umat3x4: ... +@overload +def column(m: umat4x2, index: int, /) -> uvec2: ... +@overload +def column(m: umat4x2, index: int, x: Union[uvec2, umvec2], /) -> umat4x2: ... +@overload +def column(m: umat4x3, index: int, /) -> uvec3: ... +@overload +def column(m: umat4x3, index: int, x: Union[uvec3, umvec3], /) -> umat4x3: ... +@overload +def column(m: umat4x4, index: int, /) -> uvec4: ... +@overload +def column(m: umat4x4, index: int, x: Union[uvec4, umvec4], /) -> umat4x4: ... + +@overload +def row(m: glm_typing.F32Matrix2x2, index: int, /) -> vec2: ... +@overload +def row(m: glm_typing.F32Matrix2x2, index: int, x: glm_typing.F32Vector2, /) -> mat2x2: ... +@overload +def row(m: glm_typing.F32Matrix2x3, index: int, /) -> vec2: ... +@overload +def row(m: glm_typing.F32Matrix2x3, index: int, x: glm_typing.F32Vector2, /) -> mat2x3: ... +@overload +def row(m: glm_typing.F32Matrix2x4, index: int, /) -> vec2: ... +@overload +def row(m: glm_typing.F32Matrix2x4, index: int, x: glm_typing.F32Vector2, /) -> mat2x4: ... +@overload +def row(m: glm_typing.F32Matrix3x2, index: int, /) -> vec3: ... +@overload +def row(m: glm_typing.F32Matrix3x2, index: int, x: glm_typing.F32Vector3, /) -> mat3x2: ... +@overload +def row(m: glm_typing.F32Matrix3x3, index: int, /) -> vec3: ... +@overload +def row(m: glm_typing.F32Matrix3x3, index: int, x: glm_typing.F32Vector3, /) -> mat3x3: ... +@overload +def row(m: glm_typing.F32Matrix3x4, index: int, /) -> vec3: ... +@overload +def row(m: glm_typing.F32Matrix3x4, index: int, x: glm_typing.F32Vector3, /) -> mat3x4: ... +@overload +def row(m: glm_typing.F32Matrix4x2, index: int, /) -> vec4: ... +@overload +def row(m: glm_typing.F32Matrix4x2, index: int, x: glm_typing.F32Vector4, /) -> mat4x2: ... +@overload +def row(m: glm_typing.F32Matrix4x3, index: int, /) -> vec4: ... +@overload +def row(m: glm_typing.F32Matrix4x3, index: int, x: glm_typing.F32Vector4, /) -> mat4x3: ... +@overload +def row(m: glm_typing.F32Matrix4x4, index: int, /) -> vec4: ... +@overload +def row(m: glm_typing.F32Matrix4x4, index: int, x: glm_typing.F32Vector4, /) -> mat4x4: ... +@overload +def row(m: dmat2x2, index: int, /) -> dvec2: ... +@overload +def row(m: dmat2x2, index: int, x: Union[dvec2, dmvec2], /) -> dmat2x2: ... +@overload +def row(m: dmat2x3, index: int, /) -> dvec2: ... +@overload +def row(m: dmat2x3, index: int, x: Union[dvec2, dmvec2], /) -> dmat2x3: ... +@overload +def row(m: dmat2x4, index: int, /) -> dvec2: ... +@overload +def row(m: dmat2x4, index: int, x: Union[dvec2, dmvec2], /) -> dmat2x4: ... +@overload +def row(m: dmat3x2, index: int, /) -> dvec3: ... +@overload +def row(m: dmat3x2, index: int, x: Union[dvec3, dmvec3], /) -> dmat3x2: ... +@overload +def row(m: dmat3x3, index: int, /) -> dvec3: ... +@overload +def row(m: dmat3x3, index: int, x: Union[dvec3, dmvec3], /) -> dmat3x3: ... +@overload +def row(m: dmat3x4, index: int, /) -> dvec3: ... +@overload +def row(m: dmat3x4, index: int, x: Union[dvec3, dmvec3], /) -> dmat3x4: ... +@overload +def row(m: dmat4x2, index: int, /) -> dvec4: ... +@overload +def row(m: dmat4x2, index: int, x: Union[dvec4, dmvec4], /) -> dmat4x2: ... +@overload +def row(m: dmat4x3, index: int, /) -> dvec4: ... +@overload +def row(m: dmat4x3, index: int, x: Union[dvec4, dmvec4], /) -> dmat4x3: ... +@overload +def row(m: dmat4x4, index: int, /) -> dvec4: ... +@overload +def row(m: dmat4x4, index: int, x: Union[dvec4, dmvec4], /) -> dmat4x4: ... +@overload +def row(m: imat2x2, index: int, /) -> ivec2: ... +@overload +def row(m: imat2x2, index: int, x: Union[ivec2, imvec2], /) -> imat2x2: ... +@overload +def row(m: imat2x3, index: int, /) -> ivec2: ... +@overload +def row(m: imat2x3, index: int, x: Union[ivec2, imvec2], /) -> imat2x3: ... +@overload +def row(m: imat2x4, index: int, /) -> ivec2: ... +@overload +def row(m: imat2x4, index: int, x: Union[ivec2, imvec2], /) -> imat2x4: ... +@overload +def row(m: imat3x2, index: int, /) -> ivec3: ... +@overload +def row(m: imat3x2, index: int, x: Union[ivec3, imvec3], /) -> imat3x2: ... +@overload +def row(m: imat3x3, index: int, /) -> ivec3: ... +@overload +def row(m: imat3x3, index: int, x: Union[ivec3, imvec3], /) -> imat3x3: ... +@overload +def row(m: imat3x4, index: int, /) -> ivec3: ... +@overload +def row(m: imat3x4, index: int, x: Union[ivec3, imvec3], /) -> imat3x4: ... +@overload +def row(m: imat4x2, index: int, /) -> ivec4: ... +@overload +def row(m: imat4x2, index: int, x: Union[ivec4, imvec4], /) -> imat4x2: ... +@overload +def row(m: imat4x3, index: int, /) -> ivec4: ... +@overload +def row(m: imat4x3, index: int, x: Union[ivec4, imvec4], /) -> imat4x3: ... +@overload +def row(m: imat4x4, index: int, /) -> ivec4: ... +@overload +def row(m: imat4x4, index: int, x: Union[ivec4, imvec4], /) -> imat4x4: ... +@overload +def row(m: umat2x2, index: int, /) -> uvec2: ... +@overload +def row(m: umat2x2, index: int, x: Union[uvec2, umvec2], /) -> umat2x2: ... +@overload +def row(m: umat2x3, index: int, /) -> uvec2: ... +@overload +def row(m: umat2x3, index: int, x: Union[uvec2, umvec2], /) -> umat2x3: ... +@overload +def row(m: umat2x4, index: int, /) -> uvec2: ... +@overload +def row(m: umat2x4, index: int, x: Union[uvec2, umvec2], /) -> umat2x4: ... +@overload +def row(m: umat3x2, index: int, /) -> uvec3: ... +@overload +def row(m: umat3x2, index: int, x: Union[uvec3, umvec3], /) -> umat3x2: ... +@overload +def row(m: umat3x3, index: int, /) -> uvec3: ... +@overload +def row(m: umat3x3, index: int, x: Union[uvec3, umvec3], /) -> umat3x3: ... +@overload +def row(m: umat3x4, index: int, /) -> uvec3: ... +@overload +def row(m: umat3x4, index: int, x: Union[uvec3, umvec3], /) -> umat3x4: ... +@overload +def row(m: umat4x2, index: int, /) -> uvec4: ... +@overload +def row(m: umat4x2, index: int, x: Union[uvec4, umvec4], /) -> umat4x2: ... +@overload +def row(m: umat4x3, index: int, /) -> uvec4: ... +@overload +def row(m: umat4x3, index: int, x: Union[uvec4, umvec4], /) -> umat4x3: ... +@overload +def row(m: umat4x4, index: int, /) -> uvec4: ... +@overload +def row(m: umat4x4, index: int, x: Union[uvec4, umvec4], /) -> umat4x4: ... + + +@overload +def affineInverse(m: glm_typing.FAnyMatrix3x3, /) -> mat3x3: ... +@overload +def affineInverse(m: dmat3x3, /) -> dmat3x3: ... +@overload +def affineInverse(m: glm_typing.FAnyMatrix4x4, /) -> mat4x4: ... +@overload +def affineInverse(m: dmat4x4, /) -> dmat4x4: ... + +@overload +def inverseTranspose(m: glm_typing.FAnyMatrix2x2, /) -> mat2x2: ... +@overload +def inverseTranspose(m: dmat2x2, /) -> dmat2x2: ... +@overload +def inverseTranspose(m: glm_typing.FAnyMatrix3x3, /) -> mat3x3: ... +@overload +def inverseTranspose(m: dmat3x3, /) -> dmat3x3: ... +@overload +def inverseTranspose(m: glm_typing.FAnyMatrix4x4, /) -> mat4x4: ... +@overload +def inverseTranspose(m: dmat4x4, /) -> dmat4x4: ... + + +@overload +def perlin(p: glm_typing.FDAnyVectorAny, /) -> float: ... +@overload +def perlin(p: glm_typing.F32Vector1, rep: glm_typing.F32Vector1, /) -> float: ... +@overload +def perlin(p: glm_typing.F32Vector2, rep: glm_typing.F32Vector2, /) -> float: ... +@overload +def perlin(p: glm_typing.F32Vector3, rep: glm_typing.F32Vector3, /) -> float: ... +@overload +def perlin(p: glm_typing.F32Vector4, rep: glm_typing.F32Vector4, /) -> float: ... +@overload +def perlin(p: _NF32DFVT, rep: _NF32DFVT, /) -> float: ... + +def simplex(p: glm_typing.FDAnyVectorAny, /) -> float: ... + + +def packF2x11_1x10(v: glm_typing.F32Vector3, /) -> int: ... + +def packF3x9_E1x5(v: glm_typing.F32Vector3, /) -> int: ... + +@overload +def packHalf(v: glm_typing.F32Vector1, /) -> u16vec1: ... +@overload +def packHalf(v: glm_typing.F32Vector2, /) -> u16vec2: ... +@overload +def packHalf(v: glm_typing.F32Vector3, /) -> u16vec3: ... +@overload +def packHalf(v: glm_typing.F32Vector4, /) -> u16vec4: ... + +def packHalf1x16(v: float, /) -> int: ... + +def packHalf4x16(v: glm_typing.F32Vector4, /) -> int: ... + +def packI3x10_1x2(v: glm_typing.I32Vector4, /) -> int: ... + +def packInt2x16(v: glm_typing.I16Vector2, /) -> int: ... + +def packInt2x32(v: glm_typing.I32Vector2, /) -> int: ... + +def packInt2x8(v: glm_typing.I8Vector2, /) -> int: ... + +def packInt4x16(v: glm_typing.I16Vector4, /) -> int: ... + +def packInt4x8(v: glm_typing.I8Vector4, /) -> int: ... + +def packRGBM(v: glm_typing.F32Vector3, /) -> vec4: ... + +@overload +def packSnorm(t: ctypes.c_int8, v: glm_typing.F32Vector1, /) -> i8vec1: ... +@overload +def packSnorm(t: ctypes.c_int8, v: _NF32DFV1T, /) -> i8vec1: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector1, /) -> u8vec1: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: _NF32DFV1T, /) -> u8vec1: ... +@overload +def packSnorm(t: ctypes.c_int16, v: glm_typing.F32Vector1, /) -> i16vec1: ... +@overload +def packSnorm(t: ctypes.c_int16, v: _NF32DFV1T, /) -> i16vec1: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector1, /) -> u16vec1: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: _NF32DFV1T, /) -> u16vec1: ... +@overload +def packSnorm(t: ctypes.c_int32, v: glm_typing.F32Vector1, /) -> i32vec1: ... +@overload +def packSnorm(t: ctypes.c_int32, v: _NF32DFV1T, /) -> i32vec1: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector1, /) -> u32vec1: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: _NF32DFV1T, /) -> u32vec1: ... +@overload +def packSnorm(t: ctypes.c_int64, v: glm_typing.F32Vector1, /) -> i64vec1: ... +@overload +def packSnorm(t: ctypes.c_int64, v: _NF32DFV1T, /) -> i64vec1: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector1, /) -> u64vec1: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: _NF32DFV1T, /) -> u64vec1: ... +@overload +def packSnorm(t: ctypes.c_int8, v: glm_typing.F32Vector2, /) -> i8vec2: ... +@overload +def packSnorm(t: ctypes.c_int8, v: _NF32DFV2T, /) -> i8vec2: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector2, /) -> u8vec2: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: _NF32DFV2T, /) -> u8vec2: ... +@overload +def packSnorm(t: ctypes.c_int16, v: glm_typing.F32Vector2, /) -> i16vec2: ... +@overload +def packSnorm(t: ctypes.c_int16, v: _NF32DFV2T, /) -> i16vec2: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector2, /) -> u16vec2: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: _NF32DFV2T, /) -> u16vec2: ... +@overload +def packSnorm(t: ctypes.c_int32, v: glm_typing.F32Vector2, /) -> i32vec2: ... +@overload +def packSnorm(t: ctypes.c_int32, v: _NF32DFV2T, /) -> i32vec2: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector2, /) -> u32vec2: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: _NF32DFV2T, /) -> u32vec2: ... +@overload +def packSnorm(t: ctypes.c_int64, v: glm_typing.F32Vector2, /) -> i64vec2: ... +@overload +def packSnorm(t: ctypes.c_int64, v: _NF32DFV2T, /) -> i64vec2: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector2, /) -> u64vec2: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: _NF32DFV2T, /) -> u64vec2: ... +@overload +def packSnorm(t: ctypes.c_int8, v: glm_typing.F32Vector3, /) -> i8vec3: ... +@overload +def packSnorm(t: ctypes.c_int8, v: _NF32DFV3T, /) -> i8vec3: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector3, /) -> u8vec3: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: _NF32DFV3T, /) -> u8vec3: ... +@overload +def packSnorm(t: ctypes.c_int16, v: glm_typing.F32Vector3, /) -> i16vec3: ... +@overload +def packSnorm(t: ctypes.c_int16, v: _NF32DFV3T, /) -> i16vec3: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector3, /) -> u16vec3: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: _NF32DFV3T, /) -> u16vec3: ... +@overload +def packSnorm(t: ctypes.c_int32, v: glm_typing.F32Vector3, /) -> i32vec3: ... +@overload +def packSnorm(t: ctypes.c_int32, v: _NF32DFV3T, /) -> i32vec3: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector3, /) -> u32vec3: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: _NF32DFV3T, /) -> u32vec3: ... +@overload +def packSnorm(t: ctypes.c_int64, v: glm_typing.F32Vector3, /) -> i64vec3: ... +@overload +def packSnorm(t: ctypes.c_int64, v: _NF32DFV3T, /) -> i64vec3: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector3, /) -> u64vec3: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: _NF32DFV3T, /) -> u64vec3: ... +@overload +def packSnorm(t: ctypes.c_int8, v: glm_typing.F32Vector4, /) -> i8vec4: ... +@overload +def packSnorm(t: ctypes.c_int8, v: _NF32DFV4T, /) -> i8vec4: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector4, /) -> u8vec4: ... +@overload +def packSnorm(t: ctypes.c_uint8, v: _NF32DFV4T, /) -> u8vec4: ... +@overload +def packSnorm(t: ctypes.c_int16, v: glm_typing.F32Vector4, /) -> i16vec4: ... +@overload +def packSnorm(t: ctypes.c_int16, v: _NF32DFV4T, /) -> i16vec4: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector4, /) -> u16vec4: ... +@overload +def packSnorm(t: ctypes.c_uint16, v: _NF32DFV4T, /) -> u16vec4: ... +@overload +def packSnorm(t: ctypes.c_int32, v: glm_typing.F32Vector4, /) -> i32vec4: ... +@overload +def packSnorm(t: ctypes.c_int32, v: _NF32DFV4T, /) -> i32vec4: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector4, /) -> u32vec4: ... +@overload +def packSnorm(t: ctypes.c_uint32, v: _NF32DFV4T, /) -> u32vec4: ... +@overload +def packSnorm(t: ctypes.c_int64, v: glm_typing.F32Vector4, /) -> i64vec4: ... +@overload +def packSnorm(t: ctypes.c_int64, v: _NF32DFV4T, /) -> i64vec4: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector4, /) -> u64vec4: ... +@overload +def packSnorm(t: ctypes.c_uint64, v: _NF32DFV4T, /) -> u64vec4: ... + +def packSnorm1x16(v: float, /) -> int: ... + +def packSnorm1x8(v: float, /) -> int: ... + +def packSnorm2x8(v: glm_typing.F32Vector2, /) -> int: ... + +def packSnorm3x10_1x2(v: glm_typing.F32Vector4, /) -> int: ... + +def packSnorm4x16(v: glm_typing.F32Vector4, /) -> int: ... + +def packU3x10_1x2(v: glm_typing.U32Vector4, /) -> int: ... + +def packUint2x16(v: glm_typing.U16Vector2, /) -> int: ... + +def packUint2x32(v: glm_typing.U32Vector2, /) -> int: ... + +def packUint2x8(v: glm_typing.U8Vector2, /) -> int: ... + +def packUint4x16(v: glm_typing.U16Vector4, /) -> int: ... + +def packUint4x8(v: glm_typing.U16Vector4, /) -> int: ... + +@overload +def packUnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector1, /) -> u8vec1: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: _NF32DFV1T, /) -> u8vec1: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector1, /) -> u16vec1: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: _NF32DFV1T, /) -> u16vec1: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector1, /) -> u32vec1: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: _NF32DFV1T, /) -> u32vec1: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector1, /) -> u64vec1: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: _NF32DFV1T, /) -> u64vec1: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector2, /) -> u8vec2: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: _NF32DFV2T, /) -> u8vec2: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector2, /) -> u16vec2: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: _NF32DFV2T, /) -> u16vec2: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector2, /) -> u32vec2: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: _NF32DFV2T, /) -> u32vec2: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector2, /) -> u64vec2: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: _NF32DFV2T, /) -> u64vec2: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector3, /) -> u8vec3: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: _NF32DFV3T, /) -> u8vec3: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector3, /) -> u16vec3: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: _NF32DFV3T, /) -> u16vec3: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector3, /) -> u32vec3: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: _NF32DFV3T, /) -> u32vec3: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector3, /) -> u64vec3: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: _NF32DFV3T, /) -> u64vec3: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: glm_typing.F32Vector4, /) -> u8vec4: ... +@overload +def packUnorm(t: ctypes.c_uint8, v: _NF32DFV4T, /) -> u8vec4: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: glm_typing.F32Vector4, /) -> u16vec4: ... +@overload +def packUnorm(t: ctypes.c_uint16, v: _NF32DFV4T, /) -> u16vec4: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: glm_typing.F32Vector4, /) -> u32vec4: ... +@overload +def packUnorm(t: ctypes.c_uint32, v: _NF32DFV4T, /) -> u32vec4: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: glm_typing.F32Vector4, /) -> u64vec4: ... +@overload +def packUnorm(t: ctypes.c_uint64, v: _NF32DFV4T, /) -> u64vec4: ... + +def packUnorm1x16(v: float, /) -> int: ... + +def packUnorm1x5_1x6_1x5(v: glm_typing.F32Vector3, /) -> int: ... + +def packUnorm2x4(v: glm_typing.F32Vector2, /) -> int: ... + +def packUnorm2x8(v: glm_typing.F32Vector2, /) -> int: ... + +def packUnorm3x10_1x2(v: glm_typing.F32Vector4, /) -> int: ... + +def packUnorm4x16(v: glm_typing.F32Vector4, /) -> int: ... + +def packUnorm4x4(v: glm_typing.F32Vector4, /) -> int: ... + +def unpackF2x11_1x10(p: int, /) -> vec3: ... + +def unpackF3x9_E1x5(p: int, /) -> vec3: ... + +@overload +def unpackHalf(v: glm_typing.U16Vector1, /) -> vec1: ... +@overload +def unpackHalf(v: glm_typing.U16Vector2, /) -> vec2: ... +@overload +def unpackHalf(v: glm_typing.U16Vector3, /) -> vec3: ... +@overload +def unpackHalf(v: glm_typing.U16Vector4, /) -> vec4: ... + +def unpackHalf1x16(p: int, /) -> float: ... + +def unpackI3x10_1x2(p: int, /) -> ivec4: ... + +def unpackInt2x16(p: int, /) -> i16vec2: ... + +def unpackInt2x32(p: int, /) -> i32vec2: ... + +def unpackInt2x8(p: int, /) -> i8vec2: ... + +def unpackInt4x16(p: int, /) -> i16vec4: ... + +def unpackInt4x8(p: int, /) -> i8vec4: ... + +def unpackRGBM(p: glm_typing.F32Vector4, /) -> vec3: ... + +@overload +def unpackSnorm(t: ctypes.c_float, v: glm_typing.I32Vector1, /) -> vec1: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: _NI32IUV1T, /) -> vec1: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: glm_typing.I32Vector1, /) -> dvec1: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: _NI32IUV1T, /) -> dvec1: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: _NI32IUV2T, /) -> vec2: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: glm_typing.I32Vector2, /) -> dvec2: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: _NI32IUV2T, /) -> dvec2: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: _NI32IUV3T, /) -> vec3: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: glm_typing.I32Vector3, /) -> dvec3: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: _NI32IUV3T, /) -> dvec3: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def unpackSnorm(t: ctypes.c_float, v: _NI32IUV4T, /) -> vec4: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: glm_typing.I32Vector4, /) -> dvec4: ... +@overload +def unpackSnorm(t: ctypes.c_double, v: _NI32IUV4T, /) -> dvec4: ... + +def unpackSnorm1x16(p: int, /) -> float: ... + +def unpackSnorm1x8(p: int, /) -> float: ... + +def unpackSnorm2x8(p: int, /) -> vec2: ... + +def unpackSnorm3x10_1x2(p: int, /) -> vec4: ... + +def unpackSnorm4x16(p: int, /) -> vec4: ... + +def unpackU3x10_1x2(p: int, /) -> uvec4: ... + +def unpackUint2x16(p: int, /) -> u16vec2: ... + +def unpackUint2x32(p: int, /) -> u32vec2: ... + +def unpackUint2x8(p: int, /) -> u8vec2: ... + +def unpackUint4x16(p: int, /) -> u16vec4: ... + +def unpackUint4x8(p: int, /) -> u8vec4: ... + +@overload +def unpackUnorm(t: ctypes.c_float, v: glm_typing.I32Vector1, /) -> vec1: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: _NI32IUV1T, /) -> vec1: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: glm_typing.I32Vector1, /) -> dvec1: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: _NI32IUV1T, /) -> dvec1: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: _NI32IUV2T, /) -> vec2: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: glm_typing.I32Vector2, /) -> dvec2: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: _NI32IUV2T, /) -> dvec2: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: _NI32IUV3T, /) -> vec3: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: glm_typing.I32Vector3, /) -> dvec3: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: _NI32IUV3T, /) -> dvec3: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def unpackUnorm(t: ctypes.c_float, v: _NI32IUV4T, /) -> vec4: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: glm_typing.I32Vector4, /) -> dvec4: ... +@overload +def unpackUnorm(t: ctypes.c_double, v: _NI32IUV4T, /) -> dvec4: ... + +def unpackUnorm1x16(p: int, /) -> float: ... + +def unpackUnorm1x5_1x6_1x5(p: int, /) -> vec3: ... + +def unpackUnorm1x8(p: int, /) -> float: ... + +def unpackUnorm2x3_1x2(p: int, /) -> vec3: ... + +def unpackUnorm2x4(p: int, /) -> vec2: ... + +def unpackUnorm2x8(p: int, /) -> vec2: ... + +def unpackUnorm3x10_1x2(p: int, /) -> vec4: ... + +def unpackUnorm3x5_1x1(p: int, /) -> vec4: ... + +def unpackUnorm4x16(p: int, /) -> vec4: ... + +def unpackUnorm4x4(p: int, /) -> vec4: ... + + +@overload +def eulerAngles(x: glm_typing.F32Quaternion, /) -> vec3: ... +@overload +def eulerAngles(x: dquat, /) -> dvec3: ... + +@overload +def mat3_cast(x: glm_typing.F32Quaternion, /) -> mat3: ... +@overload +def mat3_cast(x: dquat, /) -> dmat3: ... + +@overload +def mat4_cast(x: glm_typing.F32Quaternion, /) -> mat4: ... +@overload +def mat4_cast(x: dquat, /) -> dmat4: ... + +def pitch(x: glm_typing.AnyAnyQuaternion, /) -> float: ... + +@overload +def quatLookAtLH(direction: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> quat: ... +@overload +def quatLookAtLH(direction: dvec3, up: dvec3, /) -> dquat: ... + +@overload +def quatLookAtRH(direction: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> quat: ... +@overload +def quatLookAtRH(direction: dvec3, up: dvec3, /) -> dquat: ... + +@overload +def quatLookAt(direction: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> quat: ... +@overload +def quatLookAt(direction: dvec3, up: dvec3, /) -> dquat: ... + +@overload +def quat_cast(x: Union[glm_typing.F32Matrix3x3, glm_typing.F32Matrix4x4], /) -> quat: ... +@overload +def quat_cast(x: Union[dmat3, dmat4], /) -> quat: ... + +def roll(x: glm_typing.AnyAnyQuaternion, /) -> float: ... + +def yaw(x: glm_typing.AnyAnyQuaternion, /) -> float: ... + + +def ballRand(Radius: glm_typing.Number, /) -> vec3: ... + +def circularRand(Radius: glm_typing.Number, /) -> vec2: ... + +def diskRand(Radius: glm_typing.Number, /) -> vec2: ... + +@overload +def gaussRand(Mean: glm_typing.Number, Deviation: glm_typing.Number, /) -> float: ... +@overload +def gaussRand(Mean: glm_typing.F32Vector1, Deviation: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def gaussRand(Mean: glm_typing.F32Vector2, Deviation: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def gaussRand(Mean: glm_typing.F32Vector3, Deviation: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def gaussRand(Mean: glm_typing.F32Vector4, Deviation: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def gaussRand(Mean: _NF32VT, Deviation: _NF32VT, /) -> _NF32VT: ... + +@overload +def linearRand(Min: glm_typing.Number, Max: glm_typing.Number, /) -> float: ... +@overload +def linearRand(Min: glm_typing.F32Vector1, Max: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def linearRand(Min: glm_typing.F32Vector2, Max: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def linearRand(Min: glm_typing.F32Vector3, Max: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def linearRand(Min: glm_typing.F32Vector4, Max: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def linearRand(Min: _NF32VT, Max: _NF32VT, /) -> _NF32VT: ... + +def setSeed(seed: SupportsInt, /) -> None: ... + +def sphericalRand(Radius: glm_typing.Number, /) -> vec3: ... + + +def acot(x: glm_typing.Number, /) -> float: ... + +def acoth(x: glm_typing.Number, /) -> float: ... + +def acsc(x: glm_typing.Number, /) -> float: ... + +def acsch(x: glm_typing.Number, /) -> float: ... + +def asec(x: glm_typing.Number, /) -> float: ... + +def asech(x: glm_typing.Number, /) -> float: ... + +def cot(x: glm_typing.Number, /) -> float: ... + +def coth(x: glm_typing.Number, /) -> float: ... + +def csc(x: glm_typing.Number, /) -> float: ... + +def csch(x: glm_typing.Number, /) -> float: ... + +def sec(x: glm_typing.Number, /) -> float: ... + +def sech(x: glm_typing.Number, /) -> float: ... + + +@overload +def ceilMultiple(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def ceilMultiple(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def ceilMultiple(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def ceilMultiple(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def ceilMultiple(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def ceilMultiple(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def ceilPowerOfTwo(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def ceilPowerOfTwo(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def ceilPowerOfTwo(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def ceilPowerOfTwo(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def ceilPowerOfTwo(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def ceilPowerOfTwo(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def floorMultiple(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def floorMultiple(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def floorMultiple(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def floorMultiple(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def floorMultiple(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def floorMultiple(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def floorPowerOfTwo(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def floorPowerOfTwo(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def floorPowerOfTwo(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def floorPowerOfTwo(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def floorPowerOfTwo(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def floorPowerOfTwo(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def roundMultiple(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def roundMultiple(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def roundMultiple(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def roundMultiple(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def roundMultiple(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def roundMultiple(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + +@overload +def roundPowerOfTwo(v: glm_typing.Number, Multiple: glm_typing.Number, /) -> int: ... +@overload +def roundPowerOfTwo(v: glm_typing.I32Vector1, Multiple: glm_typing.I32Vector1, /) -> ivec1: ... +@overload +def roundPowerOfTwo(v: glm_typing.I32Vector2, Multiple: glm_typing.I32Vector2, /) -> ivec2: ... +@overload +def roundPowerOfTwo(v: glm_typing.I32Vector3, Multiple: glm_typing.I32Vector3, /) -> ivec3: ... +@overload +def roundPowerOfTwo(v: glm_typing.I32Vector4, Multiple: glm_typing.I32Vector4, /) -> ivec4: ... +@overload +def roundPowerOfTwo(v: _NI32IVT, Multiple: _NI32IVT, /) -> _NI32IVT: ... + + +def make_mat2(x: ctypes.pointer[Any], /) -> mat2x2: ... + +def make_mat3(x: ctypes.pointer[Any], /) -> mat3x3: ... + +def make_mat4(x: ctypes.pointer[Any], /) -> mat4x4: ... + +def make_mat2x2(x: ctypes.pointer[Any], /) -> mat2x2: ... + +def make_mat2x3(x: ctypes.pointer[Any], /) -> mat2x3: ... + +def make_mat2x4(x: ctypes.pointer[Any], /) -> mat2x4: ... + +def make_mat3x2(x: ctypes.pointer[Any], /) -> mat3x2: ... + +def make_mat3x3(x: ctypes.pointer[Any], /) -> mat3x3: ... + +def make_mat3x4(x: ctypes.pointer[Any], /) -> mat3x4: ... + +def make_mat4x2(x: ctypes.pointer[Any], /) -> mat4x2: ... + +def make_mat4x3(x: ctypes.pointer[Any], /) -> mat4x3: ... + +def make_mat4x4(x: ctypes.pointer[Any], /) -> mat4x4: ... + +def make_quat(x: ctypes.pointer[Any], /) -> quat: ... + +def make_vec2(x: ctypes.pointer[Any], /) -> vec2: ... + +def make_vec3(x: ctypes.pointer[Any], /) -> vec3: ... + +def make_vec4(x: ctypes.pointer[Any], /) -> vec4: ... + +@overload +def sizeof(x: Type[Union[ctypes.c_bool, ctypes.c_short, ctypes.c_long, ctypes.c_longlong, ctypes.c_byte, ctypes.c_ushort, ctypes.c_ulong, ctypes.c_ulonglong, ctypes.c_ubyte, ctypes.c_double, ctypes.c_float, glm_typing.AnyAnyVecAny, glm_typing.AnyAnyMatAnyxAny, glm_typing.AnyAnyQuat]], /) -> int: ... +@overload +def sizeof(x: Union[ctypes.c_bool, ctypes.c_short, ctypes.c_long, ctypes.c_longlong, ctypes.c_byte, ctypes.c_ushort, ctypes.c_ulong, ctypes.c_ulonglong, ctypes.c_ubyte, ctypes.c_double, ctypes.c_float, array[Any], glm_typing.AnyAnyVecAny, glm_typing.AnyAnyMatAnyxAny, glm_typing.AnyAnyQuat], /) -> int: ... + +@overload +def value_ptr(x: Union[glm_typing.F32VecAny, glm_typing.F32MatAnyxAny, glm_typing.F32Quat], /) -> ctypes.pointer[ctypes.c_float]: ... +@overload +def value_ptr(x: Union[glm_typing.D64VecAny, glm_typing.D64MatAnyxAny, glm_typing.D64Quat], /) -> ctypes.pointer[ctypes.c_double]: ... +@overload +def value_ptr(x: Union[glm_typing.I32VecAny, glm_typing.I32MatAnyxAny], /) -> ctypes.pointer[ctypes.c_int32]: ... +@overload +def value_ptr(x: Union[glm_typing.U32VecAny, glm_typing.U32MatAnyxAny], /) -> ctypes.pointer[ctypes.c_uint32]: ... +@overload +def value_ptr(x: glm_typing.I8VecAny, /) -> ctypes.pointer[ctypes.c_int8]: ... +@overload +def value_ptr(x: glm_typing.U8VecAny, /) -> ctypes.pointer[ctypes.c_uint8]: ... +@overload +def value_ptr(x: glm_typing.B8VecAny, /) -> ctypes.pointer[ctypes.c_bool]: ... +@overload +def value_ptr(x: glm_typing.I16VecAny, /) -> ctypes.pointer[ctypes.c_int16]: ... +@overload +def value_ptr(x: glm_typing.U16VecAny, /) -> ctypes.pointer[ctypes.c_uint16]: ... +@overload +def value_ptr(x: glm_typing.I64VecAny, /) -> ctypes.pointer[ctypes.c_int64]: ... +@overload +def value_ptr(x: glm_typing.U64VecAny, /) -> ctypes.pointer[ctypes.c_uint64]: ... + + +@overload +def float_distance(x: glm_typing.Number, y: glm_typing.Number) -> float: ... +@overload +def float_distance(x: glm_typing.F32Vector1, y: glm_typing.F32Vector1, /) -> ivec1: ... +@overload +def float_distance(x: dvec1, y: dvec1, /) -> i64vec1: ... +@overload +def float_distance(x: glm_typing.F32Vector2, y: glm_typing.F32Vector2, /) -> ivec2: ... +@overload +def float_distance(x: dvec2, y: dvec2, /) -> i64vec2: ... +@overload +def float_distance(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> ivec3: ... +@overload +def float_distance(x: dvec3, y: dvec3, /) -> i64vec3: ... +@overload +def float_distance(x: glm_typing.F32Vector4, y: glm_typing.F32Vector4, /) -> ivec4: ... +@overload +def float_distance(x: dvec4, y: dvec4, /) -> i64vec4: ... + +@overload +def next_float(x: glm_typing.Number, /) -> float: ... +@overload +def next_float(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def next_float(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def next_float(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def next_float(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def next_float(x: _NF32DFVT, /) -> _NF32DFVT: ... +@overload +def next_float(x: glm_typing.Number, ULPs: glm_typing.Number, /) -> float: ... +@overload +def next_float(x: glm_typing.F32Vector1, ULPs: glm_typing.Number, /) -> vec1: ... +@overload +def next_float(x: glm_typing.F32Vector2, ULPs: glm_typing.Number, /) -> vec2: ... +@overload +def next_float(x: glm_typing.F32Vector3, ULPs: glm_typing.Number, /) -> vec3: ... +@overload +def next_float(x: glm_typing.F32Vector4, ULPs: glm_typing.Number, /) -> vec4: ... +@overload +def next_float(x: _NF32DFVT, ULPs: glm_typing.Number, /) -> _NF32DFVT: ... +@overload +def next_float(x: glm_typing.F32Vector1, ULPs: glm_typing.I32Vector1, /) -> vec1: ... +@overload +def next_float(x: _NF32DFV1T, ULPs: glm_typing.I32Vector1, /) -> _NF32DFV1T: ... +@overload +def next_float(x: glm_typing.F32Vector2, ULPs: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def next_float(x: _NF32DFV2T, ULPs: glm_typing.I32Vector2, /) -> _NF32DFV2T: ... +@overload +def next_float(x: glm_typing.F32Vector3, ULPs: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def next_float(x: _NF32DFV3T, ULPs: glm_typing.I32Vector3, /) -> _NF32DFV3T: ... +@overload +def next_float(x: glm_typing.F32Vector4, ULPs: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def next_float(x: _NF32DFV4T, ULPs: glm_typing.I32Vector4, /) -> _NF32DFV4T: ... + +@overload +def prev_float(x: glm_typing.Number, /) -> float: ... +@overload +def prev_float(x: glm_typing.F32Vector1, /) -> vec1: ... +@overload +def prev_float(x: glm_typing.F32Vector2, /) -> vec2: ... +@overload +def prev_float(x: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def prev_float(x: glm_typing.F32Vector4, /) -> vec4: ... +@overload +def prev_float(x: _NF32DFVT, /) -> _NF32DFVT: ... +@overload +def prev_float(x: glm_typing.Number, ULPs: glm_typing.Number, /) -> float: ... +@overload +def prev_float(x: glm_typing.F32Vector1, ULPs: glm_typing.Number, /) -> vec1: ... +@overload +def prev_float(x: glm_typing.F32Vector2, ULPs: glm_typing.Number, /) -> vec2: ... +@overload +def prev_float(x: glm_typing.F32Vector3, ULPs: glm_typing.Number, /) -> vec3: ... +@overload +def prev_float(x: glm_typing.F32Vector4, ULPs: glm_typing.Number, /) -> vec4: ... +@overload +def prev_float(x: _NF32DFVT, ULPs: glm_typing.Number, /) -> _NF32DFVT: ... +@overload +def prev_float(x: glm_typing.F32Vector1, ULPs: glm_typing.I32Vector1, /) -> vec1: ... +@overload +def prev_float(x: _NF32DFV1T, ULPs: glm_typing.I32Vector1, /) -> _NF32DFV1T: ... +@overload +def prev_float(x: glm_typing.F32Vector2, ULPs: glm_typing.I32Vector2, /) -> vec2: ... +@overload +def prev_float(x: _NF32DFV2T, ULPs: glm_typing.I32Vector2, /) -> _NF32DFV2T: ... +@overload +def prev_float(x: glm_typing.F32Vector3, ULPs: glm_typing.I32Vector3, /) -> vec3: ... +@overload +def prev_float(x: _NF32DFV3T, ULPs: glm_typing.I32Vector3, /) -> _NF32DFV3T: ... +@overload +def prev_float(x: glm_typing.F32Vector4, ULPs: glm_typing.I32Vector4, /) -> vec4: ... +@overload +def prev_float(x: _NF32DFV4T, ULPs: glm_typing.I32Vector4, /) -> _NF32DFV4T: ... + + +def frustumLH_NO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumLH_ZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumRH_NO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumRH_ZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustum(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumNO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumRH(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumLH(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def frustumZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def infinitePerspectiveLH(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, /) -> mat4x4: ... + +def infinitePerspectiveRH(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, /) -> mat4x4: ... + +def infinitePerspective(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, /) -> mat4x4: ... + +def orthoLH_NO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoLH_ZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoRH_NO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoRH_ZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def ortho(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoLH(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoNO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoRH(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def orthoZO(left: glm_typing.Number, right: glm_typing.Number, bottom: glm_typing.Number, top: glm_typing.Number, zNear: glm_typing.Number, zFar: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveLH_NO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveLH_ZO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveRH_NO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveRH_ZO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspective(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveLH(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveNO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveRH(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveZO(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovLH_NO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovLH_ZO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovRH_NO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovRH_ZO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFov(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovLH(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovNO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovRH(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +def perspectiveFovZO(fov: glm_typing.Number, width: glm_typing.Number, height: glm_typing.Number, near: glm_typing.Number, far: glm_typing.Number, /) -> mat4x4: ... + +@overload +def tweakedInfinitePerspective(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, /) -> mat4x4: ... +@overload +def tweakedInfinitePerspective(fovy: glm_typing.Number, aspect: glm_typing.Number, near: glm_typing.Number, epsilon: float, /) -> mat4x4: ... + + +@overload +def pickMatrix(center: glm_typing.F32Vector2, delta: glm_typing.F32Vector2, viewport: glm_typing.F32Vector4, /) -> mat4x4: ... +@overload +def pickMatrix(center: dvec2, delta: dvec2, viewport: dvec4, /) -> dmat4x4: ... + +@overload +def projectNO(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def projectNO(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def project(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def project(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def projectZO(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def projectZO(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def unProjectNO(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def unProjectNO(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def unProject(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def unProject(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + +@overload +def unProjectZO(obj: glm_typing.F32Vector3, model: glm_typing.F32Matrix4x4, proj: glm_typing.F32Matrix4x4, viewport: glm_typing.F32Vector4, /) -> vec3: ... +@overload +def unProjectZO(obj: dvec3, model: dmat4x4, proj: dmat4x4, viewport: dvec4, /) -> dvec3: ... + + +def identity(matrix_type: Type[_MT], /) -> _MT: ... + +@overload +def lookAtLH(eye: glm_typing.F32Vector3, center: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def lookAtLH(eye: dvec3, center: dvec3, up: dvec3, /) -> dmat4x4: ... + +@overload +def lookAtRH(eye: glm_typing.F32Vector3, center: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def lookAtRH(eye: dvec3, center: dvec3, up: dvec3, /) -> dmat4x4: ... + +@overload +def lookAt(eye: glm_typing.F32Vector3, center: glm_typing.F32Vector3, up: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def lookAt(eye: dvec3, center: dvec3, up: dvec3, /) -> dmat4x4: ... + +@overload +def rotate(angle: glm_typing.Number, axis: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def rotate(angle: glm_typing.Number, axis: dvec3, /) -> dmat4x4: ... +@overload +def rotate(angle: glm_typing.Number, /) -> mat3x3: ... +@overload +def rotate(m: glm_typing.F32Matrix4x4, angle: glm_typing.Number, axis: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def rotate(m: dmat4x4, angle: glm_typing.Number, axis: dvec3, /) -> dmat4x4: ... +@overload +def rotate(m: glm_typing.F32Matrix3x3, angle: glm_typing.Number, /) -> mat3x3: ... +@overload +def rotate(m: dmat3x3, angle: glm_typing.Number, /) -> dmat3x3: ... +@overload +def rotate(v: glm_typing.F32Vector2, angle: glm_typing.Number, /) -> vec2: ... +@overload +def rotate(v: dvec2, angle: glm_typing.Number, /) -> dvec2: ... +@overload +def rotate(v: glm_typing.F32Vector3, angle: glm_typing.Number, normal: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def rotate(v: dvec3, angle: glm_typing.Number, normal: dvec3, /) -> dvec3: ... +@overload +def rotate(v: glm_typing.F32Vector4, angle: glm_typing.Number, normal: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def rotate(v: dvec4, angle: glm_typing.Number, normal: dvec3, /) -> dvec4: ... +@overload +def rotate(v: quat, angle: glm_typing.Number, normal: glm_typing.F32Vector3, /) -> quat: ... +@overload +def rotate(v: dquat, angle: glm_typing.Number, normal: dvec3, /) -> dquat: ... + +@overload +def rotate_slow(m: glm_typing.F32Matrix4x4, angle: glm_typing.Number, axis: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def rotate_slow(m: dmat4x4, angle: glm_typing.Number, axis: dvec3, /) -> dmat4x4: ... + +@overload +def scale(v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def scale(v: dvec3, /) -> dmat4x4: ... +@overload +def scale(v: glm_typing.F32Vector2, /) -> mat3x3: ... +@overload +def scale(v: dvec2, /) -> mat3x3: ... +@overload +def scale(m: glm_typing.F32Matrix4x4, v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def scale(m: dmat4x4, v: dvec3, /) -> dmat4x4: ... +@overload +def scale(m: glm_typing.F32Matrix3x3, v: glm_typing.F32Vector2, /) -> mat3x3: ... +@overload +def scale(m: dmat3x3, v: dvec2, /) -> dmat3x3: ... + +@overload +def scale_slow(m: glm_typing.F32Matrix4x4, v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def scale_slow(m: dmat4x4, v: dvec3, /) -> dmat4x4: ... + +@overload +def translate(v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def translate(v: dvec3, /) -> dmat4x4: ... +@overload +def translate(v: glm_typing.F32Vector2, /) -> mat3x3: ... +@overload +def translate(v: dvec2, /) -> dmat3x3: ... +@overload +def translate(m: glm_typing.F32Matrix4x4, v: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def translate(m: dmat4x4, v: dvec3, /) -> dmat4x4: ... +@overload +def translate(m: glm_typing.F32Matrix3x3, v: glm_typing.F32Vector2, /) -> mat3x3: ... +@overload +def translate(m: dmat3x3, v: dvec2, /) -> dmat3x3: ... + + +@overload +def conjugate(q: glm_typing.F32Quaternion, /) -> quat: ... +@overload +def conjugate(q: _NF32QT, /) -> _NF32QT: ... + +@overload +def lerp(x: glm_typing.F32Quaternion, y: glm_typing.F32Quaternion, a: glm_typing.Number, /) -> quat: ... +@overload +def lerp(x: _NF32QT, y: _NF32QT, a: glm_typing.Number, /) -> _NF32QT: ... +@overload +def lerp(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, a: glm_typing.Number, /) -> vec3: ... +@overload +def lerp(x: _NF32DFV3T, y: _NF32DFV3T, a: glm_typing.Number, /) -> _NF32DFV3T: ... + +@overload +def slerp(x: glm_typing.F32Quaternion, y: glm_typing.F32Quaternion, a: glm_typing.Number, /) -> quat: ... +@overload +def slerp(x: _NF32QT, y: _NF32QT, a: glm_typing.Number, /) -> _NF32QT: ... +@overload +def slerp(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, a: glm_typing.Number, /) -> vec3: ... +@overload +def slerp(x: _NF32DFV3T, y: _NF32DFV3T, a: glm_typing.Number, /) -> _NF32DFV3T: ... + + +def angle(x: _QT, /) -> float: ... + +@overload +def angleAxis(angle: glm_typing.Number, axis: glm_typing.F32Vector3, /) -> quat: ... +@overload +def angleAxis(angle: glm_typing.Number, axis: dvec3, /) -> dquat: ... + +@overload +def axis(x: glm_typing.F32Quat, /) -> vec3: ... +@overload +def axis(x: dquat, /) -> dvec3: ... + + +@overload +def decompose(modelMatrix: glm_typing.F32Matrix3x3, scale: glm_typing.F32Vector3, orientation: glm_typing.F32Quaternion, translation: glm_typing.F32Vector3, skew: glm_typing.F32Vector3, perspective: glm_typing.F32Vector4, /) -> bool: ... +@overload +def decompose(modelMatrix: dmat4x4, scale: dvec3, orientation: dquat, translation: dvec3, skew: dvec3, perspective: dvec4, /) -> bool: ... + + +@overload +def shearX(m: glm_typing.F32Matrix3x3, y: glm_typing.Number, /) -> mat3x3: ... +@overload +def shearX(m: _NF32M3X3T, y: glm_typing.Number, /) -> _NF32M3X3T: ... + +@overload +def shearY(m: glm_typing.F32Matrix3x3, y: glm_typing.Number, /) -> mat3x3: ... +@overload +def shearY(m: _NF32M3X3T, y: glm_typing.Number, /) -> _NF32M3X3T: ... + + + +@overload +def distance2(p0: glm_typing.F32Vector1, p1: glm_typing.F32Vector1, /) -> float: ... +@overload +def distance2(p0: glm_typing.F32Vector2, p1: glm_typing.F32Vector2, /) -> float: ... +@overload +def distance2(p0: glm_typing.F32Vector3, p1: glm_typing.F32Vector3, /) -> float: ... +@overload +def distance2(p0: glm_typing.F32Vector4, p1: glm_typing.F32Vector4, /) -> float: ... +@overload +def distance2(p0: _NF32DFVT, p1: _NF32DFVT, /) -> float: ... + +@overload +def l1Norm(v: glm_typing.FDAnyVector3, /) -> float: ... +@overload +def l1Norm(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def l1Norm(x: _NF32DFV3T, y: _NF32DFV3T, /) -> float: ... + +@overload +def l2Norm(v: glm_typing.FDAnyVector3, /) -> float: ... +@overload +def l2Norm(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def l2Norm(x: _NF32DFV3T, y: _NF32DFV3T, /) -> float: ... + +@overload +def lMaxNorm(v: glm_typing.FDAnyVector3, /) -> float: ... +@overload +def lMaxNorm(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def lMaxNorm(x: _NF32DFV3T, y: _NF32DFV3T, /) -> float: ... + +@overload +def length2(p0: glm_typing.F32Vector1, p1: glm_typing.F32Vector1, /) -> float: ... +@overload +def length2(p0: glm_typing.F32Vector2, p1: glm_typing.F32Vector2, /) -> float: ... +@overload +def length2(p0: glm_typing.F32Vector3, p1: glm_typing.F32Vector3, /) -> float: ... +@overload +def length2(p0: glm_typing.F32Vector4, p1: glm_typing.F32Vector4, /) -> float: ... +@overload +def length2(p0: _NF32DFVT, p1: _NF32DFVT, /) -> float: ... + +@overload +def lxNorm(v: glm_typing.FDAnyVector3, /) -> float: ... +@overload +def lxNorm(x: glm_typing.F32Vector3, y: glm_typing.F32Vector3, /) -> float: ... +@overload +def lxNorm(x: _NF32DFV3T, y: _NF32DFV3T, /) -> float: ... + + +@overload +def euclidean(polar: glm_typing.F32Vector2, /) -> vec3: ... +@overload +def euclidean(polar: dvec2, /) -> dvec3: ... + +@overload +def polar(euclidean: glm_typing.F32Vector3, /) -> vec3: ... +@overload +def polar(euclidean: _NF32DFV3T, /) -> _NF32DFV3T: ... + + +@overload +def orientation(Normal: glm_typing.F32Vector3, Up: glm_typing.F32Vector3, /) -> mat4x4: ... +@overload +def orientation(Normal: dvec3, Up: dvec3, /) -> dmat4x4: ... + +@overload +def rotateX(v: glm_typing.F32Vector3, angle: glm_typing.Number) -> vec3: ... +@overload +def rotateX(v: _NF32DFV3T, angle: glm_typing.Number) -> _NF32DFV3T: ... +@overload +def rotateX(v: glm_typing.F32Vector4, angle: glm_typing.Number) -> vec4: ... +@overload +def rotateX(v: _NF32DFV4T, angle: glm_typing.Number) -> _NF32DFV4T: ... + +@overload +def rotateY(v: glm_typing.F32Vector3, angle: glm_typing.Number) -> vec3: ... +@overload +def rotateY(v: _NF32DFV3T, angle: glm_typing.Number) -> _NF32DFV3T: ... +@overload +def rotateY(v: glm_typing.F32Vector4, angle: glm_typing.Number) -> vec4: ... +@overload +def rotateY(v: _NF32DFV4T, angle: glm_typing.Number) -> _NF32DFV4T: ... + +@overload +def rotateZ(v: glm_typing.F32Vector3, angle: glm_typing.Number) -> vec3: ... +@overload +def rotateZ(v: _NF32DFV3T, angle: glm_typing.Number) -> _NF32DFV3T: ... +@overload +def rotateZ(v: glm_typing.F32Vector4, angle: glm_typing.Number) -> vec4: ... +@overload +def rotateZ(v: _NF32DFV4T, angle: glm_typing.Number) -> _NF32DFV4T: ... + +__all__ = ['abs', 'acos', 'acosh', 'acot', 'acoth', 'acsc', 'acsch', 'add', 'affineInverse', 'all', 'and_', 'angle', 'angleAxis', 'any', 'array', 'asec', 'asech', 'asin', 'asinh', 'atan', 'atanh', 'axis', 'ballRand', 'bitCount', 'bitfieldExtract', 'bitfieldInsert', 'bitfieldReverse', 'bool_', 'bvec1', 'bvec2', 'bvec3', 'bvec4', 'c_int16', 'c_int32', 'c_int64', 'c_int8', 'c_uint16', 'c_uint32', 'c_uint64', 'c_uint8', 'ceil', 'ceilMultiple', 'ceilPowerOfTwo', 'circularRand', 'clamp', 'cmp', 'column', 'conjugate', 'convertLinearToSRGB', 'convertSRGBToLinear', 'cos', 'cosh', 'cot', 'coth', 'cross', 'csc', 'csch', 'decompose', 'degrees', 'determinant', 'diskRand', 'distance', 'distance2', 'div', 'dmat2', 'dmat2x2', 'dmat2x3', 'dmat2x4', 'dmat3', 'dmat3x2', 'dmat3x3', 'dmat3x4', 'dmat4', 'dmat4x2', 'dmat4x3', 'dmat4x4', 'dmvec2', 'dmvec3', 'dmvec4', 'dot', 'double', 'dquat', 'dvec1', 'dvec2', 'dvec3', 'dvec4', 'e', 'epsilon', 'epsilonEqual', 'epsilonNotEqual', 'equal', 'euclidean', 'euler', 'eulerAngles', 'exp', 'exp2', 'f32mat2', 'f32mat2x2', 'f32mat2x3', 'f32mat2x4', 'f32mat3', 'f32mat3x2', 'f32mat3x3', 'f32mat3x4', 'f32mat4', 'f32mat4x2', 'f32mat4x3', 'f32mat4x4', 'f32quat', 'f32vec1', 'f32vec2', 'f32vec3', 'f32vec4', 'f64mat2', 'f64mat2x2', 'f64mat2x3', 'f64mat2x4', 'f64mat3', 'f64mat3x2', 'f64mat3x3', 'f64mat3x4', 'f64mat4', 'f64mat4x2', 'f64mat4x3', 'f64mat4x4', 'f64quat', 'f64vec1', 'f64vec2', 'f64vec3', 'f64vec4', 'faceforward', 'findLSB', 'findMSB', 'float32', 'float64', 'floatBitsToInt', 'floatBitsToUint', 'float_', 'float_distance', 'floor', 'floorMultiple', 'floorPowerOfTwo', 'floordiv', 'fma', 'fmat2', 'fmat2x2', 'fmat2x3', 'fmat2x4', 'fmat3', 'fmat3x2', 'fmat3x3', 'fmat3x4', 'fmat4', 'fmat4x2', 'fmat4x3', 'fmat4x4', 'fmax', 'fmin', 'four_over_pi', 'fquat', 'fract', 'frexp', 'frustum', 'frustumLH', 'frustumLH_NO', 'frustumLH_ZO', 'frustumNO', 'frustumRH', 'frustumRH_NO', 'frustumRH_ZO', 'frustumZO', 'fvec1', 'fvec2', 'fvec3', 'fvec4', 'gaussRand', 'golden_ratio', 'greaterThan', 'greaterThanEqual', 'half_pi', 'i16vec1', 'i16vec2', 'i16vec3', 'i16vec4', 'i32mat2', 'i32mat2x2', 'i32mat2x3', 'i32mat2x4', 'i32mat3', 'i32mat3x2', 'i32mat3x3', 'i32mat3x4', 'i32mat4', 'i32mat4x2', 'i32mat4x3', 'i32mat4x4', 'i32vec1', 'i32vec2', 'i32vec3', 'i32vec4', 'i64vec1', 'i64vec2', 'i64vec3', 'i64vec4', 'i8vec1', 'i8vec2', 'i8vec3', 'i8vec4', 'identity', 'if_else', 'imat2', 'imat2x2', 'imat2x3', 'imat2x4', 'imat3', 'imat3x2', 'imat3x3', 'imat3x4', 'imat4', 'imat4x2', 'imat4x3', 'imat4x4', 'imulExtended', 'imvec2', 'imvec3', 'imvec4', 'infinitePerspective', 'infinitePerspectiveLH', 'infinitePerspectiveRH', 'int16', 'int32', 'int64', 'int8', 'intBitsToFloat', 'inv', 'inverse', 'inverseTranspose', 'inversesqrt', 'iround', 'isinf', 'isnan', 'ivec1', 'ivec2', 'ivec3', 'ivec4', 'l1Norm', 'l2Norm', 'lMaxNorm', 'ldexp', 'length2', 'lerp', 'lessThan', 'lessThanEqual', 'linearRand', 'ln_ln_two', 'ln_ten', 'ln_two', 'log', 'log2', 'lookAt', 'lookAtLH', 'lookAtRH', 'lshift', 'lxNorm', 'make_mat2', 'make_mat2x2', 'make_mat2x3', 'make_mat2x4', 'make_mat3', 'make_mat3x2', 'make_mat3x3', 'make_mat3x4', 'make_mat4', 'make_mat4x2', 'make_mat4x3', 'make_mat4x4', 'make_quat', 'make_vec2', 'make_vec3', 'make_vec4', 'mat2', 'mat2x2', 'mat2x3', 'mat2x4', 'mat3', 'mat3_cast', 'mat3x2', 'mat3x3', 'mat3x4', 'mat4', 'mat4_cast', 'mat4x2', 'mat4x3', 'mat4x4', 'matrixCompMult', 'max', 'min', 'mix', 'modf', 'mul', 'mvec2', 'mvec3', 'mvec4', 'neg', 'next_float', 'normalize', 'notEqual', 'not_', 'one', 'one_over_pi', 'one_over_root_two', 'or_', 'orientation', 'ortho', 'orthoLH', 'orthoLH_NO', 'orthoLH_ZO', 'orthoNO', 'orthoRH', 'orthoRH_NO', 'orthoRH_ZO', 'orthoZO', 'outerProduct', 'packDouble2x32', 'packF2x11_1x10', 'packF3x9_E1x5', 'packHalf', 'packHalf1x16', 'packHalf2x16', 'packHalf4x16', 'packI3x10_1x2', 'packInt2x16', 'packInt2x32', 'packInt2x8', 'packInt4x16', 'packInt4x8', 'packRGBM', 'packSnorm', 'packSnorm1x16', 'packSnorm1x8', 'packSnorm2x16', 'packSnorm2x8', 'packSnorm3x10_1x2', 'packSnorm4x16', 'packSnorm4x8', 'packU3x10_1x2', 'packUint2x16', 'packUint2x32', 'packUint2x8', 'packUint4x16', 'packUint4x8', 'packUnorm', 'packUnorm1x16', 'packUnorm1x5_1x6_1x5', 'packUnorm2x16', 'packUnorm2x4', 'packUnorm2x8', 'packUnorm3x10_1x2', 'packUnorm4x16', 'packUnorm4x4', 'packUnorm4x8', 'perlin', 'perspective', 'perspectiveFov', 'perspectiveFovLH', 'perspectiveFovLH_NO', 'perspectiveFovLH_ZO', 'perspectiveFovNO', 'perspectiveFovRH', 'perspectiveFovRH_NO', 'perspectiveFovRH_ZO', 'perspectiveFovZO', 'perspectiveLH', 'perspectiveLH_NO', 'perspectiveLH_ZO', 'perspectiveNO', 'perspectiveRH', 'perspectiveRH_NO', 'perspectiveRH_ZO', 'perspectiveZO', 'pi', 'pickMatrix', 'pitch', 'polar', 'pos', 'pow', 'prev_float', 'project', 'projectNO', 'projectZO', 'quat', 'quatLookAt', 'quatLookAtLH', 'quatLookAtRH', 'quater_pi', 'radians', 'reflect', 'refract', 'roll', 'root_five', 'root_half_pi', 'root_ln_four', 'root_pi', 'root_three', 'root_two', 'root_two_pi', 'round', 'roundEven', 'roundMultiple', 'roundPowerOfTwo', 'row', 'rshift', 'sec', 'sech', 'setSeed', 'shearX', 'shearY', 'sign', 'simplex', 'sin', 'sinh', 'sizeof', 'slerp', 'smoothstep', 'sphericalRand', 'sqrt', 'step', 'sub', 'tan', 'tanh', 'third', 'three_over_two_pi', 'transpose', 'trunc', 'tweakedInfinitePerspective', 'two_over_pi', 'two_over_root_pi', 'two_pi', 'two_thirds', 'u16vec1', 'u16vec2', 'u16vec3', 'u16vec4', 'u32mat2', 'u32mat2x2', 'u32mat2x3', 'u32mat2x4', 'u32mat3', 'u32mat3x2', 'u32mat3x3', 'u32mat3x4', 'u32mat4', 'u32mat4x2', 'u32mat4x3', 'u32mat4x4', 'u32vec1', 'u32vec2', 'u32vec3', 'u32vec4', 'u64vec1', 'u64vec2', 'u64vec3', 'u64vec4', 'u8vec1', 'u8vec2', 'u8vec3', 'u8vec4', 'uaddCarry', 'uint16', 'uint32', 'uint64', 'uint8', 'uintBitsToFloat', 'umat2', 'umat2x2', 'umat2x3', 'umat2x4', 'umat3', 'umat3x2', 'umat3x3', 'umat3x4', 'umat4', 'umat4x2', 'umat4x3', 'umat4x4', 'umulExtended', 'umvec2', 'umvec3', 'umvec4', 'unProject', 'unProjectNO', 'unProjectZO', 'unpackDouble2x32', 'unpackF2x11_1x10', 'unpackF3x9_E1x5', 'unpackHalf', 'unpackHalf1x16', 'unpackHalf2x16', 'unpackI3x10_1x2', 'unpackInt2x16', 'unpackInt2x32', 'unpackInt2x8', 'unpackInt4x16', 'unpackInt4x8', 'unpackRGBM', 'unpackSnorm', 'unpackSnorm1x16', 'unpackSnorm1x8', 'unpackSnorm2x16', 'unpackSnorm2x8', 'unpackSnorm3x10_1x2', 'unpackSnorm4x16', 'unpackSnorm4x8', 'unpackU3x10_1x2', 'unpackUint2x16', 'unpackUint2x32', 'unpackUint2x8', 'unpackUint4x16', 'unpackUint4x8', 'unpackUnorm', 'unpackUnorm1x16', 'unpackUnorm1x5_1x6_1x5', 'unpackUnorm1x8', 'unpackUnorm2x16', 'unpackUnorm2x3_1x2', 'unpackUnorm2x4', 'unpackUnorm2x8', 'unpackUnorm3x10_1x2', 'unpackUnorm3x5_1x1', 'unpackUnorm4x16', 'unpackUnorm4x4', 'unpackUnorm4x8', 'uround', 'usubBorrow', 'uvec1', 'uvec2', 'uvec3', 'uvec4', 'value_ptr', 'vec1', 'vec2', 'vec3', 'vec4', 'xor', 'yaw', 'zero'] diff --git a/pyglm/glm_typing.py b/pyglm/glm_typing.py new file mode 100644 index 00000000..bd077b28 --- /dev/null +++ b/pyglm/glm_typing.py @@ -0,0 +1,530 @@ + +# generated by tools/generate.py +# https://github.com/esoma/pyglm-typing/ + +from typing import SupportsFloat, SupportsInt, Tuple, Union + +from . import glm + +Number = Union[SupportsFloat, SupportsInt] +B8Vector1 = Union[glm.bvec1, Tuple[Number]] +B8Vec1 = glm.bvec1 +B8Vector2 = Union[glm.bvec2, Tuple[Number, Number]] +B8Vec2 = glm.bvec2 +B8Vector3 = Union[glm.bvec3, Tuple[Number, Number, Number]] +B8Vec3 = glm.bvec3 +B8Vector4 = Union[glm.bvec4, Tuple[Number, Number, Number, Number]] +B8Vec4 = glm.bvec4 +B8VectorAny = Union[glm.bvec1, glm.bvec2, glm.bvec3, glm.bvec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +B8VecAny = Union[glm.bvec1, glm.bvec2, glm.bvec3, glm.bvec4] +BAnyVector1 = Union[glm.bvec1, Tuple[Number]] +BAnyVec1 = glm.bvec1 +BAnyVector2 = Union[glm.bvec2, Tuple[Number, Number]] +BAnyVec2 = glm.bvec2 +BAnyVector3 = Union[glm.bvec3, Tuple[Number, Number, Number]] +BAnyVec3 = glm.bvec3 +BAnyVector4 = Union[glm.bvec4, Tuple[Number, Number, Number, Number]] +BAnyVec4 = glm.bvec4 +BAnyVectorAny = Union[glm.bvec1, glm.bvec2, glm.bvec3, glm.bvec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +BAnyVecAny = Union[glm.bvec1, glm.bvec2, glm.bvec3, glm.bvec4] +D64Vector1 = Union[glm.dvec1, Tuple[Number]] +D64Vec1 = glm.dvec1 +D64Vector2 = Union[glm.dmvec2, glm.dvec2, Tuple[Number, Number]] +D64Vec2 = Union[glm.dmvec2, glm.dvec2] +D64Vector3 = Union[glm.dmvec3, glm.dvec3, Tuple[Number, Number, Number]] +D64Vec3 = Union[glm.dmvec3, glm.dvec3] +D64Vector4 = Union[glm.dmvec4, glm.dvec4, Tuple[Number, Number, Number, Number]] +D64Vec4 = Union[glm.dmvec4, glm.dvec4] +D64VectorAny = Union[glm.dmvec2, glm.dmvec3, glm.dmvec4, glm.dvec1, glm.dvec2, glm.dvec3, glm.dvec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +D64VecAny = Union[glm.dmvec2, glm.dmvec3, glm.dmvec4, glm.dvec1, glm.dvec2, glm.dvec3, glm.dvec4] +DAnyVector1 = Union[glm.dvec1, Tuple[Number]] +DAnyVec1 = glm.dvec1 +DAnyVector2 = Union[glm.dmvec2, glm.dvec2, Tuple[Number, Number]] +DAnyVec2 = Union[glm.dmvec2, glm.dvec2] +DAnyVector3 = Union[glm.dmvec3, glm.dvec3, Tuple[Number, Number, Number]] +DAnyVec3 = Union[glm.dmvec3, glm.dvec3] +DAnyVector4 = Union[glm.dmvec4, glm.dvec4, Tuple[Number, Number, Number, Number]] +DAnyVec4 = Union[glm.dmvec4, glm.dvec4] +DAnyVectorAny = Union[glm.dmvec2, glm.dmvec3, glm.dmvec4, glm.dvec1, glm.dvec2, glm.dvec3, glm.dvec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +DAnyVecAny = Union[glm.dmvec2, glm.dmvec3, glm.dmvec4, glm.dvec1, glm.dvec2, glm.dvec3, glm.dvec4] +F32Vector1 = Union[glm.vec1, Tuple[Number]] +F32Vec1 = glm.vec1 +F32Vector2 = Union[glm.mvec2, glm.vec2, Tuple[Number, Number]] +F32Vec2 = Union[glm.mvec2, glm.vec2] +F32Vector3 = Union[glm.mvec3, glm.vec3, Tuple[Number, Number, Number]] +F32Vec3 = Union[glm.mvec3, glm.vec3] +F32Vector4 = Union[glm.mvec4, glm.vec4, Tuple[Number, Number, Number, Number]] +F32Vec4 = Union[glm.mvec4, glm.vec4] +F32VectorAny = Union[glm.mvec2, glm.mvec3, glm.mvec4, glm.vec1, glm.vec2, glm.vec3, glm.vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +F32VecAny = Union[glm.mvec2, glm.mvec3, glm.mvec4, glm.vec1, glm.vec2, glm.vec3, glm.vec4] +FAnyVector1 = Union[glm.vec1, Tuple[Number]] +FAnyVec1 = glm.vec1 +FAnyVector2 = Union[glm.mvec2, glm.vec2, Tuple[Number, Number]] +FAnyVec2 = Union[glm.mvec2, glm.vec2] +FAnyVector3 = Union[glm.mvec3, glm.vec3, Tuple[Number, Number, Number]] +FAnyVec3 = Union[glm.mvec3, glm.vec3] +FAnyVector4 = Union[glm.mvec4, glm.vec4, Tuple[Number, Number, Number, Number]] +FAnyVec4 = Union[glm.mvec4, glm.vec4] +FAnyVectorAny = Union[glm.mvec2, glm.mvec3, glm.mvec4, glm.vec1, glm.vec2, glm.vec3, glm.vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +FAnyVecAny = Union[glm.mvec2, glm.mvec3, glm.mvec4, glm.vec1, glm.vec2, glm.vec3, glm.vec4] +I8Vector1 = Union[glm.i8vec1, Tuple[Number]] +I8Vec1 = glm.i8vec1 +I8Vector2 = Union[glm.i8vec2, Tuple[Number, Number]] +I8Vec2 = glm.i8vec2 +I8Vector3 = Union[glm.i8vec3, Tuple[Number, Number, Number]] +I8Vec3 = glm.i8vec3 +I8Vector4 = Union[glm.i8vec4, Tuple[Number, Number, Number, Number]] +I8Vec4 = glm.i8vec4 +I8VectorAny = Union[glm.i8vec1, glm.i8vec2, glm.i8vec3, glm.i8vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +I8VecAny = Union[glm.i8vec1, glm.i8vec2, glm.i8vec3, glm.i8vec4] +I16Vector1 = Union[glm.i16vec1, Tuple[Number]] +I16Vec1 = glm.i16vec1 +I16Vector2 = Union[glm.i16vec2, Tuple[Number, Number]] +I16Vec2 = glm.i16vec2 +I16Vector3 = Union[glm.i16vec3, Tuple[Number, Number, Number]] +I16Vec3 = glm.i16vec3 +I16Vector4 = Union[glm.i16vec4, Tuple[Number, Number, Number, Number]] +I16Vec4 = glm.i16vec4 +I16VectorAny = Union[glm.i16vec1, glm.i16vec2, glm.i16vec3, glm.i16vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +I16VecAny = Union[glm.i16vec1, glm.i16vec2, glm.i16vec3, glm.i16vec4] +I32Vector1 = Union[glm.ivec1, Tuple[Number]] +I32Vec1 = glm.ivec1 +I32Vector2 = Union[glm.imvec2, glm.ivec2, Tuple[Number, Number]] +I32Vec2 = Union[glm.imvec2, glm.ivec2] +I32Vector3 = Union[glm.imvec3, glm.ivec3, Tuple[Number, Number, Number]] +I32Vec3 = Union[glm.imvec3, glm.ivec3] +I32Vector4 = Union[glm.imvec4, glm.ivec4, Tuple[Number, Number, Number, Number]] +I32Vec4 = Union[glm.imvec4, glm.ivec4] +I32VectorAny = Union[glm.imvec2, glm.imvec3, glm.imvec4, glm.ivec1, glm.ivec2, glm.ivec3, glm.ivec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +I32VecAny = Union[glm.imvec2, glm.imvec3, glm.imvec4, glm.ivec1, glm.ivec2, glm.ivec3, glm.ivec4] +I64Vector1 = Union[glm.i64vec1, Tuple[Number]] +I64Vec1 = glm.i64vec1 +I64Vector2 = Union[glm.i64vec2, Tuple[Number, Number]] +I64Vec2 = glm.i64vec2 +I64Vector3 = Union[glm.i64vec3, Tuple[Number, Number, Number]] +I64Vec3 = glm.i64vec3 +I64Vector4 = Union[glm.i64vec4, Tuple[Number, Number, Number, Number]] +I64Vec4 = glm.i64vec4 +I64VectorAny = Union[glm.i64vec1, glm.i64vec2, glm.i64vec3, glm.i64vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +I64VecAny = Union[glm.i64vec1, glm.i64vec2, glm.i64vec3, glm.i64vec4] +IAnyVector1 = Union[glm.i16vec1, glm.i64vec1, glm.i8vec1, glm.ivec1, Tuple[Number]] +IAnyVec1 = Union[glm.i16vec1, glm.i64vec1, glm.i8vec1, glm.ivec1] +IAnyVector2 = Union[glm.i16vec2, glm.i64vec2, glm.i8vec2, glm.imvec2, glm.ivec2, Tuple[Number, Number]] +IAnyVec2 = Union[glm.i16vec2, glm.i64vec2, glm.i8vec2, glm.imvec2, glm.ivec2] +IAnyVector3 = Union[glm.i16vec3, glm.i64vec3, glm.i8vec3, glm.imvec3, glm.ivec3, Tuple[Number, Number, Number]] +IAnyVec3 = Union[glm.i16vec3, glm.i64vec3, glm.i8vec3, glm.imvec3, glm.ivec3] +IAnyVector4 = Union[glm.i16vec4, glm.i64vec4, glm.i8vec4, glm.imvec4, glm.ivec4, Tuple[Number, Number, Number, Number]] +IAnyVec4 = Union[glm.i16vec4, glm.i64vec4, glm.i8vec4, glm.imvec4, glm.ivec4] +IAnyVectorAny = Union[glm.i16vec1, glm.i16vec2, glm.i16vec3, glm.i16vec4, glm.i64vec1, glm.i64vec2, glm.i64vec3, glm.i64vec4, glm.i8vec1, glm.i8vec2, glm.i8vec3, glm.i8vec4, glm.imvec2, glm.imvec3, glm.imvec4, glm.ivec1, glm.ivec2, glm.ivec3, glm.ivec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +IAnyVecAny = Union[glm.i16vec1, glm.i16vec2, glm.i16vec3, glm.i16vec4, glm.i64vec1, glm.i64vec2, glm.i64vec3, glm.i64vec4, glm.i8vec1, glm.i8vec2, glm.i8vec3, glm.i8vec4, glm.imvec2, glm.imvec3, glm.imvec4, glm.ivec1, glm.ivec2, glm.ivec3, glm.ivec4] +U8Vector1 = Union[glm.u8vec1, Tuple[Number]] +U8Vec1 = glm.u8vec1 +U8Vector2 = Union[glm.u8vec2, Tuple[Number, Number]] +U8Vec2 = glm.u8vec2 +U8Vector3 = Union[glm.u8vec3, Tuple[Number, Number, Number]] +U8Vec3 = glm.u8vec3 +U8Vector4 = Union[glm.u8vec4, Tuple[Number, Number, Number, Number]] +U8Vec4 = glm.u8vec4 +U8VectorAny = Union[glm.u8vec1, glm.u8vec2, glm.u8vec3, glm.u8vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +U8VecAny = Union[glm.u8vec1, glm.u8vec2, glm.u8vec3, glm.u8vec4] +U16Vector1 = Union[glm.u16vec1, Tuple[Number]] +U16Vec1 = glm.u16vec1 +U16Vector2 = Union[glm.u16vec2, Tuple[Number, Number]] +U16Vec2 = glm.u16vec2 +U16Vector3 = Union[glm.u16vec3, Tuple[Number, Number, Number]] +U16Vec3 = glm.u16vec3 +U16Vector4 = Union[glm.u16vec4, Tuple[Number, Number, Number, Number]] +U16Vec4 = glm.u16vec4 +U16VectorAny = Union[glm.u16vec1, glm.u16vec2, glm.u16vec3, glm.u16vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +U16VecAny = Union[glm.u16vec1, glm.u16vec2, glm.u16vec3, glm.u16vec4] +U32Vector1 = Union[glm.uvec1, Tuple[Number]] +U32Vec1 = glm.uvec1 +U32Vector2 = Union[glm.umvec2, glm.uvec2, Tuple[Number, Number]] +U32Vec2 = Union[glm.umvec2, glm.uvec2] +U32Vector3 = Union[glm.umvec3, glm.uvec3, Tuple[Number, Number, Number]] +U32Vec3 = Union[glm.umvec3, glm.uvec3] +U32Vector4 = Union[glm.umvec4, glm.uvec4, Tuple[Number, Number, Number, Number]] +U32Vec4 = Union[glm.umvec4, glm.uvec4] +U32VectorAny = Union[glm.umvec2, glm.umvec3, glm.umvec4, glm.uvec1, glm.uvec2, glm.uvec3, glm.uvec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +U32VecAny = Union[glm.umvec2, glm.umvec3, glm.umvec4, glm.uvec1, glm.uvec2, glm.uvec3, glm.uvec4] +U64Vector1 = Union[glm.u64vec1, Tuple[Number]] +U64Vec1 = glm.u64vec1 +U64Vector2 = Union[glm.u64vec2, Tuple[Number, Number]] +U64Vec2 = glm.u64vec2 +U64Vector3 = Union[glm.u64vec3, Tuple[Number, Number, Number]] +U64Vec3 = glm.u64vec3 +U64Vector4 = Union[glm.u64vec4, Tuple[Number, Number, Number, Number]] +U64Vec4 = glm.u64vec4 +U64VectorAny = Union[glm.u64vec1, glm.u64vec2, glm.u64vec3, glm.u64vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +U64VecAny = Union[glm.u64vec1, glm.u64vec2, glm.u64vec3, glm.u64vec4] +UAnyVector1 = Union[glm.u16vec1, glm.u64vec1, glm.u8vec1, glm.uvec1, Tuple[Number]] +UAnyVec1 = Union[glm.u16vec1, glm.u64vec1, glm.u8vec1, glm.uvec1] +UAnyVector2 = Union[glm.u16vec2, glm.u64vec2, glm.u8vec2, glm.umvec2, glm.uvec2, Tuple[Number, Number]] +UAnyVec2 = Union[glm.u16vec2, glm.u64vec2, glm.u8vec2, glm.umvec2, glm.uvec2] +UAnyVector3 = Union[glm.u16vec3, glm.u64vec3, glm.u8vec3, glm.umvec3, glm.uvec3, Tuple[Number, Number, Number]] +UAnyVec3 = Union[glm.u16vec3, glm.u64vec3, glm.u8vec3, glm.umvec3, glm.uvec3] +UAnyVector4 = Union[glm.u16vec4, glm.u64vec4, glm.u8vec4, glm.umvec4, glm.uvec4, Tuple[Number, Number, Number, Number]] +UAnyVec4 = Union[glm.u16vec4, glm.u64vec4, glm.u8vec4, glm.umvec4, glm.uvec4] +UAnyVectorAny = Union[glm.u16vec1, glm.u16vec2, glm.u16vec3, glm.u16vec4, glm.u64vec1, glm.u64vec2, glm.u64vec3, glm.u64vec4, glm.u8vec1, glm.u8vec2, glm.u8vec3, glm.u8vec4, glm.umvec2, glm.umvec3, glm.umvec4, glm.uvec1, glm.uvec2, glm.uvec3, glm.uvec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +UAnyVecAny = Union[glm.u16vec1, glm.u16vec2, glm.u16vec3, glm.u16vec4, glm.u64vec1, glm.u64vec2, glm.u64vec3, glm.u64vec4, glm.u8vec1, glm.u8vec2, glm.u8vec3, glm.u8vec4, glm.umvec2, glm.umvec3, glm.umvec4, glm.uvec1, glm.uvec2, glm.uvec3, glm.uvec4] +Any8Vector1 = Union[glm.bvec1, glm.i8vec1, glm.u8vec1, Tuple[Number]] +Any8Vec1 = Union[glm.bvec1, glm.i8vec1, glm.u8vec1] +Any8Vector2 = Union[glm.bvec2, glm.i8vec2, glm.u8vec2, Tuple[Number, Number]] +Any8Vec2 = Union[glm.bvec2, glm.i8vec2, glm.u8vec2] +Any8Vector3 = Union[glm.bvec3, glm.i8vec3, glm.u8vec3, Tuple[Number, Number, Number]] +Any8Vec3 = Union[glm.bvec3, glm.i8vec3, glm.u8vec3] +Any8Vector4 = Union[glm.bvec4, glm.i8vec4, glm.u8vec4, Tuple[Number, Number, Number, Number]] +Any8Vec4 = Union[glm.bvec4, glm.i8vec4, glm.u8vec4] +Any8VectorAny = Union[glm.bvec1, glm.bvec2, glm.bvec3, glm.bvec4, glm.i8vec1, glm.i8vec2, glm.i8vec3, glm.i8vec4, glm.u8vec1, glm.u8vec2, glm.u8vec3, glm.u8vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +Any8VecAny = Union[glm.bvec1, glm.bvec2, glm.bvec3, glm.bvec4, glm.i8vec1, glm.i8vec2, glm.i8vec3, glm.i8vec4, glm.u8vec1, glm.u8vec2, glm.u8vec3, glm.u8vec4] +Any16Vector1 = Union[glm.i16vec1, glm.u16vec1, Tuple[Number]] +Any16Vec1 = Union[glm.i16vec1, glm.u16vec1] +Any16Vector2 = Union[glm.i16vec2, glm.u16vec2, Tuple[Number, Number]] +Any16Vec2 = Union[glm.i16vec2, glm.u16vec2] +Any16Vector3 = Union[glm.i16vec3, glm.u16vec3, Tuple[Number, Number, Number]] +Any16Vec3 = Union[glm.i16vec3, glm.u16vec3] +Any16Vector4 = Union[glm.i16vec4, glm.u16vec4, Tuple[Number, Number, Number, Number]] +Any16Vec4 = Union[glm.i16vec4, glm.u16vec4] +Any16VectorAny = Union[glm.i16vec1, glm.i16vec2, glm.i16vec3, glm.i16vec4, glm.u16vec1, glm.u16vec2, glm.u16vec3, glm.u16vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +Any16VecAny = Union[glm.i16vec1, glm.i16vec2, glm.i16vec3, glm.i16vec4, glm.u16vec1, glm.u16vec2, glm.u16vec3, glm.u16vec4] +Any32Vector1 = Union[glm.ivec1, glm.uvec1, glm.vec1, Tuple[Number]] +Any32Vec1 = Union[glm.ivec1, glm.uvec1, glm.vec1] +Any32Vector2 = Union[glm.imvec2, glm.ivec2, glm.mvec2, glm.umvec2, glm.uvec2, glm.vec2, Tuple[Number, Number]] +Any32Vec2 = Union[glm.imvec2, glm.ivec2, glm.mvec2, glm.umvec2, glm.uvec2, glm.vec2] +Any32Vector3 = Union[glm.imvec3, glm.ivec3, glm.mvec3, glm.umvec3, glm.uvec3, glm.vec3, Tuple[Number, Number, Number]] +Any32Vec3 = Union[glm.imvec3, glm.ivec3, glm.mvec3, glm.umvec3, glm.uvec3, glm.vec3] +Any32Vector4 = Union[glm.imvec4, glm.ivec4, glm.mvec4, glm.umvec4, glm.uvec4, glm.vec4, Tuple[Number, Number, Number, Number]] +Any32Vec4 = Union[glm.imvec4, glm.ivec4, glm.mvec4, glm.umvec4, glm.uvec4, glm.vec4] +Any32VectorAny = Union[glm.imvec2, glm.imvec3, glm.imvec4, glm.ivec1, glm.ivec2, glm.ivec3, glm.ivec4, glm.mvec2, glm.mvec3, glm.mvec4, glm.umvec2, glm.umvec3, glm.umvec4, glm.uvec1, glm.uvec2, glm.uvec3, glm.uvec4, glm.vec1, glm.vec2, glm.vec3, glm.vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +Any32VecAny = Union[glm.imvec2, glm.imvec3, glm.imvec4, glm.ivec1, glm.ivec2, glm.ivec3, glm.ivec4, glm.mvec2, glm.mvec3, glm.mvec4, glm.umvec2, glm.umvec3, glm.umvec4, glm.uvec1, glm.uvec2, glm.uvec3, glm.uvec4, glm.vec1, glm.vec2, glm.vec3, glm.vec4] +Any64Vector1 = Union[glm.dvec1, glm.i64vec1, glm.u64vec1, Tuple[Number]] +Any64Vec1 = Union[glm.dvec1, glm.i64vec1, glm.u64vec1] +Any64Vector2 = Union[glm.dmvec2, glm.dvec2, glm.i64vec2, glm.u64vec2, Tuple[Number, Number]] +Any64Vec2 = Union[glm.dmvec2, glm.dvec2, glm.i64vec2, glm.u64vec2] +Any64Vector3 = Union[glm.dmvec3, glm.dvec3, glm.i64vec3, glm.u64vec3, Tuple[Number, Number, Number]] +Any64Vec3 = Union[glm.dmvec3, glm.dvec3, glm.i64vec3, glm.u64vec3] +Any64Vector4 = Union[glm.dmvec4, glm.dvec4, glm.i64vec4, glm.u64vec4, Tuple[Number, Number, Number, Number]] +Any64Vec4 = Union[glm.dmvec4, glm.dvec4, glm.i64vec4, glm.u64vec4] +Any64VectorAny = Union[glm.dmvec2, glm.dmvec3, glm.dmvec4, glm.dvec1, glm.dvec2, glm.dvec3, glm.dvec4, glm.i64vec1, glm.i64vec2, glm.i64vec3, glm.i64vec4, glm.u64vec1, glm.u64vec2, glm.u64vec3, glm.u64vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +Any64VecAny = Union[glm.dmvec2, glm.dmvec3, glm.dmvec4, glm.dvec1, glm.dvec2, glm.dvec3, glm.dvec4, glm.i64vec1, glm.i64vec2, glm.i64vec3, glm.i64vec4, glm.u64vec1, glm.u64vec2, glm.u64vec3, glm.u64vec4] +AnyAnyVector1 = Union[glm.bvec1, glm.dvec1, glm.i16vec1, glm.i64vec1, glm.i8vec1, glm.ivec1, glm.u16vec1, glm.u64vec1, glm.u8vec1, glm.uvec1, glm.vec1, Tuple[Number]] +AnyAnyVec1 = Union[glm.bvec1, glm.dvec1, glm.i16vec1, glm.i64vec1, glm.i8vec1, glm.ivec1, glm.u16vec1, glm.u64vec1, glm.u8vec1, glm.uvec1, glm.vec1] +AnyAnyVector2 = Union[glm.bvec2, glm.dmvec2, glm.dvec2, glm.i16vec2, glm.i64vec2, glm.i8vec2, glm.imvec2, glm.ivec2, glm.mvec2, glm.u16vec2, glm.u64vec2, glm.u8vec2, glm.umvec2, glm.uvec2, glm.vec2, Tuple[Number, Number]] +AnyAnyVec2 = Union[glm.bvec2, glm.dmvec2, glm.dvec2, glm.i16vec2, glm.i64vec2, glm.i8vec2, glm.imvec2, glm.ivec2, glm.mvec2, glm.u16vec2, glm.u64vec2, glm.u8vec2, glm.umvec2, glm.uvec2, glm.vec2] +AnyAnyVector3 = Union[glm.bvec3, glm.dmvec3, glm.dvec3, glm.i16vec3, glm.i64vec3, glm.i8vec3, glm.imvec3, glm.ivec3, glm.mvec3, glm.u16vec3, glm.u64vec3, glm.u8vec3, glm.umvec3, glm.uvec3, glm.vec3, Tuple[Number, Number, Number]] +AnyAnyVec3 = Union[glm.bvec3, glm.dmvec3, glm.dvec3, glm.i16vec3, glm.i64vec3, glm.i8vec3, glm.imvec3, glm.ivec3, glm.mvec3, glm.u16vec3, glm.u64vec3, glm.u8vec3, glm.umvec3, glm.uvec3, glm.vec3] +AnyAnyVector4 = Union[glm.bvec4, glm.dmvec4, glm.dvec4, glm.i16vec4, glm.i64vec4, glm.i8vec4, glm.imvec4, glm.ivec4, glm.mvec4, glm.u16vec4, glm.u64vec4, glm.u8vec4, glm.umvec4, glm.uvec4, glm.vec4, Tuple[Number, Number, Number, Number]] +AnyAnyVec4 = Union[glm.bvec4, glm.dmvec4, glm.dvec4, glm.i16vec4, glm.i64vec4, glm.i8vec4, glm.imvec4, glm.ivec4, glm.mvec4, glm.u16vec4, glm.u64vec4, glm.u8vec4, glm.umvec4, glm.uvec4, glm.vec4] +AnyAnyVectorAny = Union[glm.bvec1, glm.bvec2, glm.bvec3, glm.bvec4, glm.dmvec2, glm.dmvec3, glm.dmvec4, glm.dvec1, glm.dvec2, glm.dvec3, glm.dvec4, glm.i16vec1, glm.i16vec2, glm.i16vec3, glm.i16vec4, glm.i64vec1, glm.i64vec2, glm.i64vec3, glm.i64vec4, glm.i8vec1, glm.i8vec2, glm.i8vec3, glm.i8vec4, glm.imvec2, glm.imvec3, glm.imvec4, glm.ivec1, glm.ivec2, glm.ivec3, glm.ivec4, glm.mvec2, glm.mvec3, glm.mvec4, glm.u16vec1, glm.u16vec2, glm.u16vec3, glm.u16vec4, glm.u64vec1, glm.u64vec2, glm.u64vec3, glm.u64vec4, glm.u8vec1, glm.u8vec2, glm.u8vec3, glm.u8vec4, glm.umvec2, glm.umvec3, glm.umvec4, glm.uvec1, glm.uvec2, glm.uvec3, glm.uvec4, glm.vec1, glm.vec2, glm.vec3, glm.vec4, Tuple[Number], Tuple[Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number, Number]] +AnyAnyVecAny = Union[glm.bvec1, glm.bvec2, glm.bvec3, glm.bvec4, glm.dmvec2, glm.dmvec3, glm.dmvec4, glm.dvec1, glm.dvec2, glm.dvec3, glm.dvec4, glm.i16vec1, glm.i16vec2, glm.i16vec3, glm.i16vec4, glm.i64vec1, glm.i64vec2, glm.i64vec3, glm.i64vec4, glm.i8vec1, glm.i8vec2, glm.i8vec3, glm.i8vec4, glm.imvec2, glm.imvec3, glm.imvec4, glm.ivec1, glm.ivec2, glm.ivec3, glm.ivec4, glm.mvec2, glm.mvec3, glm.mvec4, glm.u16vec1, glm.u16vec2, glm.u16vec3, glm.u16vec4, glm.u64vec1, glm.u64vec2, glm.u64vec3, glm.u64vec4, glm.u8vec1, glm.u8vec2, glm.u8vec3, glm.u8vec4, glm.umvec2, glm.umvec3, glm.umvec4, glm.uvec1, glm.uvec2, glm.uvec3, glm.uvec4, glm.vec1, glm.vec2, glm.vec3, glm.vec4] +FDAnyVectorAny = Union[FAnyVectorAny, DAnyVectorAny] +FDAnyVector1 = Union[FAnyVector1, DAnyVector1] +FDAnyVector2 = Union[FAnyVector2, DAnyVector2] +FDAnyVector3 = Union[FAnyVector3, DAnyVector3] +FDAnyVector4 = Union[FAnyVector4, DAnyVector4] +IUAnyVector1 = Union[IAnyVector1, UAnyVector1] +IUAnyVector2 = Union[IAnyVector2, UAnyVector2] +IUAnyVector3 = Union[IAnyVector3, UAnyVector3] +IUAnyVector4 = Union[IAnyVector4, UAnyVector4] +D64Matrix2x2 = Union[glm.dmat2x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]]] +D64Mat2x2 = glm.dmat2x2 +D64Matrix2x3 = Union[glm.dmat2x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +D64Mat2x3 = glm.dmat2x3 +D64Matrix2x4 = Union[glm.dmat2x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +D64Mat2x4 = glm.dmat2x4 +D64Matrix2xAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +D64Mat2xAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4] +D64Matrix3x2 = Union[glm.dmat3x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +D64Mat3x2 = glm.dmat3x2 +D64Matrix3x3 = Union[glm.dmat3x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +D64Mat3x3 = glm.dmat3x3 +D64Matrix3x4 = Union[glm.dmat3x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +D64Mat3x4 = glm.dmat3x4 +D64Matrix3xAny = Union[glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +D64Mat3xAny = Union[glm.dmat3x2, glm.dmat3x3, glm.dmat3x4] +D64Matrix4x2 = Union[glm.dmat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +D64Mat4x2 = glm.dmat4x2 +D64Matrix4x3 = Union[glm.dmat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +D64Mat4x3 = glm.dmat4x3 +D64Matrix4x4 = Union[glm.dmat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +D64Mat4x4 = glm.dmat4x4 +D64Matrix4xAny = Union[glm.dmat4x2, glm.dmat4x3, glm.dmat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +D64Mat4xAny = Union[glm.dmat4x2, glm.dmat4x3, glm.dmat4x4] +D64MatrixAnyx2 = Union[glm.dmat2x2, glm.dmat3x2, glm.dmat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +D64MatAnyx2 = Union[glm.dmat2x2, glm.dmat3x2, glm.dmat4x2] +D64MatrixAnyx3 = Union[glm.dmat2x3, glm.dmat3x3, glm.dmat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +D64MatAnyx3 = Union[glm.dmat2x3, glm.dmat3x3, glm.dmat4x3] +D64MatrixAnyx4 = Union[glm.dmat2x4, glm.dmat3x4, glm.dmat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +D64MatAnyx4 = Union[glm.dmat2x4, glm.dmat3x4, glm.dmat4x4] +D64MatrixAnyxAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, glm.dmat4x2, glm.dmat4x3, glm.dmat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +D64MatAnyxAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, glm.dmat4x2, glm.dmat4x3, glm.dmat4x4] +DAnyMatrix2x2 = Union[glm.dmat2x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]]] +DAnyMat2x2 = glm.dmat2x2 +DAnyMatrix2x3 = Union[glm.dmat2x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +DAnyMat2x3 = glm.dmat2x3 +DAnyMatrix2x4 = Union[glm.dmat2x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +DAnyMat2x4 = glm.dmat2x4 +DAnyMatrix2xAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +DAnyMat2xAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4] +DAnyMatrix3x2 = Union[glm.dmat3x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +DAnyMat3x2 = glm.dmat3x2 +DAnyMatrix3x3 = Union[glm.dmat3x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +DAnyMat3x3 = glm.dmat3x3 +DAnyMatrix3x4 = Union[glm.dmat3x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +DAnyMat3x4 = glm.dmat3x4 +DAnyMatrix3xAny = Union[glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +DAnyMat3xAny = Union[glm.dmat3x2, glm.dmat3x3, glm.dmat3x4] +DAnyMatrix4x2 = Union[glm.dmat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +DAnyMat4x2 = glm.dmat4x2 +DAnyMatrix4x3 = Union[glm.dmat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +DAnyMat4x3 = glm.dmat4x3 +DAnyMatrix4x4 = Union[glm.dmat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +DAnyMat4x4 = glm.dmat4x4 +DAnyMatrix4xAny = Union[glm.dmat4x2, glm.dmat4x3, glm.dmat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +DAnyMat4xAny = Union[glm.dmat4x2, glm.dmat4x3, glm.dmat4x4] +DAnyMatrixAnyx2 = Union[glm.dmat2x2, glm.dmat3x2, glm.dmat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +DAnyMatAnyx2 = Union[glm.dmat2x2, glm.dmat3x2, glm.dmat4x2] +DAnyMatrixAnyx3 = Union[glm.dmat2x3, glm.dmat3x3, glm.dmat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +DAnyMatAnyx3 = Union[glm.dmat2x3, glm.dmat3x3, glm.dmat4x3] +DAnyMatrixAnyx4 = Union[glm.dmat2x4, glm.dmat3x4, glm.dmat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +DAnyMatAnyx4 = Union[glm.dmat2x4, glm.dmat3x4, glm.dmat4x4] +DAnyMatrixAnyxAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, glm.dmat4x2, glm.dmat4x3, glm.dmat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +DAnyMatAnyxAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, glm.dmat4x2, glm.dmat4x3, glm.dmat4x4] +F32Matrix2x2 = Union[glm.mat2x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]]] +F32Mat2x2 = glm.mat2x2 +F32Matrix2x3 = Union[glm.mat2x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +F32Mat2x3 = glm.mat2x3 +F32Matrix2x4 = Union[glm.mat2x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +F32Mat2x4 = glm.mat2x4 +F32Matrix2xAny = Union[glm.mat2x2, glm.mat2x3, glm.mat2x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +F32Mat2xAny = Union[glm.mat2x2, glm.mat2x3, glm.mat2x4] +F32Matrix3x2 = Union[glm.mat3x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +F32Mat3x2 = glm.mat3x2 +F32Matrix3x3 = Union[glm.mat3x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +F32Mat3x3 = glm.mat3x3 +F32Matrix3x4 = Union[glm.mat3x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +F32Mat3x4 = glm.mat3x4 +F32Matrix3xAny = Union[glm.mat3x2, glm.mat3x3, glm.mat3x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +F32Mat3xAny = Union[glm.mat3x2, glm.mat3x3, glm.mat3x4] +F32Matrix4x2 = Union[glm.mat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +F32Mat4x2 = glm.mat4x2 +F32Matrix4x3 = Union[glm.mat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +F32Mat4x3 = glm.mat4x3 +F32Matrix4x4 = Union[glm.mat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +F32Mat4x4 = glm.mat4x4 +F32Matrix4xAny = Union[glm.mat4x2, glm.mat4x3, glm.mat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +F32Mat4xAny = Union[glm.mat4x2, glm.mat4x3, glm.mat4x4] +F32MatrixAnyx2 = Union[glm.mat2x2, glm.mat3x2, glm.mat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +F32MatAnyx2 = Union[glm.mat2x2, glm.mat3x2, glm.mat4x2] +F32MatrixAnyx3 = Union[glm.mat2x3, glm.mat3x3, glm.mat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +F32MatAnyx3 = Union[glm.mat2x3, glm.mat3x3, glm.mat4x3] +F32MatrixAnyx4 = Union[glm.mat2x4, glm.mat3x4, glm.mat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +F32MatAnyx4 = Union[glm.mat2x4, glm.mat3x4, glm.mat4x4] +F32MatrixAnyxAny = Union[glm.mat2x2, glm.mat2x3, glm.mat2x4, glm.mat3x2, glm.mat3x3, glm.mat3x4, glm.mat4x2, glm.mat4x3, glm.mat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +F32MatAnyxAny = Union[glm.mat2x2, glm.mat2x3, glm.mat2x4, glm.mat3x2, glm.mat3x3, glm.mat3x4, glm.mat4x2, glm.mat4x3, glm.mat4x4] +FAnyMatrix2x2 = Union[glm.mat2x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]]] +FAnyMat2x2 = glm.mat2x2 +FAnyMatrix2x3 = Union[glm.mat2x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +FAnyMat2x3 = glm.mat2x3 +FAnyMatrix2x4 = Union[glm.mat2x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +FAnyMat2x4 = glm.mat2x4 +FAnyMatrix2xAny = Union[glm.mat2x2, glm.mat2x3, glm.mat2x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +FAnyMat2xAny = Union[glm.mat2x2, glm.mat2x3, glm.mat2x4] +FAnyMatrix3x2 = Union[glm.mat3x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +FAnyMat3x2 = glm.mat3x2 +FAnyMatrix3x3 = Union[glm.mat3x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +FAnyMat3x3 = glm.mat3x3 +FAnyMatrix3x4 = Union[glm.mat3x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +FAnyMat3x4 = glm.mat3x4 +FAnyMatrix3xAny = Union[glm.mat3x2, glm.mat3x3, glm.mat3x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +FAnyMat3xAny = Union[glm.mat3x2, glm.mat3x3, glm.mat3x4] +FAnyMatrix4x2 = Union[glm.mat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +FAnyMat4x2 = glm.mat4x2 +FAnyMatrix4x3 = Union[glm.mat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +FAnyMat4x3 = glm.mat4x3 +FAnyMatrix4x4 = Union[glm.mat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +FAnyMat4x4 = glm.mat4x4 +FAnyMatrix4xAny = Union[glm.mat4x2, glm.mat4x3, glm.mat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +FAnyMat4xAny = Union[glm.mat4x2, glm.mat4x3, glm.mat4x4] +FAnyMatrixAnyx2 = Union[glm.mat2x2, glm.mat3x2, glm.mat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +FAnyMatAnyx2 = Union[glm.mat2x2, glm.mat3x2, glm.mat4x2] +FAnyMatrixAnyx3 = Union[glm.mat2x3, glm.mat3x3, glm.mat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +FAnyMatAnyx3 = Union[glm.mat2x3, glm.mat3x3, glm.mat4x3] +FAnyMatrixAnyx4 = Union[glm.mat2x4, glm.mat3x4, glm.mat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +FAnyMatAnyx4 = Union[glm.mat2x4, glm.mat3x4, glm.mat4x4] +FAnyMatrixAnyxAny = Union[glm.mat2x2, glm.mat2x3, glm.mat2x4, glm.mat3x2, glm.mat3x3, glm.mat3x4, glm.mat4x2, glm.mat4x3, glm.mat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +FAnyMatAnyxAny = Union[glm.mat2x2, glm.mat2x3, glm.mat2x4, glm.mat3x2, glm.mat3x3, glm.mat3x4, glm.mat4x2, glm.mat4x3, glm.mat4x4] +I32Matrix2x2 = Union[glm.imat2x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]]] +I32Mat2x2 = glm.imat2x2 +I32Matrix2x3 = Union[glm.imat2x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +I32Mat2x3 = glm.imat2x3 +I32Matrix2x4 = Union[glm.imat2x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +I32Mat2x4 = glm.imat2x4 +I32Matrix2xAny = Union[glm.imat2x2, glm.imat2x3, glm.imat2x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +I32Mat2xAny = Union[glm.imat2x2, glm.imat2x3, glm.imat2x4] +I32Matrix3x2 = Union[glm.imat3x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +I32Mat3x2 = glm.imat3x2 +I32Matrix3x3 = Union[glm.imat3x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +I32Mat3x3 = glm.imat3x3 +I32Matrix3x4 = Union[glm.imat3x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +I32Mat3x4 = glm.imat3x4 +I32Matrix3xAny = Union[glm.imat3x2, glm.imat3x3, glm.imat3x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +I32Mat3xAny = Union[glm.imat3x2, glm.imat3x3, glm.imat3x4] +I32Matrix4x2 = Union[glm.imat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +I32Mat4x2 = glm.imat4x2 +I32Matrix4x3 = Union[glm.imat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +I32Mat4x3 = glm.imat4x3 +I32Matrix4x4 = Union[glm.imat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +I32Mat4x4 = glm.imat4x4 +I32Matrix4xAny = Union[glm.imat4x2, glm.imat4x3, glm.imat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +I32Mat4xAny = Union[glm.imat4x2, glm.imat4x3, glm.imat4x4] +I32MatrixAnyx2 = Union[glm.imat2x2, glm.imat3x2, glm.imat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +I32MatAnyx2 = Union[glm.imat2x2, glm.imat3x2, glm.imat4x2] +I32MatrixAnyx3 = Union[glm.imat2x3, glm.imat3x3, glm.imat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +I32MatAnyx3 = Union[glm.imat2x3, glm.imat3x3, glm.imat4x3] +I32MatrixAnyx4 = Union[glm.imat2x4, glm.imat3x4, glm.imat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +I32MatAnyx4 = Union[glm.imat2x4, glm.imat3x4, glm.imat4x4] +I32MatrixAnyxAny = Union[glm.imat2x2, glm.imat2x3, glm.imat2x4, glm.imat3x2, glm.imat3x3, glm.imat3x4, glm.imat4x2, glm.imat4x3, glm.imat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +I32MatAnyxAny = Union[glm.imat2x2, glm.imat2x3, glm.imat2x4, glm.imat3x2, glm.imat3x3, glm.imat3x4, glm.imat4x2, glm.imat4x3, glm.imat4x4] +IAnyMatrix2x2 = Union[glm.imat2x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]]] +IAnyMat2x2 = glm.imat2x2 +IAnyMatrix2x3 = Union[glm.imat2x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +IAnyMat2x3 = glm.imat2x3 +IAnyMatrix2x4 = Union[glm.imat2x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +IAnyMat2x4 = glm.imat2x4 +IAnyMatrix2xAny = Union[glm.imat2x2, glm.imat2x3, glm.imat2x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +IAnyMat2xAny = Union[glm.imat2x2, glm.imat2x3, glm.imat2x4] +IAnyMatrix3x2 = Union[glm.imat3x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +IAnyMat3x2 = glm.imat3x2 +IAnyMatrix3x3 = Union[glm.imat3x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +IAnyMat3x3 = glm.imat3x3 +IAnyMatrix3x4 = Union[glm.imat3x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +IAnyMat3x4 = glm.imat3x4 +IAnyMatrix3xAny = Union[glm.imat3x2, glm.imat3x3, glm.imat3x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +IAnyMat3xAny = Union[glm.imat3x2, glm.imat3x3, glm.imat3x4] +IAnyMatrix4x2 = Union[glm.imat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +IAnyMat4x2 = glm.imat4x2 +IAnyMatrix4x3 = Union[glm.imat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +IAnyMat4x3 = glm.imat4x3 +IAnyMatrix4x4 = Union[glm.imat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +IAnyMat4x4 = glm.imat4x4 +IAnyMatrix4xAny = Union[glm.imat4x2, glm.imat4x3, glm.imat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +IAnyMat4xAny = Union[glm.imat4x2, glm.imat4x3, glm.imat4x4] +IAnyMatrixAnyx2 = Union[glm.imat2x2, glm.imat3x2, glm.imat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +IAnyMatAnyx2 = Union[glm.imat2x2, glm.imat3x2, glm.imat4x2] +IAnyMatrixAnyx3 = Union[glm.imat2x3, glm.imat3x3, glm.imat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +IAnyMatAnyx3 = Union[glm.imat2x3, glm.imat3x3, glm.imat4x3] +IAnyMatrixAnyx4 = Union[glm.imat2x4, glm.imat3x4, glm.imat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +IAnyMatAnyx4 = Union[glm.imat2x4, glm.imat3x4, glm.imat4x4] +IAnyMatrixAnyxAny = Union[glm.imat2x2, glm.imat2x3, glm.imat2x4, glm.imat3x2, glm.imat3x3, glm.imat3x4, glm.imat4x2, glm.imat4x3, glm.imat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +IAnyMatAnyxAny = Union[glm.imat2x2, glm.imat2x3, glm.imat2x4, glm.imat3x2, glm.imat3x3, glm.imat3x4, glm.imat4x2, glm.imat4x3, glm.imat4x4] +U32Matrix2x2 = Union[glm.umat2x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]]] +U32Mat2x2 = glm.umat2x2 +U32Matrix2x3 = Union[glm.umat2x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +U32Mat2x3 = glm.umat2x3 +U32Matrix2x4 = Union[glm.umat2x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +U32Mat2x4 = glm.umat2x4 +U32Matrix2xAny = Union[glm.umat2x2, glm.umat2x3, glm.umat2x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +U32Mat2xAny = Union[glm.umat2x2, glm.umat2x3, glm.umat2x4] +U32Matrix3x2 = Union[glm.umat3x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +U32Mat3x2 = glm.umat3x2 +U32Matrix3x3 = Union[glm.umat3x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +U32Mat3x3 = glm.umat3x3 +U32Matrix3x4 = Union[glm.umat3x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +U32Mat3x4 = glm.umat3x4 +U32Matrix3xAny = Union[glm.umat3x2, glm.umat3x3, glm.umat3x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +U32Mat3xAny = Union[glm.umat3x2, glm.umat3x3, glm.umat3x4] +U32Matrix4x2 = Union[glm.umat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +U32Mat4x2 = glm.umat4x2 +U32Matrix4x3 = Union[glm.umat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +U32Mat4x3 = glm.umat4x3 +U32Matrix4x4 = Union[glm.umat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +U32Mat4x4 = glm.umat4x4 +U32Matrix4xAny = Union[glm.umat4x2, glm.umat4x3, glm.umat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +U32Mat4xAny = Union[glm.umat4x2, glm.umat4x3, glm.umat4x4] +U32MatrixAnyx2 = Union[glm.umat2x2, glm.umat3x2, glm.umat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +U32MatAnyx2 = Union[glm.umat2x2, glm.umat3x2, glm.umat4x2] +U32MatrixAnyx3 = Union[glm.umat2x3, glm.umat3x3, glm.umat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +U32MatAnyx3 = Union[glm.umat2x3, glm.umat3x3, glm.umat4x3] +U32MatrixAnyx4 = Union[glm.umat2x4, glm.umat3x4, glm.umat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +U32MatAnyx4 = Union[glm.umat2x4, glm.umat3x4, glm.umat4x4] +U32MatrixAnyxAny = Union[glm.umat2x2, glm.umat2x3, glm.umat2x4, glm.umat3x2, glm.umat3x3, glm.umat3x4, glm.umat4x2, glm.umat4x3, glm.umat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +U32MatAnyxAny = Union[glm.umat2x2, glm.umat2x3, glm.umat2x4, glm.umat3x2, glm.umat3x3, glm.umat3x4, glm.umat4x2, glm.umat4x3, glm.umat4x4] +UAnyMatrix2x2 = Union[glm.umat2x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]]] +UAnyMat2x2 = glm.umat2x2 +UAnyMatrix2x3 = Union[glm.umat2x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +UAnyMat2x3 = glm.umat2x3 +UAnyMatrix2x4 = Union[glm.umat2x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +UAnyMat2x4 = glm.umat2x4 +UAnyMatrix2xAny = Union[glm.umat2x2, glm.umat2x3, glm.umat2x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +UAnyMat2xAny = Union[glm.umat2x2, glm.umat2x3, glm.umat2x4] +UAnyMatrix3x2 = Union[glm.umat3x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +UAnyMat3x2 = glm.umat3x2 +UAnyMatrix3x3 = Union[glm.umat3x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +UAnyMat3x3 = glm.umat3x3 +UAnyMatrix3x4 = Union[glm.umat3x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +UAnyMat3x4 = glm.umat3x4 +UAnyMatrix3xAny = Union[glm.umat3x2, glm.umat3x3, glm.umat3x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +UAnyMat3xAny = Union[glm.umat3x2, glm.umat3x3, glm.umat3x4] +UAnyMatrix4x2 = Union[glm.umat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +UAnyMat4x2 = glm.umat4x2 +UAnyMatrix4x3 = Union[glm.umat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +UAnyMat4x3 = glm.umat4x3 +UAnyMatrix4x4 = Union[glm.umat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +UAnyMat4x4 = glm.umat4x4 +UAnyMatrix4xAny = Union[glm.umat4x2, glm.umat4x3, glm.umat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +UAnyMat4xAny = Union[glm.umat4x2, glm.umat4x3, glm.umat4x4] +UAnyMatrixAnyx2 = Union[glm.umat2x2, glm.umat3x2, glm.umat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +UAnyMatAnyx2 = Union[glm.umat2x2, glm.umat3x2, glm.umat4x2] +UAnyMatrixAnyx3 = Union[glm.umat2x3, glm.umat3x3, glm.umat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +UAnyMatAnyx3 = Union[glm.umat2x3, glm.umat3x3, glm.umat4x3] +UAnyMatrixAnyx4 = Union[glm.umat2x4, glm.umat3x4, glm.umat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +UAnyMatAnyx4 = Union[glm.umat2x4, glm.umat3x4, glm.umat4x4] +UAnyMatrixAnyxAny = Union[glm.umat2x2, glm.umat2x3, glm.umat2x4, glm.umat3x2, glm.umat3x3, glm.umat3x4, glm.umat4x2, glm.umat4x3, glm.umat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +UAnyMatAnyxAny = Union[glm.umat2x2, glm.umat2x3, glm.umat2x4, glm.umat3x2, glm.umat3x3, glm.umat3x4, glm.umat4x2, glm.umat4x3, glm.umat4x4] +AnyAnyMatrix2x2 = Union[glm.dmat2x2, glm.imat2x2, glm.mat2x2, glm.umat2x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]]] +AnyAnyMat2x2 = Union[glm.dmat2x2, glm.imat2x2, glm.mat2x2, glm.umat2x2] +AnyAnyMatrix2x3 = Union[glm.dmat2x3, glm.imat2x3, glm.mat2x3, glm.umat2x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +AnyAnyMat2x3 = Union[glm.dmat2x3, glm.imat2x3, glm.mat2x3, glm.umat2x3] +AnyAnyMatrix2x4 = Union[glm.dmat2x4, glm.imat2x4, glm.mat2x4, glm.umat2x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +AnyAnyMat2x4 = Union[glm.dmat2x4, glm.imat2x4, glm.mat2x4, glm.umat2x4] +AnyAnyMatrix2xAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, glm.imat2x2, glm.imat2x3, glm.imat2x4, glm.mat2x2, glm.mat2x3, glm.mat2x4, glm.umat2x2, glm.umat2x3, glm.umat2x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +AnyAnyMat2xAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, glm.imat2x2, glm.imat2x3, glm.imat2x4, glm.mat2x2, glm.mat2x3, glm.mat2x4, glm.umat2x2, glm.umat2x3, glm.umat2x4] +AnyAnyMatrix3x2 = Union[glm.dmat3x2, glm.imat3x2, glm.mat3x2, glm.umat3x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +AnyAnyMat3x2 = Union[glm.dmat3x2, glm.imat3x2, glm.mat3x2, glm.umat3x2] +AnyAnyMatrix3x3 = Union[glm.dmat3x3, glm.imat3x3, glm.mat3x3, glm.umat3x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +AnyAnyMat3x3 = Union[glm.dmat3x3, glm.imat3x3, glm.mat3x3, glm.umat3x3] +AnyAnyMatrix3x4 = Union[glm.dmat3x4, glm.imat3x4, glm.mat3x4, glm.umat3x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +AnyAnyMat3x4 = Union[glm.dmat3x4, glm.imat3x4, glm.mat3x4, glm.umat3x4] +AnyAnyMatrix3xAny = Union[glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, glm.imat3x2, glm.imat3x3, glm.imat3x4, glm.mat3x2, glm.mat3x3, glm.mat3x4, glm.umat3x2, glm.umat3x3, glm.umat3x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +AnyAnyMat3xAny = Union[glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, glm.imat3x2, glm.imat3x3, glm.imat3x4, glm.mat3x2, glm.mat3x3, glm.mat3x4, glm.umat3x2, glm.umat3x3, glm.umat3x4] +AnyAnyMatrix4x2 = Union[glm.dmat4x2, glm.imat4x2, glm.mat4x2, glm.umat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +AnyAnyMat4x2 = Union[glm.dmat4x2, glm.imat4x2, glm.mat4x2, glm.umat4x2] +AnyAnyMatrix4x3 = Union[glm.dmat4x3, glm.imat4x3, glm.mat4x3, glm.umat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +AnyAnyMat4x3 = Union[glm.dmat4x3, glm.imat4x3, glm.mat4x3, glm.umat4x3] +AnyAnyMatrix4x4 = Union[glm.dmat4x4, glm.imat4x4, glm.mat4x4, glm.umat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +AnyAnyMat4x4 = Union[glm.dmat4x4, glm.imat4x4, glm.mat4x4, glm.umat4x4] +AnyAnyMatrix4xAny = Union[glm.dmat4x2, glm.dmat4x3, glm.dmat4x4, glm.imat4x2, glm.imat4x3, glm.imat4x4, glm.mat4x2, glm.mat4x3, glm.mat4x4, glm.umat4x2, glm.umat4x3, glm.umat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +AnyAnyMat4xAny = Union[glm.dmat4x2, glm.dmat4x3, glm.dmat4x4, glm.imat4x2, glm.imat4x3, glm.imat4x4, glm.mat4x2, glm.mat4x3, glm.mat4x4, glm.umat4x2, glm.umat4x3, glm.umat4x4] +AnyAnyMatrixAnyx2 = Union[glm.dmat2x2, glm.dmat3x2, glm.dmat4x2, glm.imat2x2, glm.imat3x2, glm.imat4x2, glm.mat2x2, glm.mat3x2, glm.mat4x2, glm.umat2x2, glm.umat3x2, glm.umat4x2, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]]] +AnyAnyMatAnyx2 = Union[glm.dmat2x2, glm.dmat3x2, glm.dmat4x2, glm.imat2x2, glm.imat3x2, glm.imat4x2, glm.mat2x2, glm.mat3x2, glm.mat4x2, glm.umat2x2, glm.umat3x2, glm.umat4x2] +AnyAnyMatrixAnyx3 = Union[glm.dmat2x3, glm.dmat3x3, glm.dmat4x3, glm.imat2x3, glm.imat3x3, glm.imat4x3, glm.mat2x3, glm.mat3x3, glm.mat4x3, glm.umat2x3, glm.umat3x3, glm.umat4x3, Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]]] +AnyAnyMatAnyx3 = Union[glm.dmat2x3, glm.dmat3x3, glm.dmat4x3, glm.imat2x3, glm.imat3x3, glm.imat4x3, glm.mat2x3, glm.mat3x3, glm.mat4x3, glm.umat2x3, glm.umat3x3, glm.umat4x3] +AnyAnyMatrixAnyx4 = Union[glm.dmat2x4, glm.dmat3x4, glm.dmat4x4, glm.imat2x4, glm.imat3x4, glm.imat4x4, glm.mat2x4, glm.mat3x4, glm.mat4x4, glm.umat2x4, glm.umat3x4, glm.umat4x4, Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +AnyAnyMatAnyx4 = Union[glm.dmat2x4, glm.dmat3x4, glm.dmat4x4, glm.imat2x4, glm.imat3x4, glm.imat4x4, glm.mat2x4, glm.mat3x4, glm.mat4x4, glm.umat2x4, glm.umat3x4, glm.umat4x4] +AnyAnyMatrixAnyxAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, glm.dmat4x2, glm.dmat4x3, glm.dmat4x4, glm.imat2x2, glm.imat2x3, glm.imat2x4, glm.imat3x2, glm.imat3x3, glm.imat3x4, glm.imat4x2, glm.imat4x3, glm.imat4x4, glm.mat2x2, glm.mat2x3, glm.mat2x4, glm.mat3x2, glm.mat3x3, glm.mat3x4, glm.mat4x2, glm.mat4x3, glm.mat4x4, glm.umat2x2, glm.umat2x3, glm.umat2x4, glm.umat3x2, glm.umat3x3, glm.umat3x4, glm.umat4x2, glm.umat4x3, glm.umat4x4, Tuple[Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]], Tuple[Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number], Tuple[Number, Number]], Tuple[Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number], Tuple[Number, Number, Number]], Tuple[Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number], Tuple[Number, Number, Number, Number]]] +AnyAnyMatAnyxAny = Union[glm.dmat2x2, glm.dmat2x3, glm.dmat2x4, glm.dmat3x2, glm.dmat3x3, glm.dmat3x4, glm.dmat4x2, glm.dmat4x3, glm.dmat4x4, glm.imat2x2, glm.imat2x3, glm.imat2x4, glm.imat3x2, glm.imat3x3, glm.imat3x4, glm.imat4x2, glm.imat4x3, glm.imat4x4, glm.mat2x2, glm.mat2x3, glm.mat2x4, glm.mat3x2, glm.mat3x3, glm.mat3x4, glm.mat4x2, glm.mat4x3, glm.mat4x4, glm.umat2x2, glm.umat2x3, glm.umat2x4, glm.umat3x2, glm.umat3x3, glm.umat3x4, glm.umat4x2, glm.umat4x3, glm.umat4x4] +AnyAnyMatrixSquare = Union[AnyAnyMatrix2x2, AnyAnyMatrix3x3, AnyAnyMatrix4x4] +D64Quaternion = Union[glm.dquat, Tuple[Number, Number, Number, Number]] +D64Quat = glm.dquat +DAnyQuaternion = Union[glm.dquat, Tuple[Number, Number, Number, Number]] +DAnyQuat = glm.dquat +F32Quaternion = Union[glm.quat, Tuple[Number, Number, Number, Number]] +F32Quat = glm.quat +FAnyQuaternion = Union[glm.quat, Tuple[Number, Number, Number, Number]] +FAnyQuat = glm.quat +AnyAnyQuaternion = Union[glm.dquat, glm.quat, Tuple[Number, Number, Number, Number]] +AnyAnyQuat = Union[glm.dquat, glm.quat] +FDAnyQuaternion = Union[FAnyQuaternion, DAnyQuaternion] +FDAnyQuaternionVector4 = Union[FDAnyVector4, FDAnyQuaternion] +__all__ = ['B8Vector1', 'B8Vec1', 'B8Vector2', 'B8Vec2', 'B8Vector3', 'B8Vec3', 'B8Vector4', 'B8Vec4', 'B8VectorAny', 'B8VecAny', 'BAnyVector1', 'BAnyVec1', 'BAnyVector2', 'BAnyVec2', 'BAnyVector3', 'BAnyVec3', 'BAnyVector4', 'BAnyVec4', 'BAnyVectorAny', 'BAnyVecAny', 'D64Vector1', 'D64Vec1', 'D64Vector2', 'D64Vec2', 'D64Vector3', 'D64Vec3', 'D64Vector4', 'D64Vec4', 'D64VectorAny', 'D64VecAny', 'DAnyVector1', 'DAnyVec1', 'DAnyVector2', 'DAnyVec2', 'DAnyVector3', 'DAnyVec3', 'DAnyVector4', 'DAnyVec4', 'DAnyVectorAny', 'DAnyVecAny', 'F32Vector1', 'F32Vec1', 'F32Vector2', 'F32Vec2', 'F32Vector3', 'F32Vec3', 'F32Vector4', 'F32Vec4', 'F32VectorAny', 'F32VecAny', 'FAnyVector1', 'FAnyVec1', 'FAnyVector2', 'FAnyVec2', 'FAnyVector3', 'FAnyVec3', 'FAnyVector4', 'FAnyVec4', 'FAnyVectorAny', 'FAnyVecAny', 'I8Vector1', 'I8Vec1', 'I8Vector2', 'I8Vec2', 'I8Vector3', 'I8Vec3', 'I8Vector4', 'I8Vec4', 'I8VectorAny', 'I8VecAny', 'I16Vector1', 'I16Vec1', 'I16Vector2', 'I16Vec2', 'I16Vector3', 'I16Vec3', 'I16Vector4', 'I16Vec4', 'I16VectorAny', 'I16VecAny', 'I32Vector1', 'I32Vec1', 'I32Vector2', 'I32Vec2', 'I32Vector3', 'I32Vec3', 'I32Vector4', 'I32Vec4', 'I32VectorAny', 'I32VecAny', 'I64Vector1', 'I64Vec1', 'I64Vector2', 'I64Vec2', 'I64Vector3', 'I64Vec3', 'I64Vector4', 'I64Vec4', 'I64VectorAny', 'I64VecAny', 'IAnyVector1', 'IAnyVec1', 'IAnyVector2', 'IAnyVec2', 'IAnyVector3', 'IAnyVec3', 'IAnyVector4', 'IAnyVec4', 'IAnyVectorAny', 'IAnyVecAny', 'U8Vector1', 'U8Vec1', 'U8Vector2', 'U8Vec2', 'U8Vector3', 'U8Vec3', 'U8Vector4', 'U8Vec4', 'U8VectorAny', 'U8VecAny', 'U16Vector1', 'U16Vec1', 'U16Vector2', 'U16Vec2', 'U16Vector3', 'U16Vec3', 'U16Vector4', 'U16Vec4', 'U16VectorAny', 'U16VecAny', 'U32Vector1', 'U32Vec1', 'U32Vector2', 'U32Vec2', 'U32Vector3', 'U32Vec3', 'U32Vector4', 'U32Vec4', 'U32VectorAny', 'U32VecAny', 'U64Vector1', 'U64Vec1', 'U64Vector2', 'U64Vec2', 'U64Vector3', 'U64Vec3', 'U64Vector4', 'U64Vec4', 'U64VectorAny', 'U64VecAny', 'UAnyVector1', 'UAnyVec1', 'UAnyVector2', 'UAnyVec2', 'UAnyVector3', 'UAnyVec3', 'UAnyVector4', 'UAnyVec4', 'UAnyVectorAny', 'UAnyVecAny', 'Any8Vector1', 'Any8Vec1', 'Any8Vector2', 'Any8Vec2', 'Any8Vector3', 'Any8Vec3', 'Any8Vector4', 'Any8Vec4', 'Any8VectorAny', 'Any8VecAny', 'Any16Vector1', 'Any16Vec1', 'Any16Vector2', 'Any16Vec2', 'Any16Vector3', 'Any16Vec3', 'Any16Vector4', 'Any16Vec4', 'Any16VectorAny', 'Any16VecAny', 'Any32Vector1', 'Any32Vec1', 'Any32Vector2', 'Any32Vec2', 'Any32Vector3', 'Any32Vec3', 'Any32Vector4', 'Any32Vec4', 'Any32VectorAny', 'Any32VecAny', 'Any64Vector1', 'Any64Vec1', 'Any64Vector2', 'Any64Vec2', 'Any64Vector3', 'Any64Vec3', 'Any64Vector4', 'Any64Vec4', 'Any64VectorAny', 'Any64VecAny', 'AnyAnyVector1', 'AnyAnyVec1', 'AnyAnyVector2', 'AnyAnyVec2', 'AnyAnyVector3', 'AnyAnyVec3', 'AnyAnyVector4', 'AnyAnyVec4', 'AnyAnyVectorAny', 'AnyAnyVecAny', 'FDAnyVectorAny', 'FDAnyVector1', 'FDAnyVector2', 'FDAnyVector3', 'FDAnyVector4', 'IUAnyVector1', 'IUAnyVector2', 'IUAnyVector3', 'IUAnyVector4', 'D64Matrix2x2', 'D64Mat2x2', 'D64Matrix2x3', 'D64Mat2x3', 'D64Matrix2x4', 'D64Mat2x4', 'D64Matrix2xAny', 'D64Mat2xAny', 'D64Matrix3x2', 'D64Mat3x2', 'D64Matrix3x3', 'D64Mat3x3', 'D64Matrix3x4', 'D64Mat3x4', 'D64Matrix3xAny', 'D64Mat3xAny', 'D64Matrix4x2', 'D64Mat4x2', 'D64Matrix4x3', 'D64Mat4x3', 'D64Matrix4x4', 'D64Mat4x4', 'D64Matrix4xAny', 'D64Mat4xAny', 'D64MatrixAnyx2', 'D64MatAnyx2', 'D64MatrixAnyx3', 'D64MatAnyx3', 'D64MatrixAnyx4', 'D64MatAnyx4', 'D64MatrixAnyxAny', 'D64MatAnyxAny', 'DAnyMatrix2x2', 'DAnyMat2x2', 'DAnyMatrix2x3', 'DAnyMat2x3', 'DAnyMatrix2x4', 'DAnyMat2x4', 'DAnyMatrix2xAny', 'DAnyMat2xAny', 'DAnyMatrix3x2', 'DAnyMat3x2', 'DAnyMatrix3x3', 'DAnyMat3x3', 'DAnyMatrix3x4', 'DAnyMat3x4', 'DAnyMatrix3xAny', 'DAnyMat3xAny', 'DAnyMatrix4x2', 'DAnyMat4x2', 'DAnyMatrix4x3', 'DAnyMat4x3', 'DAnyMatrix4x4', 'DAnyMat4x4', 'DAnyMatrix4xAny', 'DAnyMat4xAny', 'DAnyMatrixAnyx2', 'DAnyMatAnyx2', 'DAnyMatrixAnyx3', 'DAnyMatAnyx3', 'DAnyMatrixAnyx4', 'DAnyMatAnyx4', 'DAnyMatrixAnyxAny', 'DAnyMatAnyxAny', 'F32Matrix2x2', 'F32Mat2x2', 'F32Matrix2x3', 'F32Mat2x3', 'F32Matrix2x4', 'F32Mat2x4', 'F32Matrix2xAny', 'F32Mat2xAny', 'F32Matrix3x2', 'F32Mat3x2', 'F32Matrix3x3', 'F32Mat3x3', 'F32Matrix3x4', 'F32Mat3x4', 'F32Matrix3xAny', 'F32Mat3xAny', 'F32Matrix4x2', 'F32Mat4x2', 'F32Matrix4x3', 'F32Mat4x3', 'F32Matrix4x4', 'F32Mat4x4', 'F32Matrix4xAny', 'F32Mat4xAny', 'F32MatrixAnyx2', 'F32MatAnyx2', 'F32MatrixAnyx3', 'F32MatAnyx3', 'F32MatrixAnyx4', 'F32MatAnyx4', 'F32MatrixAnyxAny', 'F32MatAnyxAny', 'FAnyMatrix2x2', 'FAnyMat2x2', 'FAnyMatrix2x3', 'FAnyMat2x3', 'FAnyMatrix2x4', 'FAnyMat2x4', 'FAnyMatrix2xAny', 'FAnyMat2xAny', 'FAnyMatrix3x2', 'FAnyMat3x2', 'FAnyMatrix3x3', 'FAnyMat3x3', 'FAnyMatrix3x4', 'FAnyMat3x4', 'FAnyMatrix3xAny', 'FAnyMat3xAny', 'FAnyMatrix4x2', 'FAnyMat4x2', 'FAnyMatrix4x3', 'FAnyMat4x3', 'FAnyMatrix4x4', 'FAnyMat4x4', 'FAnyMatrix4xAny', 'FAnyMat4xAny', 'FAnyMatrixAnyx2', 'FAnyMatAnyx2', 'FAnyMatrixAnyx3', 'FAnyMatAnyx3', 'FAnyMatrixAnyx4', 'FAnyMatAnyx4', 'FAnyMatrixAnyxAny', 'FAnyMatAnyxAny', 'I32Matrix2x2', 'I32Mat2x2', 'I32Matrix2x3', 'I32Mat2x3', 'I32Matrix2x4', 'I32Mat2x4', 'I32Matrix2xAny', 'I32Mat2xAny', 'I32Matrix3x2', 'I32Mat3x2', 'I32Matrix3x3', 'I32Mat3x3', 'I32Matrix3x4', 'I32Mat3x4', 'I32Matrix3xAny', 'I32Mat3xAny', 'I32Matrix4x2', 'I32Mat4x2', 'I32Matrix4x3', 'I32Mat4x3', 'I32Matrix4x4', 'I32Mat4x4', 'I32Matrix4xAny', 'I32Mat4xAny', 'I32MatrixAnyx2', 'I32MatAnyx2', 'I32MatrixAnyx3', 'I32MatAnyx3', 'I32MatrixAnyx4', 'I32MatAnyx4', 'I32MatrixAnyxAny', 'I32MatAnyxAny', 'IAnyMatrix2x2', 'IAnyMat2x2', 'IAnyMatrix2x3', 'IAnyMat2x3', 'IAnyMatrix2x4', 'IAnyMat2x4', 'IAnyMatrix2xAny', 'IAnyMat2xAny', 'IAnyMatrix3x2', 'IAnyMat3x2', 'IAnyMatrix3x3', 'IAnyMat3x3', 'IAnyMatrix3x4', 'IAnyMat3x4', 'IAnyMatrix3xAny', 'IAnyMat3xAny', 'IAnyMatrix4x2', 'IAnyMat4x2', 'IAnyMatrix4x3', 'IAnyMat4x3', 'IAnyMatrix4x4', 'IAnyMat4x4', 'IAnyMatrix4xAny', 'IAnyMat4xAny', 'IAnyMatrixAnyx2', 'IAnyMatAnyx2', 'IAnyMatrixAnyx3', 'IAnyMatAnyx3', 'IAnyMatrixAnyx4', 'IAnyMatAnyx4', 'IAnyMatrixAnyxAny', 'IAnyMatAnyxAny', 'U32Matrix2x2', 'U32Mat2x2', 'U32Matrix2x3', 'U32Mat2x3', 'U32Matrix2x4', 'U32Mat2x4', 'U32Matrix2xAny', 'U32Mat2xAny', 'U32Matrix3x2', 'U32Mat3x2', 'U32Matrix3x3', 'U32Mat3x3', 'U32Matrix3x4', 'U32Mat3x4', 'U32Matrix3xAny', 'U32Mat3xAny', 'U32Matrix4x2', 'U32Mat4x2', 'U32Matrix4x3', 'U32Mat4x3', 'U32Matrix4x4', 'U32Mat4x4', 'U32Matrix4xAny', 'U32Mat4xAny', 'U32MatrixAnyx2', 'U32MatAnyx2', 'U32MatrixAnyx3', 'U32MatAnyx3', 'U32MatrixAnyx4', 'U32MatAnyx4', 'U32MatrixAnyxAny', 'U32MatAnyxAny', 'UAnyMatrix2x2', 'UAnyMat2x2', 'UAnyMatrix2x3', 'UAnyMat2x3', 'UAnyMatrix2x4', 'UAnyMat2x4', 'UAnyMatrix2xAny', 'UAnyMat2xAny', 'UAnyMatrix3x2', 'UAnyMat3x2', 'UAnyMatrix3x3', 'UAnyMat3x3', 'UAnyMatrix3x4', 'UAnyMat3x4', 'UAnyMatrix3xAny', 'UAnyMat3xAny', 'UAnyMatrix4x2', 'UAnyMat4x2', 'UAnyMatrix4x3', 'UAnyMat4x3', 'UAnyMatrix4x4', 'UAnyMat4x4', 'UAnyMatrix4xAny', 'UAnyMat4xAny', 'UAnyMatrixAnyx2', 'UAnyMatAnyx2', 'UAnyMatrixAnyx3', 'UAnyMatAnyx3', 'UAnyMatrixAnyx4', 'UAnyMatAnyx4', 'UAnyMatrixAnyxAny', 'UAnyMatAnyxAny', 'AnyAnyMatrix2x2', 'AnyAnyMat2x2', 'AnyAnyMatrix2x3', 'AnyAnyMat2x3', 'AnyAnyMatrix2x4', 'AnyAnyMat2x4', 'AnyAnyMatrix2xAny', 'AnyAnyMat2xAny', 'AnyAnyMatrix3x2', 'AnyAnyMat3x2', 'AnyAnyMatrix3x3', 'AnyAnyMat3x3', 'AnyAnyMatrix3x4', 'AnyAnyMat3x4', 'AnyAnyMatrix3xAny', 'AnyAnyMat3xAny', 'AnyAnyMatrix4x2', 'AnyAnyMat4x2', 'AnyAnyMatrix4x3', 'AnyAnyMat4x3', 'AnyAnyMatrix4x4', 'AnyAnyMat4x4', 'AnyAnyMatrix4xAny', 'AnyAnyMat4xAny', 'AnyAnyMatrixAnyx2', 'AnyAnyMatAnyx2', 'AnyAnyMatrixAnyx3', 'AnyAnyMatAnyx3', 'AnyAnyMatrixAnyx4', 'AnyAnyMatAnyx4', 'AnyAnyMatrixAnyxAny', 'AnyAnyMatAnyxAny', 'AnyAnyMatrixSquare', 'D64Quaternion', 'D64Quat', 'DAnyQuaternion', 'DAnyQuat', 'F32Quaternion', 'F32Quat', 'FAnyQuaternion', 'FAnyQuat', 'AnyAnyQuaternion', 'AnyAnyQuat', 'FDAnyQuaternion', 'FDAnyQuaternionVector4'] diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..07de284a --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ["setuptools", "wheel"] +build-backend = "setuptools.build_meta" \ No newline at end of file diff --git a/setup.cfg b/setup.cfg index 1f4bb8c5..1aea4d3b 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,7 +1,38 @@ -[bdist_wheel] -# This flag says that the code is written to work on both Python 2 and Python -# 3. If at all possible, it is good practice to do this. If you cannot, you -# will need to generate wheels for each Python version that you support. -#universal=0 [metadata] -license_file = COPYING \ No newline at end of file +name = pyglm +version = file: VERSION +author = Zuzu_Typ +author_email = zuzu.typ@gmail.com +description = OpenGL Mathematics library for Python +long_description = file: README.md +long_description_content_type = text/markdown +keywords = GLM, OpenGL, matrix, vector, vec, mat, Mathematics, 3D, python, python3, 3, library, python-c-api, c-api, math-library, numpy, pyrr, pip, pypi, matrix-manipulation, matrix-multiplication, matrix-functions, quaternion, c, glsl +python_requires = >=3.7 +license = Zlib +dynamic = +classifiers = + Development Status :: 5 - Production/Stable + Intended Audience :: Developers + License :: OSI Approved :: zlib/libpng License + Programming Language :: Python :: 3 :: Only + Programming Language :: Python :: 3 + Programming Language :: Python :: 3.9 + Programming Language :: Python :: 3.10 + Programming Language :: Python :: 3.11 + Programming Language :: Python :: 3.12 + Programming Language :: Python :: 3.13 + Programming Language :: Python :: 3.14 + Operating System :: Microsoft :: Windows + Operating System :: POSIX :: Linux + Operating System :: MacOS + Topic :: Multimedia :: Graphics + Topic :: Software Development :: Libraries + Topic :: Scientific/Engineering :: Physics + Typing :: Typed +project_urls = + Source Code = https://github.com/Zuzu-Typ/PyGLM/ + Documentation = https://github.com/Zuzu-Typ/PyGLM/wiki + +[options] +include_package_data = True +packages = find: diff --git a/setup.py b/setup.py index 89e2340f..fb73a5b2 100644 --- a/setup.py +++ b/setup.py @@ -1,132 +1,21 @@ -"""A setuptools based setup module. -See: -https://packaging.python.org/en/latest/distributing.html -https://github.com/pypa/sampleproject -""" +from setuptools import Extension, setup -import sys -if sys.version_info.major < 3 or sys.version_info.minor < 5: - raise Exception("PyGLM (0.5.0b1+) requires Python 3.5 or higher. Please install PyGLM==0.4.8b1") - -# Always prefer setuptools over distutils -from setuptools import setup, find_packages, Extension -# To use a consistent encoding from codecs import open -from os import path -import re - -module1 = Extension('glm', - sources = ['PyGLM.cpp'], include_dirs=["glm/"], extra_compile_args=['-std=c++11']) +from os import path here = path.abspath(path.dirname(__file__)) -with open(path.join(here, "version.h")) as f: - __version__ = re.search('"(.*?)"', f.read()).group().strip('"') - -# Get the long description from the README file -with open(path.join(here, 'README.md'), encoding='utf-8') as f: - long_description = f.read() - long_description = long_description.replace("\r", "") +with open(path.join(here, "VERSION")) as file_: + VERSION = file_.read().strip() setup( - name='PyGLM', - - # Versions should comply with PEP440. For a discussion on single-sourcing - # the version across setup.py and the project code, see - # https://packaging.python.org/en/latest/single_source_version.html - version=__version__, - - description='OpenGL Mathematics library for Python', - long_description=long_description, - long_description_content_type='text/markdown', - - # The project's main homepage. - url='https://github.com/Zuzu-Typ/PyGLM', - - # Author details - author='Zuzu_Typ', - author_email="zuzu.typ@gmail.com", - - # Choose your license - license='zlib/libpng license', - -## install_requires=[], - - # See https://pypi.python.org/pypi?%3Aaction=list_classifiers - classifiers=[ - # How mature is this project? Common values are - # 3 - Alpha - # 4 - Beta - # 5 - Production/Stable - 'Development Status :: 5 - Production/Stable', - - # Indicate who your project is intended for - 'Intended Audience :: Developers', - 'Topic :: Multimedia :: Graphics', - - # Pick your license as you wish (should match "license" above) - 'License :: OSI Approved :: zlib/libpng License', - - # Specify the Python versions you support here. In particular, ensure - # that you indicate whether you support Python 2, Python 3 or both. - 'Programming Language :: Python :: 3 :: Only', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.5', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: 3.7', - 'Programming Language :: Python :: 3.8', - 'Programming Language :: Python :: 3.9', - 'Programming Language :: Python :: 3.10', - 'Operating System :: Microsoft :: Windows', - 'Operating System :: POSIX :: Linux', - "Operating System :: MacOS", - 'Topic :: Software Development :: Libraries', - 'Topic :: Scientific/Engineering :: Physics' - - ], - - # What does your project relate to? - keywords='GLM OpenGL matrix vector vec mat Mathematics 3D python python3 3 library python-c-api c-api math-library numpy pyrr pip pypi matrix-manipulation matrix-multiplication matrix-functions quaternion c glsl', - - # You can just specify the packages manually here if your project is - # simple. Or you can use find_packages(). - packages={},#find_packages(exclude=['contrib', 'docs', 'tests'],include=["*.h"]), - -## package_data={ -## "":["*.h"] -## }, - - platforms = ["Windows", "Linux", "MacOS"], - - include_package_data=True, - - # Alternatively, if you want to distribute just a my_module.py, uncomment - # this: - #py_modules=["glm"], - - ext_modules = [module1], - - # List run-time dependencies here. These will be installed by pip when - # your project is installed. For an analysis of "install_requires" vs pip's - # requirements files see: - # https://packaging.python.org/en/latest/requirements.html - - # List additional groups of dependencies here (e.g. development - # dependencies). You can install these using the following syntax, - # for example: - # $ pip install -e .[dev,test] - - # If there are data files included in your packages that need to be - # installed, specify them here. If using Python 2.6 or less, then these - # have to be included in MANIFEST.in as well. - - # Although 'package_data' is the preferred approach, in some case you may - # need to place data files outside of your packages. See: - # http://docs.python.org/3.4/distutils/setupscript.html#installing-additional-files # noqa - # In this case, 'data_file' will be installed into '/my_data' - - # To provide executable scripts, use entry points in preference to the - # "scripts" keyword. Entry points provide cross-platform support and allow - # pip to create the appropriate form of executable for the target platform. + ext_modules=[ + Extension( + name="pyglm.glm", + sources=["PyGLM_lib/PyGLM.cpp"], + include_dirs=["PyGLM_lib/glm/"], + extra_compile_args=['-std=c++11', f'-DVERSION={VERSION}'] + ), + ] ) diff --git a/test/PyGLM_test.py b/test/PyGLM_test.py index 9c645a63..2ab10627 100644 --- a/test/PyGLM_test.py +++ b/test/PyGLM_test.py @@ -1,4 +1,4 @@ -import glm, sys, random, time, copy, re, math +import glm, sys, random, time, copy, re, math, ctypes from collections import OrderedDict @@ -478,6 +478,27 @@ def test_specific(): 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(): @@ -759,6 +780,36 @@ def test_div(): 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"): @@ -798,21 +849,21 @@ def test_rshift(): # and # def test_and(): - for obj in gen_obj("#MV__iqsuIQSU"): + 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__iqsuIQSU"): + 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__iqsuIQSU"): + for obj in gen_obj("#MV__iqsuIQSUB"): fassert(obj.__xor__, (1,)) fassert(obj.__xor__, (obj,)) #/xor # @@ -877,7 +928,7 @@ def test_imod(): # ifloordiv # def test_ifloordiv(): - for obj in gen_obj("#MV__fF"): + for obj in gen_obj("#MV__fFiqsuIQSU"): fassert(obj.__ifloordiv__, (1,)) #/ifloordiv # @@ -1146,6 +1197,24 @@ def test_buffer_protocol(): 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 # @@ -3301,7 +3370,7 @@ def test_uaddCarry(): 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),) + ((16, 17, 2**32 - 1, 1),) ] for x, y, expected_result, expected_borrow in cases: @@ -3574,7 +3643,36 @@ def test_mat2x2(): ##/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 ### diff --git a/test/PyGLM vs NumPy.py b/test/PyGLM_vs_NumPy.py similarity index 100% rename from test/PyGLM vs NumPy.py rename to test/PyGLM_vs_NumPy.py diff --git a/version.h b/version.h deleted file mode 100644 index 881179f8..00000000 --- a/version.h +++ /dev/null @@ -1 +0,0 @@ -#define PyGLM_VERSION "2.5.7" \ No newline at end of file diff --git a/vs-project/.gitignore b/vs-project/.gitignore new file mode 100644 index 00000000..f0f2feea --- /dev/null +++ b/vs-project/.gitignore @@ -0,0 +1,2 @@ +Win32/ +x64/ diff --git a/vs-project/PyGLM build/.gitignore b/vs-project/PyGLM build/.gitignore new file mode 100644 index 00000000..f0f2feea --- /dev/null +++ b/vs-project/PyGLM build/.gitignore @@ -0,0 +1,2 @@ +Win32/ +x64/ diff --git a/vs-project/PyGLM build/PyGLM build.vcxproj b/vs-project/PyGLM build/PyGLM build.vcxproj new file mode 100644 index 00000000..0ca3f93b --- /dev/null +++ b/vs-project/PyGLM build/PyGLM build.vcxproj @@ -0,0 +1,366 @@ + + + + + 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_d + .pyd + + + .pyd + glm + + + $(SolutionDir)$(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\ + glm_d + .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) + python39_d.lib;%(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/vs-project/PyGLM build/PyGLM build.vcxproj.filters b/vs-project/PyGLM build/PyGLM build.vcxproj.filters new file mode 100644 index 00000000..25954528 --- /dev/null +++ b/vs-project/PyGLM build/PyGLM build.vcxproj.filters @@ -0,0 +1,741 @@ + + + + + {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 + + + Headerdateien\PyGLM\internal_functions + + + \ No newline at end of file diff --git a/vs-project/PyGLM build/PyGLM build.vcxproj.user b/vs-project/PyGLM build/PyGLM build.vcxproj.user new file mode 100644 index 00000000..be250787 --- /dev/null +++ b/vs-project/PyGLM build/PyGLM build.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/vs-project/PyGLM test.pyproj b/vs-project/PyGLM test.pyproj new file mode 100644 index 00000000..46595156 --- /dev/null +++ b/vs-project/PyGLM test.pyproj @@ -0,0 +1,55 @@ + + + Debug + 2.0 + 4db02b00-448e-49ac-bbde-4e06aa14f15d + + + PyGLM_run.py + ..\test + . + . + PyGLM test + PyGLM test + Standard Python launcher + True + -i + False + Global|PythonCore|3.9 + true + + + true + false + + + true + false + + + + + + + + PyGLM build + {9908a257-6824-4543-b7e4-acfd9f40ad85} + True + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/vs-project/PyGLM.sln b/vs-project/PyGLM.sln new file mode 100644 index 00000000..e1b5089f --- /dev/null +++ b/vs-project/PyGLM.sln @@ -0,0 +1,45 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.10.34916.146 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{888888A0-9F3D-457C-B088-3A5042F75D52}") = "PyGLM test", "PyGLM test.pyproj", "{4DB02B00-448E-49AC-BBDE-4E06AA14F15D}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PyGLM build", "PyGLM build\PyGLM build.vcxproj", "{9908A257-6824-4543-B7E4-ACFD9F40AD85}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {4DB02B00-448E-49AC-BBDE-4E06AA14F15D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4DB02B00-448E-49AC-BBDE-4E06AA14F15D}.Debug|x64.ActiveCfg = Debug|Any CPU + {4DB02B00-448E-49AC-BBDE-4E06AA14F15D}.Debug|x86.ActiveCfg = Debug|Any CPU + {4DB02B00-448E-49AC-BBDE-4E06AA14F15D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4DB02B00-448E-49AC-BBDE-4E06AA14F15D}.Release|x64.ActiveCfg = Release|Any CPU + {4DB02B00-448E-49AC-BBDE-4E06AA14F15D}.Release|x86.ActiveCfg = Release|Any CPU + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Debug|Any CPU.ActiveCfg = Debug|x64 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Debug|Any CPU.Build.0 = Debug|x64 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Debug|x64.ActiveCfg = Debug|x64 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Debug|x64.Build.0 = Debug|x64 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Debug|x86.ActiveCfg = Debug|Win32 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Debug|x86.Build.0 = Debug|Win32 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Release|Any CPU.ActiveCfg = Release|x64 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Release|Any CPU.Build.0 = Release|x64 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Release|x64.ActiveCfg = Release|x64 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Release|x64.Build.0 = Release|x64 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Release|x86.ActiveCfg = Release|Win32 + {9908A257-6824-4543-B7E4-ACFD9F40AD85}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {2372BA11-12FC-4113-9F11-16049FC0C8C4} + EndGlobalSection +EndGlobal diff --git a/vs-project/PyGLM_run.py b/vs-project/PyGLM_run.py new file mode 100644 index 00000000..dbd7dcde --- /dev/null +++ b/vs-project/PyGLM_run.py @@ -0,0 +1,50 @@ + +import os + +os.environ["TEST_PICKLING"] = "True" + +TEST = True + +TEST_PERFORMANCE = False + +GEN_DOC = True + +if TEST_PERFORMANCE: + import PyGLM_vs_NumPy + +if TEST: + import PyGLM_test, time, traceback, sys + print("Testing PyGLM...") + start_time = time.time() + for member in dir(PyGLM_test): + if member.startswith("test"): + try: + getattr(PyGLM_test, member)() + except: + print("The following test failed: " + member, file=sys.stderr) + traceback.print_exc() + print("Finished tests in {:.3g}s".format(time.time()-start_time)) + + +import glm +from glm import * + +if GEN_DOC: + import generate_function_reference + +if True: + import time + def t(func, *args, r=1000000, **kw): + start = time.time() + for i in range(r): + func(*args, **kw) + return time.time() - start + from sys import getrefcount as rc + def memcor(func, *args, r=1000000, **kw): + for i in range(r): + try: + func(*args, **kw) + except: + pass + + diff --git a/vs-project/SlashBack.py b/vs-project/SlashBack.py new file mode 100644 index 00000000..66826468 --- /dev/null +++ b/vs-project/SlashBack.py @@ -0,0 +1,541 @@ + +# License (zlib/libpng): + +############################################# +# # +# Copyright (c) 2019 Zuzu_Typ # +#--------------------------------------------# +# This software is provided 'as-is', # +# without any express or implied warranty. # +# In no event will the authors be held # +# liable for any damages arising from the # +# use of this software. # +# # +# Permission is granted to anyone to use # +# this software for any purpose, including # +# commercial applications, and to alter it # +## and redistribute it freely, subject to # +## the following restrictions: # +## # +## 1. The origin of this software must not # +## be misrepresented; you must not claim # +## that you wrote the original software. # +## If you use this software in a product, # +## an acknowledgment in the product # +## documentation would be appreciated but # +## is not required. # +## # +## 2. Altered source versions must be # +# # plainly marked as such, and must not # +# # be misrepresented as being the # +# # original software. # +# # # +# # 3. This notice may not be removed or # +### altered from any source distribution. # + ############################################## + +from builtins import open as builtins_open + +import sys, os, traceback, string + +__version__ = "0.2.0" + +__welcome__ = f"""\ +SlashBack v{__version__} by Zuzu_Typ""" + +__doc__ = """\ +A little editor for my own markup language +called SlashBack ( \\SB\\ ).""" + +__usage__ = """\ +Usage: +SlashBack.py """ + +class TextConfig: + NO_LIST = 0 + ORDERED_LIST = 1 + UNORDERED_LIST = 2 + + NO_TASK = 0 + CHECKED_TASK = 1 + UNCHECKED_TASK = 2 + + bold = False + italic = False + strikethrough = False + underline = False + quote = False + table = False + separator = False + raw = False + ignore = False + code = None + image = None + url = None + mention = None + reference = None + comment = None + list = NO_LIST + task = NO_TASK + header = 0 + index = 1 + indent = 1 + list_indices = {} # only for ordered lists + + def __init__(self, other_config = None): + if other_config: + self.bold = other_config.bold + self.italic = other_config.italic + self.strikethrough = other_config.strikethrough + self.underline = other_config.underline + self.quote = other_config.quote + self.table = other_config.table + self.separator = other_config.separator + self.raw = other_config.raw + self.ignore = other_config.ignore + self.code = other_config.code + self.image = other_config.image + self.url = other_config.url + self.mention = other_config.mention + self.reference = other_config.reference + self.comment = other_config.comment + self.list = other_config.list + self.task = other_config.task + self.header = other_config.header + self.index = other_config.index + self.indent = other_config.indent + self.list_indices = other_config.list_indices.copy() + + def __str__(self): + out = set() + + if self.comment: + out.add(f"/* {self.comment} */") + if self.bold: + out.add("bold") + if self.italic: + out.add("italic") + if self.strikethrough: + out.add("strikethrough") + if self.underline: + out.add("underline") + if self.quote: + out.add("quote") + if self.table: + out.add(f"table at {self.index}") + if self.raw: + out.add("") + if self.code: + out.add(f"code {self.code}") + if self.image: + out.add(f"image {self.image}") + if self.url: + out.add(f"url {self.url}") + if self.mention: + out.add(f"mention {self.mention}") + if self.reference: + out.add(f"reference {self.reference}") + if self.list: + out.add(("ordered list" if self.list == self.ORDERED_LIST else "unordered list") + f" at {self.index}") + if self.task: + out.add("checked task" if self.list == self.CHECKED_TASK else "unchecked task") + if self.header: + out.add(f"h{self.header}") + if self.separator: + out.add("---") + + return ", ".join(out) + + __repr__ = lambda self: self.__str__() + +class Text: + def __init__(self, text, text_config): + self.text = text + self.text_config = text_config + +class ParsedText: + def __init__(self, text_list): + self.text_list = text_list + + def to_markdown(self): + out = [f"[//]: # (generated using SlashBack {__version__})\n\n".encode()] + + current_text_config = TextConfig() + + table_signalized = True + + for text in self.text_list: + text_string = text.text + this_text_config = text.text_config + + if this_text_config.raw: + out.append(text_string) + continue + + if not this_text_config.code: + for char in "\\`*_{}[]()#+-.!": + text_string = text_string.replace(char.encode(), f"\\{char}".encode()) + for char, replacement in ((b"&", b"&"), (b"<", b"<"), (b">", b">"), (b"~", b"~"), (b"|", b"|"), (b"@", b"@"), (b"`", b"`")): + text_string = text_string.replace(char, replacement) + + if not this_text_config.table: + text_string = text_string.replace(b"\t", b" ").replace(b" ", b" " * 2).replace(b"\r\n", b"\n").replace(b"\r", b"\n").replace(b"\n", b" \n") + else: + pass#text_string = text_string.replace(b"`", b"`") + + if not table_signalized and b"\n" in text_string: + table_signalized = True + text_string = text_string.replace(b"\n", b"\n" + b"|".join([b"-"] * (this_text_config.index + 1)) + b"\n") + + + + if this_text_config.list and this_text_config.index != 0 and current_text_config.index != this_text_config.index: + out.append(b" " * (this_text_config.indent - 1) + ( f"{this_text_config.index}. ".encode() if this_text_config.list == TextConfig.ORDERED_LIST else b"* ")) + + if current_text_config.table and this_text_config.table and current_text_config.index < this_text_config.index: + out.append(b"|") + + if not current_text_config.bold and this_text_config.bold: + out.append(b"**") + + if not current_text_config.italic and this_text_config.italic: + out.append(b"*") + + if not current_text_config.strikethrough and this_text_config.strikethrough: + out.append(b"~~") + + if not current_text_config.underline and this_text_config.underline: + out.append(b"") + + if not current_text_config.quote and this_text_config.quote: + out.append(b">") + + if not current_text_config.table and this_text_config.table: + table_signalized = False + + if not current_text_config.code and this_text_config.code: + out.append(b"``` ") + if isinstance(this_text_config.code, bytes): + out.append(this_text_config.code) + + if not current_text_config.image and this_text_config.image: + out.append(b"![") + + if not current_text_config.url and this_text_config.url: + out.append(b"[") + + if not current_text_config.list and this_text_config.list: + pass + + if not current_text_config.task and this_text_config.task: + if this_text_config.task == TextConfig.CHECKED_TASK: + out.append(b"- [x] ") + else: + out.append(b"- [ ] ") + + if not current_text_config.header and this_text_config.header: + out.append(b"#" * this_text_config.header + b" ") + + if not current_text_config.separator and this_text_config.separator: + out.append(b"\n---") + + if not current_text_config.mention and this_text_config.mention: + out.append(b"@" + this_text_config.mention) + + if not current_text_config.reference and this_text_config.reference: + out.append(this_text_config.reference) + + if not current_text_config.comment and this_text_config.comment: + out.append(f" [//]: # ({this_text_config.comment.decode()}) ".encode()) + + # backward # + + if current_text_config.url and not this_text_config.url: + out.append(f"]({current_text_config.url.decode()})".encode()) + + if current_text_config.image and not this_text_config.image: + out.append(f"]({current_text_config.image.decode()})".encode()) + + if current_text_config.code and not this_text_config.code: + out.append(b" ```") + + if current_text_config.task and not this_text_config.task: + out.append(b"\n\n") + + if current_text_config.quote and not this_text_config.quote: + out.append(b"\n\n") + + if current_text_config.underline and not this_text_config.underline: + out.append(b"") + + if current_text_config.strikethrough and not this_text_config.strikethrough: + out.append(b"~~") + + if current_text_config.italic and not this_text_config.italic: + out.append(b"*") + + if current_text_config.bold and not this_text_config.bold: + out.append(b"**") + + if not (not current_text_config.ignore and this_text_config.ignore): + out.append(text_string) + + current_text_config = this_text_config + + if current_text_config.url: + out.append(f"]({current_text_config.url.decode()})".encode()) + + if current_text_config.image: + out.append(f"]({current_text_config.image.decode()})".encode()) + + if current_text_config.code: + out.append(b" ```") + + if current_text_config.quote: + out.append(b"\n\n") + + if current_text_config.strikethrough: + out.append(b"~~") + + if current_text_config.italic: + out.append(b"*") + + if current_text_config.bold: + out.append(b"**") + + return b"".join(out) + + +class SlashBackParserError(Exception): + pass + +class SlashBackParser: + def __init__(self, path = None, auto_read = True): + self.path = path + self.read() + + def read(self): + file_ = builtins_open(self.path, "rb") + content = file_.read() + file_.close() + + self.parsed_text = self.parse(content) + + def write(self, path): + file_ = builtins_open(path, "wb") + file_.write(self.parsed_text.to_markdown()) + file_.close() + + def parse_single(self, command, config): + command = command.lstrip((string.whitespace + "!#/:|+.~>_<").encode()).rstrip() + + if config.separator: config.separator = False + if config.reference: config.reference = None + if config.mention: config.mention = None + if config.comment: config.comment = None + + + if command == b"raw": + config.raw = not config.raw + + elif command == b"h1": + config.header = 0 if config.header else 1 + elif command == b"h2": + config.header = 0 if config.header else 2 + elif command == b"h3": + config.header = 0 if config.header else 3 + elif command == b"h4": + config.header = 0 if config.header else 4 + elif command == b"h5": + config.header = 0 if config.header else 5 + elif command == b"h6": + config.header = 0 if config.header else 6 + + elif command == b"b": + config.bold = not config.bold + elif command == b"i": + config.italic = not config.italic + + elif command in (b"separator", b"sep"): + config.separator = True + + elif command == b"s": + config.strikethrough = not config.strikethrough + + elif command == b"u": + config.underline = not config.underline + + elif command in (b"quote", b"q"): + config.quote = not config.quote + + elif command in (b"table", b"tbl"): + if config.list: + raise SlashBackParserError("A table can't be created inside a list") + config.table = not config.table + config.index = 0 + + elif command in (b"list switch", b"ls", b"sl"): + if not config.list: + raise SlashBackParserError("There's no list to switch here") + config.list = config.ORDERED_LIST if config.list == config.UNORDERED_LIST else config.UNORDERED_LIST + config.index = 0 + + elif command in (b"list ordered", b"lo", b"ol"): + if config.table: + raise SlashBackParserError("A list can't be created inside a table") + config.list = config.NO_LIST if config.list else config.ORDERED_LIST + config.index = 0 + + elif command in (b"list unordered", b"lu", b"ul"): + if config.table: + raise SlashBackParserError("A list can't be created inside a table") + config.list = config.NO_LIST if config.list else config.UNORDERED_LIST + config.index = 0 + + elif command in (b"list", b"lo", b"ol", b"lu", b"ul"): + if not config.list: + raise SlashBackParseError("Unspecified list type") + + config.list = config.NO_LIST + + config.list_indices = {} + + elif command in (b"task checked", b"tc", b"x"): + config.task = config.NO_TASK if config.task else config.CHECKED_TASK + + elif command in (b"task unchecked", b"tu", b"o"): + config.task = config.NO_TASK if config.task else config.UNCHECKED_TASK + + elif command in (b"task", b"tc", b"tu", b"x", b"o"): + if not config.task: + raise SlashBackParseError("Unspecified task type") + + config.task = config.NO_TASK + + elif command in (b"image", b"img"): + if not config.image: + raise SlashBackParseError("Unspecified image type") + + config.image = None + + elif command == b"url": #TODO + if not config.url: + raise SlashBackParseError("Unspecified url link") + + config.url = None + + elif command.count(b"-") == len(command): + if config.list: + config.indent = command.count(b"-") + + for indent in config.list_indices.copy(): + if indent > config.indent: + del config.list_indices[indent] + + if config.list == config.ORDERED_LIST: + config.index = config.list_indices.get(config.indent, 1) + + config.list_indices[config.indent] = config.index + 1 + else: + config.index += 1 + + elif config.table: + config.index += 1 + if not config.list and not config.table: + raise SlashBackParserError(f"Unexpected \\{command.decode()}\\ token") + + else: + space_index = command.find(b" ") + first_command = command[:space_index] if space_index != -1 else command + info = command[space_index:].strip() if space_index != -1 else "" + + if first_command == b"image": + config.image = None if config.image else info + + elif first_command == b"url": + config.url = None if config.url else info + + elif first_command == b"code": + config.code = None if config.code else info if info else True + + elif first_command == b"mention": + config.mention = info + + elif first_command == b"reference": + config.reference = info + + elif first_command in (b"c", b"comment", b"ignore"): + config.ignore = not config.ignore + + elif first_command in (b"ic", b"icomment"): + config.comment = info + + else: + raise SlashBackParserError(f"Unknown command \"{first_command.decode()}\"") + + return config + + def parse(self, text): + if (text.count(b"\\") % 2): + raise SlashBackParserError("The amount of backslashes isn't even") + index = 0 + found = text.find(b"\\", index) + second_found = text.find(b"\\", found + 1) + + out = [] + + current_text = None + + current_config = TextConfig() + + while found != -1: + current_command = text[found + 1 : second_found] + + if not current_command: + out.append(Text(text[index : found + 1], TextConfig(current_config))) + else: + out.append(Text(text[index : found], TextConfig(current_config))) + current_config = self.parse_single(current_command, current_config) + + index = second_found + 1 + found = text.find(b"\\", index) + second_found = text.find(b"\\", found + 1) + + if (second_found == -1): + raise SlashBackParserError("Error while parsing. Inconsistent amount of backslashes") + + out.append(Text(text[index :], TextConfig(current_config))) + + return ParsedText(out) + +open = lambda path: SlashBackParser(path) + +if __name__ == "__main__": + print(__welcome__) + + has_processed_files = False + + if len(sys.argv) != 1: + print("") + for filename in sys.argv[1:]: + if filename[0] == "-": + print(f"Invalid option: '{filename}' (ignoring)", file=sys.stderr) + elif not os.path.exists(filename): + print(f"File not found: '{filename}' (ignoring)", file=sys.stderr) + else: + has_processed_files = True + out_filename = os.path.splitext(filename)[0] + ".md" + processing_string = f"Processing file {filename} and saving to {out_filename}..." + print(processing_string, end = "") + try: + sbf = open(filename) + sbf.write(out_filename) + print(f"\r{processing_string} Done.") + except SlashBackParserError as exception: + print(f"\nERROR: {exception!s}", file=sys.stderr) + except Exception as exception: + print("\nUNHANDLED EXCEPTION OCCURED!", file=sys.stderr) + traceback.print_exc() + + if not has_processed_files: + print("\n" + __usage__, file=sys.stderr) diff --git a/vs-project/generate_function_reference.py b/vs-project/generate_function_reference.py new file mode 100644 index 00000000..4374c6e7 --- /dev/null +++ b/vs-project/generate_function_reference.py @@ -0,0 +1,460 @@ +import glm +import re, os, SlashBack, sys, traceback + +builtin_function_or_method = type(glm.silence) + +HERE = os.path.dirname(__file__) + +TARGET_FOLDER = os.path.abspath(os.path.join(HERE, "../wiki/function-reference")) + +functions = [] + +func_common = ["abs", "sign", "floor", "trunc", "round", "roundEven", + "ceil", "fract", "mod", "min", "max", "fmin", + "fmax", "clamp", "mix", "step", "smoothstep", "isnan", + "isinf", "fma", "frexp", "ldexp", "floatBitsToInt", + "floatBitsToUint", "intBitsToFloat", "uintBitsToFloat", + "modf"] + +func_exponential = ["pow", "exp", "log", "exp2", "log2", "sqrt", "inversesqrt"] + +func_geometric = ["length", "distance", "dot", "cross", "normalize", "faceforward", "reflect", "refract"] + +func_integer = ["uaddCarry", "usubBorrow", "umulExtended", "imulExtended", + "bitfieldExtract", "bitfieldInsert", "bitfieldReverse", + "bitCount", "findLSB", "findMSB"] + +func_matrix = ["matrixCompMult", "outerProduct", "transpose", "determinant", "inverse"] + +func_packing = ["packDouble2x32", "packUnorm2x16", "packSnorm2x16", "packSnorm4x8", + "packUnorm4x8", "packHalf2x16", "unpackDouble2x32", "unpackUnorm2x16", + "unpackSnorm2x16", "unpackSnorm4x8", "unpackUnorm4x8", "unpackHalf2x16"] + +func_trigonometric = ["radians", "degrees", "sin", "cos", "tan", "asin", "acos", "atan", + "sinh", "cosh", "tanh", "asinh", "acosh", "atanh"] + +func_vector_relational = ["equal", "notEqual", "lessThan", "lessThanEqual", "greaterThan", + "greaterThanEqual", "any", "all", "not_"] + +detail = func_common + func_exponential + func_geometric + func_integer + func_matrix + \ + func_packing + func_trigonometric + func_vector_relational + +color_space = ["convertLinearToSRGB", "convertSRGBToLinear"] + +constants = ["epsilon", "zero", "one", "pi", "two_pi", "root_pi", + "half_pi", "three_over_two_pi", "quarter_pi", "one_over_pi", + "one_over_two_pi", "two_over_pi", "four_over_pi", + "two_over_root_pi", "one_over_root_two", "root_half_pi", + "root_two_pi", "root_ln_four", "e", "euler", "root_two", + "root_three", "root_five", "ln_two", "ln_ln_two", "ln_ten", "third", + "two_thirds", "golden_ratio"] + +epsilon = ["epsilonEqual", "epsilonNotEqual"] + +integer = ["iround", "uround"] + +matrix_access = ["row", "column"] + +matrix_clip_space = ["tweakedInfinitePerspective"] + \ + [x + y for y in ["", "LH", "RH", "NO", "ZO", "LH_ZO", "LH_NO", "RH_ZO", "RH_NO"] for x in ["ortho", "frustum", "perspective", "perspectiveFov"]] +\ + ["infinitePerspective" + y for y in ["", "LH", "RH"]] + +matrix_inverse = ["affineInverse", "inverseTranspose"] + +matrix_projection = ["project", "projectNO", "projectZO", "unProject", "unProjectNO", "unProjectZO", "pickMatrix"] + +matrix_transform = ["identity", "translate", "rotate", "rotate_slow", "scale", "scale_slow", "lookAt", + "lookAtRH", "lookAtLH"] + +noise = ["perlin", "simplex"] + +packing_pack_methods = ["pack" + x + y for x, z in [ + ("Int", ("2x8", "4x8", "4x16", "2x16", "2x32")), + ("Uint", ("2x8", "4x8", "4x16", "2x16", "2x32")), + ("Unorm", ("", "1x8", "2x8", "1x16", "4x16", "3x10_1x2", "2x4", "4x4", "1x5_1x6_1x5", "3x5_1x1", "2x3_1x2")), + ("Snorm", ("", "1x8", "2x8", "1x16", "4x16", "3x10_1x2")), + ("Half", ("", "1x16", "4x16")), + ("", ("I3x10_1x2", "U3x10_1x2", "F2x11_1x10", "F3x9_E1x5", "RGBM")), + ] for y in z] + +packing = [y + x for x in packing_pack_methods for y in ["", "un"]] + +quaternion = ["quatLookAt", "quatLookAtLH", "quatLookAtRH", "eulerAngles", "roll", "pitch", "yaw", "mat3_cast", + "mat4_cast", "quat_cast"] + +quaternion_common = ["lerp", "slerp", "conjugate"] + +quaternion_trigonometric = ["angle", "axis", "angleAxis"] + +random = ["linearRand", "gaussRand", "circularRand", "sphericalRand", "diskRand", "ballRand", "setSeed"] + +reciprocal = [f.format(x) for f in ("{}", "a{}", "{}h", "a{}h") for x in ("sec", "csc", "cot")] + +round = ["ceilPowerOfTwo", "floorPowerOfTwo", "roundPowerOfTwo", "ceilMultiple", "floorMultiple", + "roundMultiple"] + +type_ptr = ["value_ptr", "sizeof", "make_quat"] + [f + str(x) for x in range(2, 5) for f in ("make_vec", "make_mat")] +\ + ["make_mat{}x{}".format(x, y) for x in range(2,5) for y in range(2,5)] + +ulp = ["next_float", "prev_float", "float_distance"] + +decompose = ["decompose"] + +norm = ["distance2", "l1Norm", "l2Norm", "lMaxNorm", "length2", "lxNorm"] + +polar_coordinates = ["polar", "euclidean"] + +matrix_transform_2d = ["shearX", "shearY", "rotate", "translate", "scale"] + +rotate_vector = ["orientation", "rotate", "rotateX", "rotateY", "rotateZ", "slerp"] + +compatibility = ["lerp", "atan2", "isfinite", "saturate"] + +stable_extensions = matrix_clip_space + matrix_projection + matrix_transform + quaternion_common +\ + quaternion_trigonometric + +recommended_extensions = color_space + constants + epsilon + integer + matrix_access + matrix_inverse +\ + noise + packing + quaternion + random + reciprocal + round + type_ptr + ulp + +unstable_extensions = decompose + norm + polar_coordinates + matrix_transform_2d + rotate_vector + compatibility + +other_functions = ["silence", "add", "and_", "or_", "xor", "cmp", "div", "floordiv", "if_else", "inv", "lshift", "mul", "neg", "pos", "rshift", "sub", "quat_to_vec4", "vec4_to_quat"] + +known_functions = detail + recommended_extensions + stable_extensions + unstable_extensions + other_functions + +ignored_functions = ["test", "test_type_identification"] + +multiple_expected = ["rotate", "translate", "scale", "slerp", "lerp"] + +folders = {} + +for raw in dir(glm): + func = getattr(glm, raw) + if (raw.startswith("__") and raw.endswith("__") or not isinstance(func, builtin_function_or_method)): + continue + functions.append(raw) + +is_defined = lambda x: x in functions +is_known = lambda x: x in known_functions +is_ignored = lambda x: x in ignored_functions + +for known_func in known_functions: + if not is_defined(known_func): + print("A 'known' function was not defined: {}".format(known_func)) + + if known_func not in multiple_expected and known_functions.count(known_func) != 1: + print("Function '{}' is known multiple times".format(known_func)) + + +for function in functions: + if not is_known(function) and not is_ignored(function): + print("Function {} is not known".format(function)) + +FUNC_PATTERN = re.compile("(^\\w+)\\s*\\(([^)]*)\\)\\s*->\\s*(.+$)") + +TEMPLATE_PATTERN = re.compile("\\\\code\\\\([A-Z]) in \\[((:?\\w+,? ?)+)\\]\\\\code\\\\") + +class FunctionName: + def __init__(self, name): + self.name = name + + def __str__(self): + return "glm.**{}**".format(self.name) + +class Parameters: + def __init__(self, param_string): + self.param_string = param_string + + def __str__(self): + inner_out = [] + for param in self.param_string.split(","): + param = param.strip() + if not param: + continue + if ":" in param: + if param.count(":") != 1: + print("Invalid amount of ':': {}".format(self.param_string)) + else: + param, type_ = param.split(":") + inner_out.append("**{}**: *{}*".format(param, type_.strip())) + else: + inner_out.append("**{}**".format(param)) + + return "({})".format(", ".join(inner_out)) + +class ReturnValue: + def __init__(self, return_value): + self.return_value = return_value + + def __str__(self): + return " -\\\\> *{}*".format(self.return_value) + +class Description: + def __init__(self, descr): + self.descr = descr + + def __str__(self): + descr = self.descr.replace("\t", "\\raw\\  \\raw\\") + while 1: + match = TEMPLATE_PATTERN.search(descr) + if match: + descr = descr[:match.start()] + "\\raw\\***{}*** in [{}]\\raw\\".format(match.group(1), ", ".join(map(lambda x: "**{}**".format(x), match.group(2).split(", ")))) + descr[match.end():] + else: + break + return descr + + +def convert_doc_entry_to_sb(subdoc): + lines = subdoc.split("\n") + first_line = "" + rest_start = 0 + for line in lines: + first_line += line + rest_start += 1 + if "->" in line: + break + descr = Description("\n".join(lines[rest_start:])) + match = FUNC_PATTERN.fullmatch(first_line) + if match: + func_name = FunctionName(match.group(1)) + parameters = Parameters(match.group(2)) + return_val = ReturnValue(match.group(3)) + return "\\raw\\#### {}{}{}\\raw\\\n{}\n".format(str(func_name), str(parameters), str(return_val), str(descr)) + print("{} doesn't match the FUNC_PATTERN!".format(subdoc)) + return "" + +def convert_doc_to_sb(func): + doc = func.__doc__ + name = func.__name__ + if doc.count("`") % 2 != 0: + print ("{} doesn't have an even amount of backticks!".format(name)) + else: + doc = doc.replace("`", "\\code\\") + out = "\\h3\\{}() function\\h3\\\n".format(name) + lines = doc.split("\n") + current_subdoc = "" + for line in lines: + if not line.startswith("\t") and current_subdoc: + out += convert_doc_entry_to_sb(current_subdoc) + current_subdoc = "" + current_subdoc += line + "\n" + if current_subdoc.strip(): + out += convert_doc_entry_to_sb(current_subdoc) + return out + +def check_doc(func): + name = func.__name__ + doc = func.__doc__ + for line in doc.split("\n"): + if line.strip() and not line.startswith("\t") and not line.startswith(name) or len(line) > 100: + print("{} has invalid doc: \n{}\n".format(name, line)) + return False + return True + +def convert_sb_file(filename): + out_filename = os.path.splitext(filename)[0] + ".md" + try: + sbf = SlashBack.open(filename) + sbf.write(out_filename) + except SlashBack.SlashBackParserError as exception: + print(f"\nERROR: {exception!s}", file=sys.stderr) + except Exception as exception: + print("\nUNHANDLED EXCEPTION OCCURED!", file=sys.stderr) + traceback.print_exc() + +def generate_reference_for(name, function_names, description): + folder = "detail" if function_names[0] in detail else "stable_extensions" if function_names[0] in stable_extensions else \ + "recommended_extensions" if function_names[0] in recommended_extensions else "unstable_extensions" if function_names[0] in unstable_extensions else \ + "other" + + if not folder in folders: + folders[folder] = {} + + folders[folder][name] = function_names + + if not os.path.exists(TARGET_FOLDER + "/{}/".format(folder)): + os.mkdir(TARGET_FOLDER + "/{}/".format(folder)) + + file_name = TARGET_FOLDER + "/{}/{}.sb".format(folder, name) + + file = open(file_name, "w") + file.write("\\c\\This file was generated using a tool\\c\\\n") + file.write("\\h1\\{} methods\\h1\\\n".format(name)) + file.write("The following methods are all part of the \\b\\{} methods\\b\\.\n".format(name)) + file.write(description) + file.write("\n\\h2\\Table of contents\\h2\\\n") + file.write("\\ul\\\n") + + function_names.sort() + + for function_name in function_names: + file.write("\\-\\\\url #{}-function\\\\b\\{}\\b\\ function\\url\\\n".format(function_name.lower(), function_name)) + file.write("\\ul\\\n") + + for function_name in function_names: + if is_defined(function_name): + func = getattr(glm, function_name) + if check_doc(func): + file.write(convert_doc_to_sb(func)) + file.close() + convert_sb_file(file_name) + + +generate_reference_for("func_common", func_common, "It contains common GLSL functions.") + +generate_reference_for("func_exponential", func_exponential, "It contains exponential GLSL functions.") + +generate_reference_for("func_geometric", func_geometric, "These operate on vectors as vectors, not component-wise.") + +generate_reference_for("func_integer", func_integer, "It contains GLSL functions on integer types.") + +generate_reference_for("func_matrix", func_matrix, "It contains GLSL matrix functions.") + +generate_reference_for("func_packing", func_packing, "Provides GLSL functions to pack and unpack half, single"+\ + " and double-precision floating point values into more compact integer types.") + +generate_reference_for("func_trigonometric", func_trigonometric, + "Function parameters specified as angle are assumed to be in units of radians.") + +generate_reference_for("func_vector_relational", func_vector_relational, + "Relational vector functions.") + +generate_reference_for("color_space", color_space, "Allow to perform bit operations on integer values.") + +generate_reference_for("constants", constants, "Provide a list of constants and precomputed useful values.") + +generate_reference_for("epsilon", epsilon, "Comparison functions for a user defined epsilon values.") + +generate_reference_for("integer", integer, "Contains two different rounding methods.") + +generate_reference_for("matrix_access", matrix_access, + "Defines functions to access rows or columns of a matrix easily.") + +generate_reference_for("matrix_clip_space", matrix_clip_space, + "Defines functions that generate clip space transformation matrices.") + +generate_reference_for("matrix_inverse", matrix_inverse, + "Defines additional matrix inverting functions.") + +generate_reference_for("matrix_projection", matrix_projection, + "Functions that generate common projection transformation matrices.") + +generate_reference_for("matrix_transform", matrix_transform, + "Defines functions that generate common transformation matrices.") + +generate_reference_for("noise", noise, + "Defines 2D, 3D and 4D procedural noise functions Based on the work of Stefan Gustavson"+\ + " and Ashima Arts on \"webgl-noise\": \\raw\\https://github.com/ashima/webgl-noise\\raw\\ Following"+\ + " Stefan Gustavson's paper \"Simplex noise demystified\": "+\ + "\\raw\\http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf\\raw\\") + +generate_reference_for("packing", packing, + "This extension provides a set of function to convert vertors to packed formats.") + +generate_reference_for("quaternion", quaternion, + "Defines a templated quaternion type and several quaternion operations.") + +generate_reference_for("quaternion_common", quaternion_common, + "Provides common functions for quaternion types.") + +generate_reference_for("quaternion_trigonometric", quaternion_trigonometric, + "Provides trigonometric functions for quaternion types.") + +generate_reference_for("random", random, + "Generate random number from various distribution methods.") + +generate_reference_for("reciprocal", reciprocal, + "Define secant, cosecant and cotangent functions.") + +generate_reference_for("round", round, + "Rounding value to specific boundings.") + +generate_reference_for("type_ptr", type_ptr, + "Handles the interaction between pointers and vector, matrix types. "+\ + "This extension defines an overloaded function, glm.value_ptr. It "+\ + "returns a pointer to the memory layout of the object. Matrix types "+\ + "store their values in column-major order. This is useful for uploading "+\ + "data to matrices or copying data to buffer objects.") + +generate_reference_for("ulp", ulp, + "Allow the measurement of the accuracy of a function against a reference implementation. "+\ + "This extension works on floating-point data and provide results in ULP.") + +generate_reference_for("decompose", decompose, + "Decomposes a model matrix to translations, rotation and scale components.") + +generate_reference_for("norm", norm, + "Various ways to compute vector norms.") + +generate_reference_for("polar_coordinates", polar_coordinates, + "Conversion from Euclidean space to polar space and revert.") + +generate_reference_for("matrix_transform_2d", matrix_transform_2d, + "Defines functions that generate common 2d transformation matrices.") + +generate_reference_for("rotate_vector", rotate_vector, + "Function to directly rotate a vector.") + +generate_reference_for("compatibility", compatibility, + "Provide functions to increase the compatibility with Cg and HLSL languages.") + +generate_reference_for("other", other_functions, + "PyGLM's custom functions.") + +instructions_filename = TARGET_FOLDER + "/INSTRUCTIONS.sb" + +instructions_file = open(instructions_filename, "r") +instuctions = instructions_file.read() +instructions_file.close() + +toc_filename = TARGET_FOLDER + "/README.sb" + +toc_file = open(toc_filename, "w") +toc_file.write("{}\n".format(instuctions)) +toc_file.write("\\h1\\Table of Contents\\h1\\\n") +toc_file.write("\\ul\\\n") + +for folder in folders: + sub_toc_filename = TARGET_FOLDER + "/{}/README.sb".format(folder) + sub_toc_file = open(sub_toc_filename, "w") + sub_toc_file.write("\\h1\\Table of Contents\\h1\\\n") + sub_toc_file.write("\\ul\\\n") + toc_file.write("\\-\\ \\url {0}/README.md\\{0}\\url\\\n".format(folder)) + folder_content = folders[folder] + for functions_name in folder_content: + sub_toc_file.write("\\-\\ \\url {0}.md \\{0} methods\\ url\\\n".format(functions_name)) + toc_file.write("\\--\\ \\url {0}/{1}.md \\{1} methods\\ url\\\n".format(folder, functions_name)) + functions = folder_content[functions_name] + for function_name in functions: + sub_toc_file.write("\\--\\ \\url {0}.md#{1}-function \\\\b\\{1}\\b\\ function \\ url\\\n".format(functions_name, function_name)) + toc_file.write("\\---\\ \\url {0}/{1}.md#{2}-function \\\\b\\{2}\\b\\ function \\ url\\\n".format(folder, functions_name, function_name)) + + sub_toc_file.write("\\ul\\\n") + sub_toc_file.close() + convert_sb_file(sub_toc_filename) + +toc_file.write("\\ul\\\n") + +toc_file.close() + +convert_sb_file(toc_filename) + + + + + + + + + + + + + + + + + + + + diff --git a/wiki/function-reference/README.md b/wiki/function-reference/README.md index a9fac6cf..e9b890a7 100644 --- a/wiki/function-reference/README.md +++ b/wiki/function-reference/README.md @@ -429,8 +429,10 @@ This means that you can call the ``` glm.abs ``` function with a ``` float ``` ` * [**neg** function ](other/other.md#neg-function) * [**or\_** function ](other/other.md#or_-function) * [**pos** function ](other/other.md#pos-function) + * [**quat\_to\_vec4** function ](other/other.md#quat_to_vec4-function) * [**rshift** function ](other/other.md#rshift-function) * [**silence** function ](other/other.md#silence-function) * [**sub** function ](other/other.md#sub-function) + * [**vec4\_to\_quat** function ](other/other.md#vec4_to_quat-function) * [**xor** function ](other/other.md#xor-function) diff --git a/wiki/function-reference/README.sb b/wiki/function-reference/README.sb index a4bbe84c..654bfefa 100644 --- a/wiki/function-reference/README.sb +++ b/wiki/function-reference/README.sb @@ -426,8 +426,10 @@ This means that you can call the \code\glm.abs\code\ function with a \code\float \---\ \url other/other.md#neg-function \\b\neg\b\ function \ url\ \---\ \url other/other.md#or_-function \\b\or_\b\ function \ url\ \---\ \url other/other.md#pos-function \\b\pos\b\ function \ url\ +\---\ \url other/other.md#quat_to_vec4-function \\b\quat_to_vec4\b\ function \ url\ \---\ \url other/other.md#rshift-function \\b\rshift\b\ function \ url\ \---\ \url other/other.md#silence-function \\b\silence\b\ function \ url\ \---\ \url other/other.md#sub-function \\b\sub\b\ function \ url\ +\---\ \url other/other.md#vec4_to_quat-function \\b\vec4_to_quat\b\ function \ url\ \---\ \url other/other.md#xor-function \\b\xor\b\ function \ url\ \ul\ diff --git a/wiki/function-reference/detail/func_geometric.md b/wiki/function-reference/detail/func_geometric.md index b151815a..6f0d85e8 100644 --- a/wiki/function-reference/detail/func_geometric.md +++ b/wiki/function-reference/detail/func_geometric.md @@ -30,10 +30,10 @@ These operate on vectors as vectors, not component\-wise\.   Returns the distance between ``` p0 ``` and ``` p1 ```, i\.e\., ``` length(p0 - p1) ```\. ### dot\(\) function -#### glm.**dot**(**x**: *float*, **y**: *float*) -\> *float* +#### glm.**dot**(**x**: *number*, **y**: *number*) -\> *float*   Returns the dot product of ``` x ``` and ``` y ```, i\.e\., ``` result = x * y ```\. -#### glm.**dot**(**x**: *vecN*, **y**: *vecN*) -\> *float* +#### glm.**dot**(**x**: *vecN*, **y**: *vecN*) -\> *number*   Returns the dot product of ``` x ``` and ``` y ```, i\.e\., ``` result = x[0] * y[0] + x[1] * y[1] + ... ``` #### glm.**dot**(**x**: *quat*, **y**: *quat*) -\> *float* diff --git a/wiki/function-reference/detail/func_geometric.sb b/wiki/function-reference/detail/func_geometric.sb index ade62915..3a000bb5 100644 --- a/wiki/function-reference/detail/func_geometric.sb +++ b/wiki/function-reference/detail/func_geometric.sb @@ -28,10 +28,10 @@ These operate on vectors as vectors, not component-wise. \raw\  \raw\Returns the distance between \code\p0\code\ and \code\p1\code\, i.e., \code\length(p0 - p1)\code\. \h3\dot() function\h3\ -\raw\#### glm.**dot**(**x**: *float*, **y**: *float*) -\\> *float*\raw\ +\raw\#### glm.**dot**(**x**: *number*, **y**: *number*) -\\> *float*\raw\ \raw\  \raw\Returns the dot product of \code\x\code\ and \code\y\code\, i.e., \code\result = x * y\code\. -\raw\#### glm.**dot**(**x**: *vecN*, **y**: *vecN*) -\\> *float*\raw\ +\raw\#### glm.**dot**(**x**: *vecN*, **y**: *vecN*) -\\> *number*\raw\ \raw\  \raw\Returns the dot product of \code\x\code\ and \code\y\code\, i.e., \code\result = x[0] * y[0] + x[1] * y[1] + ...\code\ \raw\#### glm.**dot**(**x**: *quat*, **y**: *quat*) -\\> *float*\raw\ diff --git a/wiki/function-reference/other/README.md b/wiki/function-reference/other/README.md index a1759ba0..dccba353 100644 --- a/wiki/function-reference/other/README.md +++ b/wiki/function-reference/other/README.md @@ -15,8 +15,10 @@ * [**neg** function ](other.md#neg-function) * [**or\_** function ](other.md#or_-function) * [**pos** function ](other.md#pos-function) + * [**quat\_to\_vec4** function ](other.md#quat_to_vec4-function) * [**rshift** function ](other.md#rshift-function) * [**silence** function ](other.md#silence-function) * [**sub** function ](other.md#sub-function) + * [**vec4\_to\_quat** function ](other.md#vec4_to_quat-function) * [**xor** function ](other.md#xor-function) diff --git a/wiki/function-reference/other/README.sb b/wiki/function-reference/other/README.sb index 13301a5c..49a4b1ae 100644 --- a/wiki/function-reference/other/README.sb +++ b/wiki/function-reference/other/README.sb @@ -13,8 +13,10 @@ \--\ \url other.md#neg-function \\b\neg\b\ function \ url\ \--\ \url other.md#or_-function \\b\or_\b\ function \ url\ \--\ \url other.md#pos-function \\b\pos\b\ function \ url\ +\--\ \url other.md#quat_to_vec4-function \\b\quat_to_vec4\b\ function \ url\ \--\ \url other.md#rshift-function \\b\rshift\b\ function \ url\ \--\ \url other.md#silence-function \\b\silence\b\ function \ url\ \--\ \url other.md#sub-function \\b\sub\b\ function \ url\ +\--\ \url other.md#vec4_to_quat-function \\b\vec4_to_quat\b\ function \ url\ \--\ \url other.md#xor-function \\b\xor\b\ function \ url\ \ul\ diff --git a/wiki/function-reference/other/other.md b/wiki/function-reference/other/other.md index 4ae1782c..da0660e3 100644 --- a/wiki/function-reference/other/other.md +++ b/wiki/function-reference/other/other.md @@ -18,9 +18,11 @@ PyGLM's custom functions\. * [**neg** function](#neg-function) * [**or\_** function](#or_-function) * [**pos** function](#pos-function) +* [**quat\_to\_vec4** function](#quat_to_vec4-function) * [**rshift** function](#rshift-function) * [**silence** function](#silence-function) * [**sub** function](#sub-function) +* [**vec4\_to\_quat** function](#vec4_to_quat-function) * [**xor** function](#xor-function) ### add\(\) function @@ -71,6 +73,10 @@ PyGLM's custom functions\. #### glm.**pos**(**a**) -\> *Any*   Equivalent to ``` +a ```\. +### quat\_to\_vec4\(\) function +#### glm.**quat_to_vec4**(**quat**) -\> *vec4* +  Component wise conversion of quat to vec4\. + ### rshift\(\) function #### glm.**rshift**(**a**, **b**) -\> *Any*   Equivalent to ``` a >> b ```\. @@ -83,6 +89,10 @@ PyGLM's custom functions\. #### glm.**sub**(**a**, **b**) -\> *Any*   Equivalent to ``` a - b ```\. +### vec4\_to\_quat\(\) function +#### glm.**vec4_to_quat**(**vec4**) -\> *quat* +  Component wise conversion of vec4 to quat\. + ### xor\(\) function #### glm.**xor**(**a**, **b**) -\> *Any*   Equivalent to ``` a ^ b ```\. diff --git a/wiki/function-reference/other/other.sb b/wiki/function-reference/other/other.sb index 57555261..e081fdf2 100644 --- a/wiki/function-reference/other/other.sb +++ b/wiki/function-reference/other/other.sb @@ -16,9 +16,11 @@ PyGLM's custom functions. \-\\url #neg-function\\b\neg\b\ function\url\ \-\\url #or_-function\\b\or_\b\ function\url\ \-\\url #pos-function\\b\pos\b\ function\url\ +\-\\url #quat_to_vec4-function\\b\quat_to_vec4\b\ function\url\ \-\\url #rshift-function\\b\rshift\b\ function\url\ \-\\url #silence-function\\b\silence\b\ function\url\ \-\\url #sub-function\\b\sub\b\ function\url\ +\-\\url #vec4_to_quat-function\\b\vec4_to_quat\b\ function\url\ \-\\url #xor-function\\b\xor\b\ function\url\ \ul\ \h3\add() function\h3\ @@ -69,6 +71,10 @@ PyGLM's custom functions. \raw\#### glm.**pos**(**a**) -\\> *Any*\raw\ \raw\  \raw\Equivalent to \code\+a\code\. +\h3\quat_to_vec4() function\h3\ +\raw\#### glm.**quat_to_vec4**(**quat**) -\\> *vec4*\raw\ +\raw\  \raw\Component wise conversion of quat to vec4. + \h3\rshift() function\h3\ \raw\#### glm.**rshift**(**a**, **b**) -\\> *Any*\raw\ \raw\  \raw\Equivalent to \code\a >> b\code\. @@ -81,6 +87,10 @@ PyGLM's custom functions. \raw\#### glm.**sub**(**a**, **b**) -\\> *Any*\raw\ \raw\  \raw\Equivalent to \code\a - b\code\. +\h3\vec4_to_quat() function\h3\ +\raw\#### glm.**vec4_to_quat**(**vec4**) -\\> *quat*\raw\ +\raw\  \raw\Component wise conversion of vec4 to quat. + \h3\xor() function\h3\ \raw\#### glm.**xor**(**a**, **b**) -\\> *Any*\raw\ \raw\  \raw\Equivalent to \code\a ^ b\code\.