aboutsummaryrefslogtreecommitdiff
path: root/libs/dds_header
diff options
context:
space:
mode:
authorSulfurNitride <SulfurNitride@users.noreply.github.com>2026-02-11 02:37:39 -0600
committerSulfurNitride <SulfurNitride@users.noreply.github.com>2026-02-11 02:37:39 -0600
commit7ee008e150bc5bcf76082d726f719ee0fdfda982 (patch)
tree27fb39be241fdb5ac2734c574de678977d1856d0 /libs/dds_header
Fluorine Manager: full Linux port of Mod Organizer 2
Complete native Linux port with FUSE-based virtual filesystem, Proton/umu-run integration, and Flatpak packaging. Key features: - FUSE VFS replacing Windows USVFS (in-process + standalone helper for Flatpak) - Proton/GE-Proton/umu-run launcher with env var forwarding - Flatpak support (sandbox-aware VFS, NXM handler, umu-run) - Wine prefix management UI - Case-insensitive path resolution for Linux filesystems - QSettings-safe INI handling (avoids Bethesda INI corruption) - Portable instance support with auto-generated launcher scripts Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Diffstat (limited to 'libs/dds_header')
-rw-r--r--libs/dds_header/.editorconfig9
-rw-r--r--libs/dds_header/.gitignore109
-rw-r--r--libs/dds_header/.pre-commit-config.yaml15
-rw-r--r--libs/dds_header/CMakeLists.txt5
-rw-r--r--libs/dds_header/CMakePresets.json11
-rw-r--r--libs/dds_header/LICENSE674
-rw-r--r--libs/dds_header/README.md2
-rw-r--r--libs/dds_header/src/CMakeLists.txt6
-rw-r--r--libs/dds_header/src/DDS/DDSDefinitions.py808
-rw-r--r--libs/dds_header/src/DDS/DDSFile.py220
-rw-r--r--libs/dds_header/src/DDS/__init__.py0
-rw-r--r--libs/dds_header/src/DDS/glstuff.py205
-rw-r--r--libs/dds_header/src/DDSPreview.py528
-rw-r--r--libs/dds_header/src/DDSPreview_en.ts128
-rw-r--r--libs/dds_header/vcpkg.json15
15 files changed, 2735 insertions, 0 deletions
diff --git a/libs/dds_header/.editorconfig b/libs/dds_header/.editorconfig
new file mode 100644
index 0000000..f64592a
--- /dev/null
+++ b/libs/dds_header/.editorconfig
@@ -0,0 +1,9 @@
+root = true
+
+[*.py]
+indent_style = space
+indent_size = 4
+
+[{CMakeLists.txt, *.cmake}]
+indent_style = space
+indent_size = 4
diff --git a/libs/dds_header/.gitignore b/libs/dds_header/.gitignore
new file mode 100644
index 0000000..5afe969
--- /dev/null
+++ b/libs/dds_header/.gitignore
@@ -0,0 +1,109 @@
+# Mod Organizer Umbrella stuff
+/msbuild.log
+/*std*.log
+/*build
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
diff --git a/libs/dds_header/.pre-commit-config.yaml b/libs/dds_header/.pre-commit-config.yaml
new file mode 100644
index 0000000..4b7d480
--- /dev/null
+++ b/libs/dds_header/.pre-commit-config.yaml
@@ -0,0 +1,15 @@
+repos:
+ - repo: https://github.com/pre-commit/pre-commit-hooks
+ rev: v5.0.0
+ hooks:
+ - id: trailing-whitespace
+ - id: end-of-file-fixer
+ - id: check-merge-conflict
+ - id: check-case-conflict
+
+ci:
+ autofix_commit_msg: "[pre-commit.ci] Auto fixes from pre-commit.com hooks."
+ autofix_prs: true
+ autoupdate_commit_msg: "[pre-commit.ci] Pre-commit autoupdate."
+ autoupdate_schedule: quarterly
+ submodules: false
diff --git a/libs/dds_header/CMakeLists.txt b/libs/dds_header/CMakeLists.txt
new file mode 100644
index 0000000..a9ad8a8
--- /dev/null
+++ b/libs/dds_header/CMakeLists.txt
@@ -0,0 +1,5 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(DDSPreview LANGUAGES NONE)
+
+add_subdirectory(src)
diff --git a/libs/dds_header/CMakePresets.json b/libs/dds_header/CMakePresets.json
new file mode 100644
index 0000000..7726456
--- /dev/null
+++ b/libs/dds_header/CMakePresets.json
@@ -0,0 +1,11 @@
+{
+ "configurePresets": [
+ {
+ "binaryDir": "${sourceDir}/vsbuild",
+ "toolchainFile": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+ "generator": "Visual Studio 17 2022",
+ "name": "vs2022-windows"
+ }
+ ],
+ "version": 4
+}
diff --git a/libs/dds_header/LICENSE b/libs/dds_header/LICENSE
new file mode 100644
index 0000000..f288702
--- /dev/null
+++ b/libs/dds_header/LICENSE
@@ -0,0 +1,674 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ <program> Copyright (C) <year> <name of author>
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
diff --git a/libs/dds_header/README.md b/libs/dds_header/README.md
new file mode 100644
index 0000000..02ff9a7
--- /dev/null
+++ b/libs/dds_header/README.md
@@ -0,0 +1,2 @@
+# modorganizer-preview_dds
+DDS preview plugin for Mod Organizer 2.
diff --git a/libs/dds_header/src/CMakeLists.txt b/libs/dds_header/src/CMakeLists.txt
new file mode 100644
index 0000000..f4f0587
--- /dev/null
+++ b/libs/dds_header/src/CMakeLists.txt
@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.16)
+
+find_package(mo2-cmake CONFIG REQUIRED)
+
+add_custom_target(DDSPreview ALL)
+mo2_configure_python(DDSPreview SIMPLE)
diff --git a/libs/dds_header/src/DDS/DDSDefinitions.py b/libs/dds_header/src/DDS/DDSDefinitions.py
new file mode 100644
index 0000000..2d44812
--- /dev/null
+++ b/libs/dds_header/src/DDS/DDSDefinitions.py
@@ -0,0 +1,808 @@
+import dataclasses
+from enum import IntEnum, IntFlag, auto
+import struct
+from typing import ClassVar, List
+
+from .glstuff import GL_IMAGE_FORMAT, CompressedGLTextureFormat, UncompressedGLTextureFormat
+
+DDS_MAGIC_NUMBER = b"DDS " # b"\x20\x53\x44\x44"
+
+
+class IntEnumFromZero(IntEnum):
+ def _generate_next_value_(name, start, count, last_values):
+ return count
+
+
+class D3D10_RESOURCE_DIMENSION(IntEnumFromZero):
+ D3D10_RESOURCE_DIMENSION_UNKNOWN = auto()
+ D3D10_RESOURCE_DIMENSION_BUFFER = auto()
+ D3D10_RESOURCE_DIMENSION_TEXTURE1D = auto()
+ D3D10_RESOURCE_DIMENSION_TEXTURE2D = auto()
+ D3D10_RESOURCE_DIMENSION_TEXTURE3D = auto()
+
+
+class DXGI_FORMAT(IntEnumFromZero):
+ DXGI_FORMAT_UNKNOWN = auto()
+ DXGI_FORMAT_R32G32B32A32_TYPELESS = auto()
+ DXGI_FORMAT_R32G32B32A32_FLOAT = auto()
+ DXGI_FORMAT_R32G32B32A32_UINT = auto()
+ DXGI_FORMAT_R32G32B32A32_SINT = auto()
+ DXGI_FORMAT_R32G32B32_TYPELESS = auto()
+ DXGI_FORMAT_R32G32B32_FLOAT = auto()
+ DXGI_FORMAT_R32G32B32_UINT = auto()
+ DXGI_FORMAT_R32G32B32_SINT = auto()
+ DXGI_FORMAT_R16G16B16A16_TYPELESS = auto()
+ DXGI_FORMAT_R16G16B16A16_FLOAT = auto()
+ DXGI_FORMAT_R16G16B16A16_UNORM = auto()
+ DXGI_FORMAT_R16G16B16A16_UINT = auto()
+ DXGI_FORMAT_R16G16B16A16_SNORM = auto()
+ DXGI_FORMAT_R16G16B16A16_SINT = auto()
+ DXGI_FORMAT_R32G32_TYPELESS = auto()
+ DXGI_FORMAT_R32G32_FLOAT = auto()
+ DXGI_FORMAT_R32G32_UINT = auto()
+ DXGI_FORMAT_R32G32_SINT = auto()
+ DXGI_FORMAT_R32G8X24_TYPELESS = auto()
+ DXGI_FORMAT_D32_FLOAT_S8X24_UINT = auto()
+ DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = auto()
+ DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = auto()
+ DXGI_FORMAT_R10G10B10A2_TYPELESS = auto()
+ DXGI_FORMAT_R10G10B10A2_UNORM = auto()
+ DXGI_FORMAT_R10G10B10A2_UINT = auto()
+ DXGI_FORMAT_R11G11B10_FLOAT = auto()
+ DXGI_FORMAT_R8G8B8A8_TYPELESS = auto()
+ DXGI_FORMAT_R8G8B8A8_UNORM = auto()
+ DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = auto()
+ DXGI_FORMAT_R8G8B8A8_UINT = auto()
+ DXGI_FORMAT_R8G8B8A8_SNORM = auto()
+ DXGI_FORMAT_R8G8B8A8_SINT = auto()
+ DXGI_FORMAT_R16G16_TYPELESS = auto()
+ DXGI_FORMAT_R16G16_FLOAT = auto()
+ DXGI_FORMAT_R16G16_UNORM = auto()
+ DXGI_FORMAT_R16G16_UINT = auto()
+ DXGI_FORMAT_R16G16_SNORM = auto()
+ DXGI_FORMAT_R16G16_SINT = auto()
+ DXGI_FORMAT_R32_TYPELESS = auto()
+ DXGI_FORMAT_D32_FLOAT = auto()
+ DXGI_FORMAT_R32_FLOAT = auto()
+ DXGI_FORMAT_R32_UINT = auto()
+ DXGI_FORMAT_R32_SINT = auto()
+ DXGI_FORMAT_R24G8_TYPELESS = auto()
+ DXGI_FORMAT_D24_UNORM_S8_UINT = auto()
+ DXGI_FORMAT_R24_UNORM_X8_TYPELESS = auto()
+ DXGI_FORMAT_X24_TYPELESS_G8_UINT = auto()
+ DXGI_FORMAT_R8G8_TYPELESS = auto()
+ DXGI_FORMAT_R8G8_UNORM = auto()
+ DXGI_FORMAT_R8G8_UINT = auto()
+ DXGI_FORMAT_R8G8_SNORM = auto()
+ DXGI_FORMAT_R8G8_SINT = auto()
+ DXGI_FORMAT_R16_TYPELESS = auto()
+ DXGI_FORMAT_R16_FLOAT = auto()
+ DXGI_FORMAT_D16_UNORM = auto()
+ DXGI_FORMAT_R16_UNORM = auto()
+ DXGI_FORMAT_R16_UINT = auto()
+ DXGI_FORMAT_R16_SNORM = auto()
+ DXGI_FORMAT_R16_SINT = auto()
+ DXGI_FORMAT_R8_TYPELESS = auto()
+ DXGI_FORMAT_R8_UNORM = auto()
+ DXGI_FORMAT_R8_UINT = auto()
+ DXGI_FORMAT_R8_SNORM = auto()
+ DXGI_FORMAT_R8_SINT = auto()
+ DXGI_FORMAT_A8_UNORM = auto()
+ DXGI_FORMAT_R1_UNORM = auto()
+ DXGI_FORMAT_R9G9B9E5_SHAREDEXP = auto()
+ DXGI_FORMAT_R8G8_B8G8_UNORM = auto()
+ DXGI_FORMAT_G8R8_G8B8_UNORM = auto()
+ DXGI_FORMAT_BC1_TYPELESS = auto()
+ DXGI_FORMAT_BC1_UNORM = auto()
+ DXGI_FORMAT_BC1_UNORM_SRGB = auto()
+ DXGI_FORMAT_BC2_TYPELESS = auto()
+ DXGI_FORMAT_BC2_UNORM = auto()
+ DXGI_FORMAT_BC2_UNORM_SRGB = auto()
+ DXGI_FORMAT_BC3_TYPELESS = auto()
+ DXGI_FORMAT_BC3_UNORM = auto()
+ DXGI_FORMAT_BC3_UNORM_SRGB = auto()
+ DXGI_FORMAT_BC4_TYPELESS = auto()
+ DXGI_FORMAT_BC4_UNORM = auto()
+ DXGI_FORMAT_BC4_SNORM = auto()
+ DXGI_FORMAT_BC5_TYPELESS = auto()
+ DXGI_FORMAT_BC5_UNORM = auto()
+ DXGI_FORMAT_BC5_SNORM = auto()
+ DXGI_FORMAT_B5G6R5_UNORM = auto()
+ DXGI_FORMAT_B5G5R5A1_UNORM = auto()
+ DXGI_FORMAT_B8G8R8A8_UNORM = auto()
+ DXGI_FORMAT_B8G8R8X8_UNORM = auto()
+ DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = auto()
+ DXGI_FORMAT_B8G8R8A8_TYPELESS = auto()
+ DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = auto()
+ DXGI_FORMAT_B8G8R8X8_TYPELESS = auto()
+ DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = auto()
+ DXGI_FORMAT_BC6H_TYPELESS = auto()
+ DXGI_FORMAT_BC6H_UF16 = auto()
+ DXGI_FORMAT_BC6H_SF16 = auto()
+ DXGI_FORMAT_BC7_TYPELESS = auto()
+ DXGI_FORMAT_BC7_UNORM = auto()
+ DXGI_FORMAT_BC7_UNORM_SRGB = auto()
+ DXGI_FORMAT_AYUV = auto()
+ DXGI_FORMAT_Y410 = auto()
+ DXGI_FORMAT_Y416 = auto()
+ DXGI_FORMAT_NV12 = auto()
+ DXGI_FORMAT_P010 = auto()
+ DXGI_FORMAT_P016 = auto()
+ DXGI_FORMAT_420_OPAQUE = auto()
+ DXGI_FORMAT_YUY2 = auto()
+ DXGI_FORMAT_Y210 = auto()
+ DXGI_FORMAT_Y216 = auto()
+ DXGI_FORMAT_NV11 = auto()
+ DXGI_FORMAT_AI44 = auto()
+ DXGI_FORMAT_IA44 = auto()
+ DXGI_FORMAT_P8 = auto()
+ DXGI_FORMAT_A8P8 = auto()
+ DXGI_FORMAT_B4G4R4A4_UNORM = auto()
+ DXGI_FORMAT_P208 = auto()
+ DXGI_FORMAT_V208 = auto()
+ DXGI_FORMAT_V408 = auto()
+ DXGI_FORMAT_FORCE_UINT = auto()
+
+
+def DataclassFromBytes(dataclass):
+ class LoadableDataclass(dataclass):
+ def __init__(self, bytes=None):
+ super(LoadableDataclass, self).__init__()
+ if bytes:
+ self.fromBytes(bytes)
+
+ def fromStream(self, byteStream):
+ self.fromBytes(byteStream.read(struct.calcsize(self.structFormat)))
+
+ def fromBytes(self, bytes):
+ loaded = struct.unpack(self.structFormat, bytes)
+ fields = dataclasses.fields(self)
+ memberIndex = 0
+ for field in fields:
+ if field.metadata and "count" in field.metadata:
+ # We have a list
+ listed = field.type.__args__[0]
+ myList = []
+ for i in range(field.metadata["count"]):
+ myList.append(listed(loaded[memberIndex]))
+ memberIndex += 1
+ self.__dict__[field.name] = myList
+ else:
+ self.__dict__[field.name] = field.type(loaded[memberIndex])
+ memberIndex += 1
+
+ return LoadableDataclass
+
+
+@DataclassFromBytes
+@dataclasses.dataclass
+class DDS_PIXELFORMAT:
+ structFormat: ClassVar[str] = "<II4sI4s4s4s4s"
+
+ class Flags(IntFlag):
+ DDPF_ALPHAPIXELS = 0x1
+ DDPF_ALPHA = 0x2
+ DDPF_FOURCC = 0x4
+ DDPF_RGB = 0x40
+ DDPF_YUV = 0x200
+ DDPF_LUMINANCE = 0x20000
+
+ dwSize: int = 0
+ dwFlags: Flags = 0
+ dwFourCC: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
+ dwRGBBitCount: int = 0
+ dwRBitMask: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
+ dwGBitMask: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
+ dwBBitMask: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
+ dwABitMask: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
+
+
+@DataclassFromBytes
+@dataclasses.dataclass
+class DDS_HEADER:
+ structFormat: ClassVar[str] = "<IIIIIII IIIIIIIIIII 32s IIIII"
+
+ class Flags(IntFlag):
+ DDSD_CAPS = 0x1
+ DDSD_HEIGHT = 0x2
+ DDSD_WIDTH = 0x4
+ DDSD_PITCH = 0x8
+ DDSD_PIXELFORMAT = 0x1000
+ DDSD_MIPMAPCOUNT = 0x20000
+ DDSD_LINEARSIZE = 0x80000
+ DDSD_DEPTH = 0x800000
+
+ class Caps(IntFlag):
+ DDSCAPS_COMPLEX = 0x8
+ DDSCAPS_MIPMAP = 0x400000
+ DDSCAPS_TEXTURE = 0x1000
+
+ class Caps2(IntFlag):
+ DDSCAPS2_CUBEMAP = 0x200
+ DDSCAPS2_CUBEMAP_POSITIVEX = 0x400
+ DDSCAPS2_CUBEMAP_NEGATIVEX = 0x800
+ DDSCAPS2_CUBEMAP_POSITIVEY = 0x1000
+ DDSCAPS2_CUBEMAP_NEGATIVEY = 0x2000
+ DDSCAPS2_CUBEMAP_POSITIVEZ = 0x4000
+ DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x8000
+ DDSCAPS2_VOLUME = 0x200000
+
+ dwSize: int = 0
+ dwFlags: Flags = 0
+ dwHeight: int = 0
+ dwWidth: int = 0
+ dwPitchOrLinearSize: int = 0
+ dwDepth: int = 0
+ dwMipMapCount: int = 0
+ dwReserved1: List[int] = dataclasses.field(default_factory=lambda: [0] * 11, metadata={"count": 11})
+ ddspf: DDS_PIXELFORMAT = dataclasses.field(default_factory=DDS_PIXELFORMAT)
+ dwCaps: Caps = 0
+ dwCaps2: Caps2 = 0
+ dwCaps3: int = 0
+ dwCaps4: int = 0
+ dwReserved2: int = 0
+
+
+@DataclassFromBytes
+@dataclasses.dataclass
+class DDS_HEADER_DXT10:
+ structFormat: ClassVar[str] = "<IIIII"
+
+ class MiscFlag(IntFlag):
+ DDS_RESOURCE_MISC_TEXTURECUBE = 0x4
+
+ class MiscFlags2(IntFlag):
+ DDS_ALPHA_MODE_UNKNOWN = 0x0
+ DDS_ALPHA_MODE_STRAIGHT = 0x1
+ DDS_ALPHA_MODE_PREMULTIPLIED = 0x2
+ DDS_ALPHA_MODE_OPAQUE = 0x3
+ DDS_ALPHA_MODE_CUSTOM = 0x4
+
+ dxgiFormat: DXGI_FORMAT = 0
+ resourceDimension: D3D10_RESOURCE_DIMENSION = 0
+ miscFlag: MiscFlag = 0
+ arraySize: int = 0
+ miscFlags2: MiscFlags2 = 0
+
+
+class UnsupportedDDSFormatException(Exception):
+ """Thrown when an unsupported DDS format or broken DDS file is given"""
+ pass
+
+
+def fourCCToDXGI(fourCC):
+ converter = {
+ b"DXT1": DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM,
+ b"DXT3": DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM,
+ b"DXT5": DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM,
+ b"BC4U": DXGI_FORMAT.DXGI_FORMAT_BC4_UNORM,
+ b"BC4S": DXGI_FORMAT.DXGI_FORMAT_BC4_SNORM,
+ b"ATI2": DXGI_FORMAT.DXGI_FORMAT_BC5_UNORM,
+ b"BC5U": DXGI_FORMAT.DXGI_FORMAT_BC5_UNORM,
+ b"BC5S": DXGI_FORMAT.DXGI_FORMAT_BC5_SNORM,
+ b"RGBG": DXGI_FORMAT.DXGI_FORMAT_R8G8_B8G8_UNORM,
+ b"GRGB": DXGI_FORMAT.DXGI_FORMAT_G8R8_G8B8_UNORM,
+ (36).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_UNORM,
+ (110).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_SNORM,
+ (111).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16_FLOAT,
+ (112).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16G16_FLOAT,
+ (113).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_FLOAT,
+ (114).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R32_FLOAT,
+ (115).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R32G32_FLOAT,
+ (116).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_FLOAT
+ # Note: Some formats with a four character code don't have a DXGI format, e.g. pre-multiplied BC2/3 images
+ }
+ if fourCC in converter:
+ return converter[fourCC]
+
+
+dxgiToGL = {
+ DXGI_FORMAT.DXGI_FORMAT_UNKNOWN: None,
+ DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_FLOAT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA32F,
+ GL_IMAGE_FORMAT.GL_RGBA,
+ GL_IMAGE_FORMAT.GL_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA32UI,
+ GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_INT),
+ DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA32I,
+ GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
+ GL_IMAGE_FORMAT.GL_INT),
+ DXGI_FORMAT.DXGI_FORMAT_R32G32B32_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R32G32B32_FLOAT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB32F,
+ GL_IMAGE_FORMAT.GL_RGB,
+ GL_IMAGE_FORMAT.GL_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_R32G32B32_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB32UI,
+ GL_IMAGE_FORMAT.GL_RGB_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_INT),
+ DXGI_FORMAT.DXGI_FORMAT_R32G32B32_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB32I,
+ GL_IMAGE_FORMAT.GL_RGB_INTEGER,
+ GL_IMAGE_FORMAT.GL_INT),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_FLOAT: UncompressedGLTextureFormat(((3, 0), [b"GL_ARB_half_float_pixel"]),
+ GL_IMAGE_FORMAT.GL_RGBA16F,
+ GL_IMAGE_FORMAT.GL_RGBA,
+ GL_IMAGE_FORMAT.GL_HALF_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA16,
+ GL_IMAGE_FORMAT.GL_RGBA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA16UI,
+ GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA16_SNORM,
+ GL_IMAGE_FORMAT.GL_RGBA,
+ GL_IMAGE_FORMAT.GL_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA16I,
+ GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
+ GL_IMAGE_FORMAT.GL_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R32G32_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R32G32_FLOAT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG32F,
+ GL_IMAGE_FORMAT.GL_RG, GL_IMAGE_FORMAT.GL_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_R32G32_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG32UI,
+ GL_IMAGE_FORMAT.GL_RG_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_INT),
+ DXGI_FORMAT.DXGI_FORMAT_R32G32_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG32I,
+ GL_IMAGE_FORMAT.GL_RG, GL_IMAGE_FORMAT.GL_INT),
+ DXGI_FORMAT.DXGI_FORMAT_R32G8X24_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_D32_FLOAT_S8X24_UINT: None,
+ DXGI_FORMAT.DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R32F,
+ GL_IMAGE_FORMAT.GL_RG,
+ GL_IMAGE_FORMAT.GL_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_X32_TYPELESS_G8X24_UINT: None,
+ DXGI_FORMAT.DXGI_FORMAT_R10G10B10A2_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R10G10B10A2_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB10_A2,
+ GL_IMAGE_FORMAT.GL_RGBA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_INT_2_10_10_10_REV),
+ DXGI_FORMAT.DXGI_FORMAT_R10G10B10A2_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB10_A2UI,
+ GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_INT_2_10_10_10_REV),
+ DXGI_FORMAT.DXGI_FORMAT_R11G11B10_FLOAT: UncompressedGLTextureFormat(((-1, 0), [b"EXT_packed_float"]),
+ GL_IMAGE_FORMAT.GL_R11F_G11F_B10F,
+ GL_IMAGE_FORMAT.GL_RGB,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_INT_10F_11F_11F_REV_EXT),
+ DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8,
+ GL_IMAGE_FORMAT.GL_RGBA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: UncompressedGLTextureFormat(((2, 1), [b"GL_EXT_texture_sRGB"]),
+ GL_IMAGE_FORMAT.GL_SRGB8_ALPHA8,
+ GL_IMAGE_FORMAT.GL_RGBA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8UI,
+ GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8_SNORM,
+ GL_IMAGE_FORMAT.GL_RGBA,
+ GL_IMAGE_FORMAT.GL_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8I,
+ GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
+ GL_IMAGE_FORMAT.GL_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R16G16_FLOAT: UncompressedGLTextureFormat(((3, 0), [b"GL_ARB_half_float_pixel"]),
+ GL_IMAGE_FORMAT.GL_RG16F, GL_IMAGE_FORMAT.GL_RG,
+ GL_IMAGE_FORMAT.GL_HALF_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG16,
+ GL_IMAGE_FORMAT.GL_RG,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG16UI,
+ GL_IMAGE_FORMAT.GL_RG_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG16_SNORM,
+ GL_IMAGE_FORMAT.GL_RG, GL_IMAGE_FORMAT.GL_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R16G16_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG16I,
+ GL_IMAGE_FORMAT.GL_RG_INTEGER,
+ GL_IMAGE_FORMAT.GL_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R32_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_D32_FLOAT: None,
+ DXGI_FORMAT.DXGI_FORMAT_R32_FLOAT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R32F,
+ GL_IMAGE_FORMAT.GL_RED, GL_IMAGE_FORMAT.GL_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_R32_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R32UI,
+ GL_IMAGE_FORMAT.GL_RED_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_INT),
+ DXGI_FORMAT.DXGI_FORMAT_R32_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R32I,
+ GL_IMAGE_FORMAT.GL_RED_INTEGER,
+ GL_IMAGE_FORMAT.GL_INT),
+ DXGI_FORMAT.DXGI_FORMAT_R24G8_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_D24_UNORM_S8_UINT: None,
+ DXGI_FORMAT.DXGI_FORMAT_R24_UNORM_X8_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_X24_TYPELESS_G8_UINT: None,
+ DXGI_FORMAT.DXGI_FORMAT_R8G8_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R8G8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG8, GL_IMAGE_FORMAT.GL_RG,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8G8_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG8UI,
+ GL_IMAGE_FORMAT.GL_RG_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8G8_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG8_SNORM,
+ GL_IMAGE_FORMAT.GL_RG, GL_IMAGE_FORMAT.GL_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8G8_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG8I,
+ GL_IMAGE_FORMAT.GL_RG_INTEGER,
+ GL_IMAGE_FORMAT.GL_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R16_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R16_FLOAT: UncompressedGLTextureFormat(((3, 0), [b"GL_ARB_half_float_pixel"]),
+ GL_IMAGE_FORMAT.GL_R16F, GL_IMAGE_FORMAT.GL_RED,
+ GL_IMAGE_FORMAT.GL_HALF_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_D16_UNORM: None,
+ DXGI_FORMAT.DXGI_FORMAT_R16_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R16, GL_IMAGE_FORMAT.GL_RED,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R16_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R16UI,
+ GL_IMAGE_FORMAT.GL_RED_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R16_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R16_SNORM,
+ GL_IMAGE_FORMAT.GL_RED, GL_IMAGE_FORMAT.GL_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R16_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R16I,
+ GL_IMAGE_FORMAT.GL_RED_INTEGER,
+ GL_IMAGE_FORMAT.GL_SHORT),
+ DXGI_FORMAT.DXGI_FORMAT_R8_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_R8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R8, GL_IMAGE_FORMAT.GL_RED,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R8UI,
+ GL_IMAGE_FORMAT.GL_RED_INTEGER,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R8_SNORM,
+ GL_IMAGE_FORMAT.GL_RED, GL_IMAGE_FORMAT.GL_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R8_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R8I,
+ GL_IMAGE_FORMAT.GL_RED_INTEGER,
+ GL_IMAGE_FORMAT.GL_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_A8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_ALPHA8,
+ GL_IMAGE_FORMAT.GL_ALPHA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R1_UNORM: None,
+ DXGI_FORMAT.DXGI_FORMAT_R9G9B9E5_SHAREDEXP: UncompressedGLTextureFormat(
+ ((3, 0), [b"GL_EXT_texture_shared_exponent"]), GL_IMAGE_FORMAT.GL_RGB9_E5, GL_IMAGE_FORMAT.GL_RGB,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_INT_5_9_9_9_REV_EXT),
+ DXGI_FORMAT.DXGI_FORMAT_R8G8_B8G8_UNORM: None,
+ DXGI_FORMAT.DXGI_FORMAT_G8R8_G8B8_UNORM: None,
+ DXGI_FORMAT.DXGI_FORMAT_BC1_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT),
+ DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM_SRGB: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT),
+ DXGI_FORMAT.DXGI_FORMAT_BC2_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT),
+ DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM_SRGB: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT),
+ DXGI_FORMAT.DXGI_FORMAT_BC3_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT),
+ DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM_SRGB: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT),
+ DXGI_FORMAT.DXGI_FORMAT_BC4_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_BC4_UNORM: CompressedGLTextureFormat(((3, 0), [b"GL_ARB_texture_compression_rgtc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_RED_RGTC1),
+ DXGI_FORMAT.DXGI_FORMAT_BC4_SNORM: CompressedGLTextureFormat(((3, 0), [b"GL_ARB_texture_compression_rgtc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_SIGNED_RED_RGTC1),
+ DXGI_FORMAT.DXGI_FORMAT_BC5_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_BC5_UNORM: CompressedGLTextureFormat(((3, 0), [b"GL_ARB_texture_compression_rgtc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_RG_RGTC2),
+ DXGI_FORMAT.DXGI_FORMAT_BC5_SNORM: CompressedGLTextureFormat(((3, 0), [b"GL_ARB_texture_compression_rgtc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_SIGNED_RG_RGTC2),
+ DXGI_FORMAT.DXGI_FORMAT_B5G6R5_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB,
+ GL_IMAGE_FORMAT.GL_RGB,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT_5_6_5_REV),
+ DXGI_FORMAT.DXGI_FORMAT_B5G5R5A1_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB5_A1,
+ GL_IMAGE_FORMAT.GL_BGRA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT_1_5_5_5_REV),
+ DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8,
+ GL_IMAGE_FORMAT.GL_BGRA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_B8G8R8X8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB8,
+ GL_IMAGE_FORMAT.GL_BGRA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM: None,
+ DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: UncompressedGLTextureFormat(((2, 1), [b"GL_EXT_texture_sRGB"]),
+ GL_IMAGE_FORMAT.GL_SRGB8_ALPHA8,
+ GL_IMAGE_FORMAT.GL_BGRA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_B8G8R8X8_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: UncompressedGLTextureFormat(((2, 1), [b"GL_EXT_texture_sRGB"]),
+ GL_IMAGE_FORMAT.GL_SRGB8,
+ GL_IMAGE_FORMAT.GL_BGRA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
+ DXGI_FORMAT.DXGI_FORMAT_BC6H_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_BC6H_UF16: CompressedGLTextureFormat(((4, 2), [b"GL_ARB_texture_compression_bptc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_BC6H_SF16: CompressedGLTextureFormat(((4, 2), [b"GL_ARB_texture_compression_bptc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT),
+ DXGI_FORMAT.DXGI_FORMAT_BC7_TYPELESS: None,
+ DXGI_FORMAT.DXGI_FORMAT_BC7_UNORM: CompressedGLTextureFormat(((4, 2), [b"GL_ARB_texture_compression_bptc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_RGBA_BPTC_UNORM),
+ DXGI_FORMAT.DXGI_FORMAT_BC7_UNORM_SRGB: CompressedGLTextureFormat(((4, 2), [b"GL_ARB_texture_compression_bptc"]),
+ GL_IMAGE_FORMAT.GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM),
+ DXGI_FORMAT.DXGI_FORMAT_AYUV: None,
+ DXGI_FORMAT.DXGI_FORMAT_Y410: None,
+ DXGI_FORMAT.DXGI_FORMAT_Y416: None,
+ DXGI_FORMAT.DXGI_FORMAT_NV12: None,
+ DXGI_FORMAT.DXGI_FORMAT_P010: None,
+ DXGI_FORMAT.DXGI_FORMAT_P016: None,
+ DXGI_FORMAT.DXGI_FORMAT_420_OPAQUE: None,
+ DXGI_FORMAT.DXGI_FORMAT_YUY2: None,
+ DXGI_FORMAT.DXGI_FORMAT_Y210: None,
+ DXGI_FORMAT.DXGI_FORMAT_Y216: None,
+ DXGI_FORMAT.DXGI_FORMAT_NV11: None,
+ DXGI_FORMAT.DXGI_FORMAT_AI44: None,
+ DXGI_FORMAT.DXGI_FORMAT_IA44: None,
+ DXGI_FORMAT.DXGI_FORMAT_P8: None,
+ DXGI_FORMAT.DXGI_FORMAT_A8P8: None,
+ DXGI_FORMAT.DXGI_FORMAT_B4G4R4A4_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA4,
+ GL_IMAGE_FORMAT.GL_BGRA,
+ GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT_4_4_4_4_REV),
+ DXGI_FORMAT.DXGI_FORMAT_P208: None,
+ DXGI_FORMAT.DXGI_FORMAT_V208: None,
+ DXGI_FORMAT.DXGI_FORMAT_V408: None,
+ DXGI_FORMAT.DXGI_FORMAT_FORCE_UINT: None
+}
+
+
+def buildConverter(byteCount, usedBitCounts={8}, bitmasks=None, intmasks=None):
+ # A converter converts the data to boring BGRA with enough bits per channel to fit the original
+ glFormat = GL_IMAGE_FORMAT.GL_BGRA
+ biggestComponent = max(usedBitCounts)
+ biggestComponent = (biggestComponent + 7) // 8
+ if biggestComponent == 1:
+ packFormat = "=4B"
+ glType = GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE
+ glInternalFormat = GL_IMAGE_FORMAT.GL_RGBA8
+ elif biggestComponent == 2:
+ packFormat = "=4H"
+ glType = GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT
+ glInternalFormat = GL_IMAGE_FORMAT.GL_RGBA16
+ elif biggestComponent <= 4:
+ biggestComponent == 4
+ packFormat = "=4I"
+ glType = GL_IMAGE_FORMAT.GL_UNSIGNED_INT
+ glInternalFormat = GL_IMAGE_FORMAT.GL_RGBA32F
+ multiplier = 255 ** biggestComponent
+
+ if byteCount == 1:
+ unpackFormat = "B"
+ unpackCombiner = lambda x: x
+ elif byteCount == 2:
+ unpackFormat = "H"
+ unpackCombiner = lambda x: x
+ elif byteCount == 3:
+ unpackFormat = "3s"
+
+ def unpackCombiner(x):
+ x = struct.unpack("<HB", x)
+ return x[0] + (x[1] << 16)
+ elif byteCount == 4:
+ unpackFormat = "I"
+ unpackCombiner = lambda x: x
+
+ if intmasks:
+ rIntMask, gIntMask, bIntMask, aIntMask = intmasks
+ else:
+ rIntMask = 0
+ gIntMask = 0
+ bIntMask = 0
+ aIntMask = 0
+
+ if bitmasks:
+ if "r" in bitmasks:
+ rIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["r"][:byteCount]))
+ if "g" in bitmasks:
+ gIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["g"][:byteCount]))
+ if "b" in bitmasks:
+ bIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["b"][:byteCount]))
+ if "a" in bitmasks:
+ aIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["a"][:byteCount]))
+ if "luminance" in bitmasks:
+ rIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["luminance"][:byteCount]))
+ gIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["luminance"][:byteCount]))
+ bIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["luminance"][:byteCount]))
+
+ rDivisor = 2 ** bin(rIntMask).count("1") - 1
+ gDivisor = 2 ** bin(gIntMask).count("1") - 1
+ bDivisor = 2 ** bin(bIntMask).count("1") - 1
+ aDivisor = 2 ** bin(aIntMask).count("1") - 1
+
+ rShift = (rIntMask & -rIntMask).bit_length() - 1
+ gShift = (gIntMask & -gIntMask).bit_length() - 1
+ bShift = (bIntMask & -bIntMask).bit_length() - 1
+ aShift = (aIntMask & -aIntMask).bit_length() - 1
+
+ def convert(imageData):
+ length = len(imageData) // byteCount
+ unpackString = "<" + ((str(length) + unpackFormat) if unpackFormat.isalpha() else unpackFormat * length)
+ unpacked = struct.unpack(unpackString, imageData)
+ repacked = bytearray(length * biggestComponent * 4)
+ repackIndex = 0
+ for pixel in unpacked:
+ pixel = unpackCombiner(pixel)
+ if rIntMask:
+ red = (((rIntMask & pixel) >> rShift) * multiplier) // rDivisor
+ else:
+ red = 0
+ if gIntMask:
+ green = (((gIntMask & pixel) >> gShift) * multiplier) // gDivisor
+ else:
+ green = 0
+ if bIntMask:
+ blue = (((bIntMask & pixel) >> bShift) * multiplier) // bDivisor
+ else:
+ blue = 0
+ if aIntMask:
+ alpha = (((aIntMask & pixel) >> aShift) * multiplier) // aDivisor
+ else:
+ alpha = multiplier
+ struct.pack_into(packFormat, repacked, repackIndex, blue, green, red, alpha)
+ repackIndex += biggestComponent * 4
+ return bytes(repacked)
+
+ return (convert, glInternalFormat, glFormat, glType)
+
+
+def getGLFormat(pixelFormat, dxt10Header=None):
+ # Half or more of this function may be unreachable or otherwise redundant.
+ glInternalFormat = None
+ dxgiFormat = None
+ if dxt10Header:
+ dxgiFormat = dxt10Header.dxgiFormat
+ flags = pixelFormat.dwFlags
+ if flags & pixelFormat.Flags.DDPF_FOURCC:
+ fourCC = pixelFormat.dwFourCC
+ if fourCC == b"DX10" and not dxt10Header:
+ raise UnsupportedDDSFormatException()
+ dxgiFormat = dxt10Header.dxgiFormat if dxt10Header else fourCCToDXGI(fourCC)
+
+ if dxgiFormat:
+ return dxgiToGL[dxgiFormat]
+ elif flags & (
+ pixelFormat.Flags.DDPF_ALPHA | pixelFormat.Flags.DDPF_RGB | pixelFormat.Flags.DDPF_YUV | pixelFormat.Flags.DDPF_LUMINANCE):
+ compressed = False
+
+ rBitmask = None
+ gBitmask = None
+ bBitmask = None
+ aBitmask = None
+ lumBitmask = None
+ if flags & (pixelFormat.Flags.DDPF_ALPHA | pixelFormat.Flags.DDPF_ALPHAPIXELS):
+ aBitmask = pixelFormat.dwABitMask
+ if flags & (pixelFormat.Flags.DDPF_RGB | pixelFormat.Flags.DDPF_YUV):
+ rBitmask = pixelFormat.dwRBitMask
+ gBitmask = pixelFormat.dwGBitMask
+ bBitmask = pixelFormat.dwBBitMask
+ if flags & pixelFormat.Flags.DDPF_LUMINANCE:
+ lumBitmask = pixelFormat.dwRBitMask
+
+ def bitCount(theBytes):
+ count = 0
+ for byte in theBytes:
+ count += bin(byte).count("1")
+ return count
+
+ def firstBit(theBytes):
+ index = 0
+ for byte in theBytes:
+ if byte != 0:
+ return index + format(byte, 'b').find("1")
+ index += 8
+
+ bitCounts = dict()
+ starts = dict()
+ namedBitmasks = dict()
+ if rBitmask:
+ bitCounts["r"] = bitCount(rBitmask)
+ starts["r"] = firstBit(rBitmask)
+ namedBitmasks["r"] = rBitmask
+ if gBitmask:
+ bitCounts["g"] = bitCount(gBitmask)
+ starts["g"] = firstBit(gBitmask)
+ namedBitmasks["g"] = gBitmask
+ if bBitmask:
+ bitCounts["b"] = bitCount(bBitmask)
+ starts["b"] = firstBit(bBitmask)
+ namedBitmasks["b"] = bBitmask
+ if aBitmask:
+ bitCounts["a"] = bitCount(aBitmask)
+ starts["a"] = firstBit(aBitmask)
+ namedBitmasks["a"] = aBitmask
+ if lumBitmask:
+ bitCounts["luminance"] = bitCount(lumBitmask)
+ starts["luminance"] = firstBit(lumBitmask)
+ namedBitmasks["luminance"] = lumBitmask
+
+ toSort = []
+ for key in starts:
+ toSort.append((starts[key], key))
+ toSort.sort()
+
+ glInternalFormatName = ["GL"]
+ glRequirements = None
+
+ desc = "GL_"
+ lastBitCount = -1
+ usedBitCounts = set()
+ for pos, channel in toSort:
+ if lastBitCount != bitCounts[channel]:
+ if lastBitCount != -1:
+ desc += str(lastBitCount)
+ lastBitCount = bitCounts[channel]
+ usedBitCounts.add(lastBitCount)
+ desc += channel
+ if len(usedBitCounts) != 1:
+ desc += str(lastBitCount)
+
+ desc = desc.upper()
+ glFormat = GL_IMAGE_FORMAT[desc] if desc in GL_IMAGE_FORMAT.__members__ else None
+
+ numComponents = len(toSort)
+ byteCount = (pixelFormat.dwRGBBitCount + 7) // 8
+ needsConversion = False
+ if len(usedBitCounts) == 1:
+ if lastBitCount == 8:
+ glType = GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE
+ elif lastBitCount == 16:
+ glType = GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT
+ elif lastBitCount == 32:
+ glType = GL_IMAGE_FORMAT.GL_UNSIGNED_INT
+ elif lastBitCount == 4:
+ if numComponents == 4:
+ glType = GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT_4_4_4_4_REV
+ else:
+ needsConversion = True
+ if not glFormat or numComponents * lastBitCount != pixelFormat.dwRGBBitCount:
+ needsConversion = True
+
+ if needsConversion:
+ convert, glInternalFormat, glFormat, glType = buildConverter(byteCount, bitmasks=namedBitmasks)
+ else:
+ convert = None
+
+ if not glInternalFormat:
+ glInternalFormatName = "_".join(glInternalFormatName)
+ glInternalFormat = GL_IMAGE_FORMAT[
+ glInternalFormatName] if glInternalFormatName in GL_IMAGE_FORMAT.__members__ else GL_IMAGE_FORMAT.GL_RGBA
+
+ if compressed:
+ return CompressedGLTextureFormat(glRequirements, glInternalFormat)
+ else:
+ return UncompressedGLTextureFormat(glRequirements, glInternalFormat, glFormat, glType, convert)
+
+
+def sizeFromFormat(dxgiFormat, width, height):
+ blockCompressed = False
+ if dxgiFormat in {DXGI_FORMAT.DXGI_FORMAT_BC1_TYPELESS,
+ DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM,
+ DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM_SRGB,
+ DXGI_FORMAT.DXGI_FORMAT_BC4_TYPELESS,
+ DXGI_FORMAT.DXGI_FORMAT_BC4_UNORM,
+ DXGI_FORMAT.DXGI_FORMAT_BC4_SNORM}:
+ blockCompressed = True
+ blockSize = 8
+ elif dxgiFormat in {DXGI_FORMAT.DXGI_FORMAT_BC2_TYPELESS,
+ DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM,
+ DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM_SRGB,
+ DXGI_FORMAT.DXGI_FORMAT_BC3_TYPELESS,
+ DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM,
+ DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM_SRGB,
+ DXGI_FORMAT.DXGI_FORMAT_BC5_TYPELESS,
+ DXGI_FORMAT.DXGI_FORMAT_BC5_UNORM,
+ DXGI_FORMAT.DXGI_FORMAT_BC5_SNORM,
+ DXGI_FORMAT.DXGI_FORMAT_BC6H_TYPELESS,
+ DXGI_FORMAT.DXGI_FORMAT_BC6H_UF16,
+ DXGI_FORMAT.DXGI_FORMAT_BC6H_SF16,
+ DXGI_FORMAT.DXGI_FORMAT_BC7_TYPELESS,
+ DXGI_FORMAT.DXGI_FORMAT_BC7_UNORM,
+ DXGI_FORMAT.DXGI_FORMAT_BC7_UNORM_SRGB}:
+ blockCompressed = True
+ blockSize = 16
+
+ if blockCompressed:
+ return max(1, ((width + 3) // 4)) * max(1, ((height + 3) // 4)) * blockSize
+
+ if dxgiFormat <= DXGI_FORMAT.DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
+ name = dxgiFormat.name + "_"
+ count = 0
+ currentNum = ""
+ for char in name:
+ if char.isdecimal():
+ currentNum += char
+ elif currentNum != "":
+ count += int(currentNum)
+ currentNum = ""
+ pixelSize = (count + 7) // 8
+ return width * height * pixelSize
+ pass
diff --git a/libs/dds_header/src/DDS/DDSFile.py b/libs/dds_header/src/DDS/DDSFile.py
new file mode 100644
index 0000000..4592074
--- /dev/null
+++ b/libs/dds_header/src/DDS/DDSFile.py
@@ -0,0 +1,220 @@
+import io
+
+from PyQt6.QtCore import QCoreApplication, qCritical, QFile, QIODeviceBase
+from PyQt6.QtOpenGL import QOpenGLTexture
+
+from . import DDSDefinitions
+from .glstuff import GLTextureFormat
+
+
+class DDSReadException(Exception):
+ """Thrown if there was an error reading a DDS file"""
+ pass
+
+
+ddsCubemapFaces = {
+ DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_POSITIVEX: QOpenGLTexture.CubeMapFace.CubeMapPositiveX,
+ DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_NEGATIVEX: QOpenGLTexture.CubeMapFace.CubeMapNegativeX,
+ DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_POSITIVEY: QOpenGLTexture.CubeMapFace.CubeMapPositiveY,
+ DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_NEGATIVEY: QOpenGLTexture.CubeMapFace.CubeMapNegativeY,
+ DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_POSITIVEZ: QOpenGLTexture.CubeMapFace.CubeMapPositiveZ,
+ DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_NEGATIVEZ: QOpenGLTexture.CubeMapFace.CubeMapNegativeZ}
+
+
+class DDSFile:
+ def __init__(self, fileData: bytes, fileName: str):
+ self.fileName = fileName
+ self.header = DDSDefinitions.DDS_HEADER()
+ self.dxt10Header = None
+ self.glFormat: GLTextureFormat = None
+ self.fileData = fileData
+ self.data = None
+ self.isCubemap = None
+
+ @classmethod
+ def fromFile(cls, fileName: str):
+ file = QFile(fileName)
+ if file.open(QIODeviceBase.OpenModeFlag.ReadOnly):
+ fileData = file.readAll()
+ else:
+ raise DDSReadException()
+ return cls(fileData.data(), fileName)
+
+ def load(self):
+ with io.BytesIO(self.fileData) as file:
+ magicNumber = file.read(4)
+ if magicNumber != DDSDefinitions.DDS_MAGIC_NUMBER:
+ qCritical(self.tr("Magic number mismatch."))
+ raise DDSReadException()
+
+ self.header.fromStream(file)
+
+ if self.header.ddspf.dwFlags & DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_FOURCC:
+ fourCC = self.header.ddspf.dwFourCC
+ if fourCC == b"DX10":
+ self.dxt10Header = DDSDefinitions.DDS_HEADER_DXT10()
+ self.dxt10Header.fromStream(file)
+ else:
+ fourCC = None
+
+ self.glFormat = DDSDefinitions.getGLFormat(self.header.ddspf, self.dxt10Header)
+ self.data = []
+ # Do this once per layer/mip level whatever, (times one per scanline if uncompressed). Also, potentially recompute this based on the format and size in case writers lie.
+ # self.data.append(file.read(self.header.dwPitchOrLinearSize))
+
+ layerCount = 1
+ if self.header.dwCaps2 & DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP:
+ self.isCubemap = True
+ layerCount = 0
+ for face in ddsCubemapFaces:
+ if self.header.dwCaps2 & face:
+ layerCount += 1
+ else:
+ self.isCubemap = False
+
+ for layer in range(layerCount):
+ nextWidth = self.header.dwWidth
+ nextHeight = self.header.dwHeight
+ mipCount = self.mipLevels()
+ for level in range(mipCount):
+ if self.header.ddspf.dwFlags & (
+ DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_ALPHA | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_RGB | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_YUV | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_LUMINANCE):
+ size = nextWidth * nextHeight * ((self.header.ddspf.dwRGBBitCount + 7) // 8)
+ elif fourCC:
+ if self.dxt10Header:
+ dxgiFormat = self.dxt10Header.dxgiFormat
+ else:
+ dxgiFormat = DDSDefinitions.fourCCToDXGI(fourCC)
+ size = DDSDefinitions.sizeFromFormat(dxgiFormat, nextWidth, nextHeight)
+ self.data.append(file.read(size))
+ nextWidth = max(nextWidth // 2, 1)
+ nextHeight = max(nextHeight // 2, 1)
+
+ def getDescription(self):
+ format = ""
+ # DX10 header says the format enum
+ if self.dxt10Header is not None:
+ format = self.dxt10Header.dxgiFormat.name.replace("DXGI_FORMAT_", "")
+ # Pixel Format says the FourCC
+ elif self.header.ddspf.dwFlags & DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_FOURCC:
+ fourCC = self.header.ddspf.dwFourCC
+ format = self.tr("{0} (equivalent to {1})").format(fourCC.decode('ascii'),
+ DDSDefinitions.fourCCToDXGI(fourCC).name.replace(
+ "DXGI_FORMAT_", ""))
+ # We've got bitmasks for the colour channels
+ else:
+ # This could be prettier if there was logic to detect that certain common bitmasks represented things more easily represented, like RGBA8
+ if self.header.ddspf.dwFlags & (
+ DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_RGB | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_YUV):
+ format += self.tr("Red bitmask {0}, Green bitmask {1}, Blue bitmask {2}").format(
+ self.header.ddspf.dwRBitMask.hex().upper(), self.header.ddspf.dwGBitMask.hex().upper(),
+ self.header.ddspf.dwBBitMask.hex().upper())
+ if self.header.ddspf.dwFlags & DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_LUMINANCE:
+ if format != "":
+ format += ", "
+ format += self.tr("Luminance bitmask {0}").format(self.header.ddspf.dwRBitMask.hex().upper())
+ if self.header.ddspf.dwFlags & (
+ DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_ALPHA | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_ALPHAPIXELS):
+ if format != "":
+ format += ", "
+ format += self.tr("Alpha bitmask {0}").format(self.header.ddspf.dwABitMask.hex().upper())
+
+ size = self.tr("{0}×{1}").format(self.header.dwWidth, self.header.dwHeight)
+
+ dimensions = self.tr("Cubemap") if self.isCubemap else self.tr("2D")
+
+ mipmaps = self.tr("Mipmapped") if self.mipLevels() != 1 else self.tr("No mipmaps")
+
+ return self.tr("{0}, {1} {2}, {3}").format(format, size, dimensions, mipmaps)
+
+ def mipLevels(self):
+ if self.header.dwFlags & DDSDefinitions.DDS_HEADER.Flags.DDSD_MIPMAPCOUNT:
+ return self.header.dwMipMapCount
+ else:
+ return 1
+
+ def asQOpenGLTexture(self, gl, context):
+ if not self.data:
+ return
+
+ if self.glFormat.requirements:
+ minVersion, extensions = self.glFormat.requirements
+ glVersion = (gl.glGetIntegerv(gl.GL_MAJOR_VERSION), gl.glGetIntegerv(gl.GL_MINOR_VERSION))
+ if glVersion < minVersion or minVersion < (1, 0):
+ compatible = False
+ for extension in extensions:
+ if context.hasExtension(extension):
+ compatible = True
+ break
+ if not compatible:
+ qCritical(self.tr("OpenGL driver incompatible with texture format."))
+ return None
+
+ if self.header.dwCaps2 & DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP:
+ texture = QOpenGLTexture(QOpenGLTexture.Target.TargetCubeMap)
+ if self.header.dwWidth != self.header.dwHeight:
+ qCritical(self.tr("Cubemap faces must be square"))
+ return None
+ else:
+ # Assume GL_TEXTURE_2D for now
+ texture = QOpenGLTexture(QOpenGLTexture.Target.Target2D)
+ # Assume single layer for now
+ # self.texture.setLayers(1)
+ mipCount = self.mipLevels()
+ texture.setAutoMipMapGenerationEnabled(False)
+ texture.setMipLevels(mipCount)
+ texture.setMipLevelRange(0, mipCount - 1)
+ texture.setSize(self.header.dwWidth, self.header.dwHeight)
+ texture.setFormat(QOpenGLTexture.TextureFormat(self.glFormat.internalFormat))
+ texture.allocateStorage()
+
+ if self.header.dwCaps2 & DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP:
+ # Lisa hasn't whipped David Wang into shape yet. At least there are fewer bugs than under Raja.
+ # The specific bug has been reported and AMD "will try to reproduce it soon"
+ # MO 2.5.0: Radeon-specific code is causing crashing on the latest drivers
+ # Some cubemaps fail to render with or without these modifications
+ # noDSA = "Radeon" in gl.glGetString(gl.GL_RENDERER) and self.glFormat.compressed
+ noDSA = False
+ if noDSA:
+ texture.bind()
+ faceIndex = 0
+ for face in ddsCubemapFaces:
+ if self.header.dwCaps2 & face:
+ for i in range(mipCount):
+ if self.glFormat.compressed:
+ if not noDSA:
+ texture.setCompressedData(i, 0, ddsCubemapFaces[face],
+ len(self.data[faceIndex * mipCount + i]),
+ self.data[faceIndex * mipCount + i])
+ else:
+ gl.glCompressedTexSubImage2D(ddsCubemapFaces[face], i, 0, 0,
+ max(self.header.dwWidth // 2 ** i, 1),
+ max(self.header.dwHeight // 2 ** i, 1),
+ self.glFormat.internalFormat,
+ len(self.data[faceIndex * mipCount + i]),
+ self.data[faceIndex * mipCount + i])
+ else:
+ texture.setData(i, 0, ddsCubemapFaces[face], QOpenGLTexture.PixelFormat(self.glFormat.format), QOpenGLTexture.PixelType(self.glFormat.type),
+ self.glFormat.converter(self.data[faceIndex * mipCount + i]))
+ faceIndex += 1
+ if noDSA:
+ texture.release()
+ else:
+ for i in range(mipCount):
+ if self.glFormat.compressed:
+ texture.setCompressedData(i, 0, len(self.data[i]), self.data[i])
+ else:
+
+ texture.setData(i, 0, QOpenGLTexture.PixelFormat(self.glFormat.format), QOpenGLTexture.PixelType(self.glFormat.type),
+ self.glFormat.converter(self.data[i]))
+
+ texture.setWrapMode(QOpenGLTexture.WrapMode.ClampToEdge)
+
+ if self.glFormat.samplerType != "F":
+ # integer textures can't be filtered
+ texture.setMinMagFilters(QOpenGLTexture.Filter.NearestMipMapNearest, QOpenGLTexture.Filter.Nearest)
+
+ return texture
+
+ def tr(self, str):
+ return QCoreApplication.translate("DDSFile", str)
diff --git a/libs/dds_header/src/DDS/__init__.py b/libs/dds_header/src/DDS/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/libs/dds_header/src/DDS/__init__.py
diff --git a/libs/dds_header/src/DDS/glstuff.py b/libs/dds_header/src/DDS/glstuff.py
new file mode 100644
index 0000000..314d48f
--- /dev/null
+++ b/libs/dds_header/src/DDS/glstuff.py
@@ -0,0 +1,205 @@
+from enum import IntEnum
+
+
+class GL_IMAGE_FORMAT(IntEnum):
+ GL_BYTE = 0x1400
+ GL_UNSIGNED_BYTE = 0x1401
+ GL_SHORT = 0x1402
+ GL_UNSIGNED_SHORT = 0x1403
+ GL_INT = 0x1404
+ GL_UNSIGNED_INT = 0x1405
+ GL_FLOAT = 0x1406
+ GL_HALF_FLOAT = 0x140B
+ GL_COLOR_INDEX = 0x1900
+ GL_STENCIL_INDEX = 0x1901
+ GL_DEPTH_COMPONENT = 0x1902
+ GL_RED = 0x1903
+ GL_GREEN = 0x1904
+ GL_BLUE = 0x1905
+ GL_ALPHA = 0x1906
+ GL_RGB = 0x1907
+ GL_RGBA = 0x1908
+ GL_LUMINANCE = 0x1909
+ GL_LUMINANCE_ALPHA = 0x190A
+ GL_BITMAP = 0x1A00
+ GL_R3_G3_B2 = 0x2A10
+ GL_UNSIGNED_BYTE_3_3_2 = 0x8032
+ GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033
+ GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034
+ GL_UNSIGNED_INT_8_8_8_8 = 0x8035
+ GL_UNSIGNED_INT_10_10_10_2 = 0x8036
+ GL_ALPHA4 = 0x803B
+ GL_ALPHA8 = 0x803C
+ GL_ALPHA12 = 0x803D
+ GL_ALPHA16 = 0x803E
+ GL_LUMINANCE4 = 0x803F
+ GL_LUMINANCE8 = 0x8040
+ GL_LUMINANCE12 = 0x8041
+ GL_LUMINANCE16 = 0x8042
+ GL_LUMINANCE4_ALPHA4 = 0x8043
+ GL_LUMINANCE6_ALPHA2 = 0x8044
+ GL_LUMINANCE8_ALPHA8 = 0x8045
+ GL_LUMINANCE12_ALPHA4 = 0x8046
+ GL_LUMINANCE12_ALPHA12 = 0x8047
+ GL_LUMINANCE16_ALPHA16 = 0x8048
+ GL_INTENSITY = 0x8049
+ GL_INTENSITY4 = 0x804A
+ GL_INTENSITY8 = 0x804B
+ GL_INTENSITY12 = 0x804C
+ GL_INTENSITY16 = 0x804D
+ GL_RGB4 = 0x804F
+ GL_RGB5 = 0x8050
+ GL_RGB8 = 0x8051
+ GL_RGB10 = 0x8052
+ GL_RGB12 = 0x8053
+ GL_RGB16 = 0x8054
+ GL_RGBA2 = 0x8055
+ GL_RGBA4 = 0x8056
+ GL_RGB5_A1 = 0x8057
+ GL_RGBA8 = 0x8058
+ GL_RGB10_A2 = 0x8059
+ GL_RGBA12 = 0x805A
+ GL_RGBA16 = 0x805B
+ GL_BGR = 0x80E0
+ GL_BGRA = 0x80E1
+ GL_DEPTH_COMPONENT16 = 0x81A5
+ GL_DEPTH_COMPONENT24 = 0x81A6
+ GL_DEPTH_COMPONENT32 = 0x81A7
+ GL_COMPRESSED_RED = 0x8225
+ GL_COMPRESSED_RG = 0x8226
+ GL_RG = 0x8227
+ GL_RG_INTEGER = 0x8228
+ GL_R8 = 0x8229
+ GL_R16 = 0x822A
+ GL_RG8 = 0x822B
+ GL_RG16 = 0x822C
+ GL_R16F = 0x822D
+ GL_R32F = 0x822E
+ GL_RG16F = 0x822F
+ GL_RG32F = 0x8230
+ GL_R8I = 0x8231
+ GL_R8UI = 0x8232
+ GL_R16I = 0x8233
+ GL_R16UI = 0x8234
+ GL_R32I = 0x8235
+ GL_R32UI = 0x8236
+ GL_RG8I = 0x8237
+ GL_RG8UI = 0x8238
+ GL_RG16I = 0x8239
+ GL_RG16UI = 0x823A
+ GL_RG32I = 0x823B
+ GL_RG32UI = 0x823C
+ GL_UNSIGNED_BYTE_2_3_3_REV = 0x8362
+ GL_UNSIGNED_SHORT_5_6_5 = 0x8363
+ GL_UNSIGNED_SHORT_5_6_5_REV = 0x8364
+ GL_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365
+ GL_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366
+ GL_UNSIGNED_INT_8_8_8_8_REV = 0x8367
+ GL_UNSIGNED_INT_2_10_10_10_REV = 0x8368
+ GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0
+ GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1
+ GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2
+ GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3
+ GL_COMPRESSED_ALPHA = 0x84E9
+ GL_COMPRESSED_LUMINANCE = 0x84EA
+ GL_COMPRESSED_LUMINANCE_ALPHA = 0x84EB
+ GL_COMPRESSED_INTENSITY = 0x84EC
+ GL_COMPRESSED_RGB = 0x84ED
+ GL_COMPRESSED_RGBA = 0x84EE
+ GL_DEPTH_STENCIL = 0x84F9
+ GL_RGBA32F = 0x8814
+ GL_RGB32F = 0x8815
+ GL_RGBA16F = 0x881A
+ GL_RGB16F = 0x881B
+ GL_R11F_G11F_B10F = 0x8C3A
+ GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B # EXT_packed_float
+ GL_RGB9_E5 = 0x8C3D
+ GL_UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E # EXT_texture_shared_exponent
+ GL_SRGB = 0x8C40
+ GL_SRGB8 = 0x8C41
+ GL_SRGB_ALPHA = 0x8C42
+ GL_SRGB8_ALPHA8 = 0x8C43
+ GL_SLUMINANCE_ALPHA = 0x8C44
+ GL_SLUMINANCE8_ALPHA8 = 0x8C45
+ GL_SLUMINANCE = 0x8C46
+ GL_SLUMINANCE8 = 0x8C47
+ GL_COMPRESSED_SRGB = 0x8C48
+ GL_COMPRESSED_SRGB_ALPHA = 0x8C49
+ GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C
+ GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D
+ GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E
+ GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F
+ GL_RGBA32UI = 0x8D70
+ GL_RGB32UI = 0x8D71
+ GL_RGBA16UI = 0x8D76
+ GL_RGB16UI = 0x8D77
+ GL_RGBA8UI = 0x8D7C
+ GL_RGB8UI = 0x8D7D
+ GL_RGBA32I = 0x8D82
+ GL_RGB32I = 0x8D83
+ GL_RGBA16I = 0x8D88
+ GL_RGB16I = 0x8D89
+ GL_RGBA8I = 0x8D8E
+ GL_RGB8I = 0x8D8F
+ GL_RED_INTEGER = 0x8D94
+ GL_RGB_INTEGER = 0x8D98
+ GL_RGBA_INTEGER = 0x8D99
+ GL_BGR_INTEGER = 0x8D9A
+ GL_BGRA_INTEGER = 0x8D9B
+ GL_COMPRESSED_RED_RGTC1 = 0x8DBB
+ GL_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC
+ GL_COMPRESSED_RG_RGTC2 = 0x8DBD
+ GL_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE
+ GL_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C
+ GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D
+ GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E
+ GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F
+ GL_R8_SNORM = 0x8F94
+ GL_RG8_SNORM = 0x8F95
+ GL_RGB8_SNORM = 0x8F96
+ GL_RGBA8_SNORM = 0x8F97
+ GL_R16_SNORM = 0x8F98
+ GL_RG16_SNORM = 0x8F99
+ GL_RGB16_SNORM = 0x8F9A
+ GL_RGBA16_SNORM = 0x8F9B
+ GL_RGB10_A2UI = 0x906F
+ GL_COMPRESSED_R11_EAC = 0x9270
+ GL_COMPRESSED_SIGNED_R11_EAC = 0x9271
+ GL_COMPRESSED_RG11_EAC = 0x9272
+ GL_COMPRESSED_SIGNED_RG11_EAC = 0x9273
+ GL_COMPRESSED_RGB8_ETC2 = 0x9274
+ GL_COMPRESSED_SRGB8_ETC2 = 0x9275
+ GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276
+ GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277
+ GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278
+ GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279
+
+
+class GLTextureFormat:
+ def __init__(self, requirements, internalFormat, compressed):
+ self.requirements = requirements
+ self.internalFormat = internalFormat
+ self.compressed = compressed
+
+ if internalFormat.name.endswith("UI"):
+ self.samplerType = "UI"
+ elif internalFormat.name.endswith("I"):
+ self.samplerType = "I"
+ else:
+ self.samplerType = "F"
+
+
+class CompressedGLTextureFormat(GLTextureFormat):
+ def __init__(self, requirements, internalFormat):
+ super().__init__(requirements, internalFormat, True)
+
+
+class UncompressedGLTextureFormat(GLTextureFormat):
+ def __init__(self, requirements, internalFormat, format, type, converter=None):
+ super().__init__(requirements, internalFormat, False)
+ self.format = format
+ self.type = type
+ if converter:
+ self.converter = converter
+ else:
+ self.converter = lambda x: x
diff --git a/libs/dds_header/src/DDSPreview.py b/libs/dds_header/src/DDSPreview.py
new file mode 100644
index 0000000..78ffffc
--- /dev/null
+++ b/libs/dds_header/src/DDSPreview.py
@@ -0,0 +1,528 @@
+import struct
+import sys
+import threading
+import enum
+
+from PyQt6.QtCore import QCoreApplication, qDebug, Qt, QSize
+from PyQt6.QtGui import QColor, QOpenGLContext, QSurfaceFormat, QMatrix4x4, QVector4D
+from PyQt6.QtOpenGLWidgets import QOpenGLWidget
+from PyQt6.QtWidgets import QGridLayout, QLabel, QPushButton, QWidget, QColorDialog, QComboBox
+from PyQt6.QtOpenGL import QOpenGLBuffer, QOpenGLDebugLogger, QOpenGLShader, QOpenGLShaderProgram, QOpenGLTexture, \
+ QOpenGLVersionProfile, QOpenGLVertexArrayObject, QOpenGLFunctions_4_1_Core, QOpenGLVersionFunctionsFactory
+
+from DDS.DDSFile import DDSFile
+
+if "mobase" not in sys.modules:
+ import mobase
+
+vertexShader2D = """
+#version 150
+
+uniform float aspectRatioRatio;
+
+in vec4 position;
+in vec2 texCoordIn;
+
+out vec2 texCoord;
+
+void main()
+{
+ texCoord = texCoordIn;
+ gl_Position = position;
+ if (aspectRatioRatio >= 1.0)
+ gl_Position.y /= aspectRatioRatio;
+ else
+ gl_Position.x *= aspectRatioRatio;
+}
+"""
+
+vertexShaderCube = """
+#version 150
+
+uniform float aspectRatioRatio;
+
+in vec4 position;
+in vec2 texCoordIn;
+
+out vec2 texCoord;
+
+void main()
+{
+ texCoord = texCoordIn;
+ gl_Position = position;
+}
+"""
+
+fragmentShaderFloat = """
+#version 150
+
+uniform sampler2D aTexture;
+uniform mat4 channelMatrix;
+uniform vec4 channelOffset;
+
+in vec2 texCoord;
+
+void main()
+{
+ gl_FragData[0] = channelMatrix * texture(aTexture, texCoord) + channelOffset;
+}
+"""
+
+fragmentShaderUInt = """
+#version 150
+
+uniform usampler2D aTexture;
+uniform mat4 channelMatrix;
+uniform vec4 channelOffset;
+
+in vec2 texCoord;
+
+void main()
+{
+ // autofilled alpha is 1, so if we have a scaling factor, we need separate ones for luminance and alpha
+ gl_FragData[0] = channelMatrix * texture(aTexture, texCoord) + channelOffset;
+}
+"""
+
+fragmentShaderSInt = """
+#version 150
+
+uniform isampler2D aTexture;
+uniform mat4 channelMatrix;
+uniform vec4 channelOffset;
+
+in vec2 texCoord;
+
+void main()
+{
+ // autofilled alpha is 1, so if we have a scaling factor and offset, we need separate ones for luminance and alpha
+ gl_FragData[0] = channelMatrix * texture(aTexture, texCoord) + channelOffset;
+}
+"""
+
+fragmentShaderCube = """
+#version 150
+
+uniform samplerCube aTexture;
+uniform mat4 channelMatrix;
+uniform vec4 channelOffset;
+
+in vec2 texCoord;
+
+const float PI = 3.1415926535897932384626433832795;
+
+void main()
+{
+ float theta = -2.0 * PI * texCoord.x;
+ float phi = PI * texCoord.y;
+ gl_FragData[0] = channelMatrix * texture(aTexture, vec3(sin(theta) * sin(phi), cos(theta) * sin(phi), cos(phi))) + channelOffset;
+}
+"""
+
+transparencyVS = """
+#version 150
+
+in vec4 position;
+
+void main()
+{
+ gl_Position = position;
+}
+"""
+
+transparencyFS = """
+#version 150
+
+uniform vec4 backgroundColour;
+
+void main()
+{
+ float x = gl_FragCoord.x;
+ float y = gl_FragCoord.y;
+ x = mod(x, 16.0);
+ y = mod(y, 16.0);
+ gl_FragData[0] = x < 8.0 ^^ y < 8.0 ? vec4(vec3(191.0/255.0), 1.0) : vec4(1.0);
+ gl_FragData[0].rgb = backgroundColour.rgb * backgroundColour.a + gl_FragData[0].rgb * (1.0 - backgroundColour.a);
+}
+"""
+
+vertices = [
+ # vertex coordinates texture coordinates
+ -1.0, -1.0, 0.5, 1.0, 0.0, 1.0,
+ -1.0, 1.0, 0.5, 1.0, 0.0, 0.0,
+ 1.0, 1.0, 0.5, 1.0, 1.0, 0.0,
+
+ -1.0, -1.0, 0.5, 1.0, 0.0, 1.0,
+ 1.0, 1.0, 0.5, 1.0, 1.0, 0.0,
+ 1.0, -1.0, 0.5, 1.0, 1.0, 1.0,
+]
+
+
+class DDSOptions:
+ def __init__(self, colour: QColor = QColor(0, 0, 0, 0), channelMatrix: QMatrix4x4 = QMatrix4x4(),
+ channelOffset: QVector4D = QVector4D()):
+ # QMatrix4x4 with no arguments is the identity matrix, so no channel transformations
+ # declare member variables with None values
+ self.backgroundColour = None
+ self.channelMatrix = None
+ self.channelOffset = None
+ # initialize member variables with error checks
+ self.setBackgroundColour(colour)
+ self.setChannelMatrix(channelMatrix)
+ self.setChannelOffset(channelOffset)
+
+ def setBackgroundColour(self, colour: QColor):
+ if isinstance(colour, QColor) and colour.isValid():
+ self.backgroundColour = colour
+ else:
+ raise TypeError(str(colour) + " is not a valid QColor object.")
+
+ def getBackgroundColour(self) -> QColor:
+ return self.backgroundColour
+
+ def getChannelMatrix(self) -> QMatrix4x4:
+ return self.channelMatrix
+
+ def setChannelMatrix(self, matrix):
+ self.channelMatrix = QMatrix4x4(matrix)
+
+ def getChannelOffset(self) -> QVector4D:
+ return self.channelOffset
+
+ def setChannelOffset(self, vector):
+ self.channelOffset = QVector4D(vector)
+
+
+glVersionProfile = QOpenGLVersionProfile()
+glVersionProfile.setVersion(2, 1)
+
+
+class DDSWidget(QOpenGLWidget):
+ def __init__(self, ddsFile, ddsOptions=DDSOptions(), debugContext=False, parent=None, f=Qt.WindowType(0)):
+ super(DDSWidget, self).__init__(parent, f)
+
+ self.ddsFile = ddsFile
+
+ self.ddsOptions = ddsOptions
+
+ self.clean = True
+
+ self.logger = None
+
+ self.program = None
+ self.transparecyProgram = None
+ self.texture = None
+ self.vbo = None
+ self.vao = None
+
+ if debugContext:
+ format = QSurfaceFormat()
+ format.setOption(QSurfaceFormat.FormatOption.DebugContext)
+ self.setFormat(format)
+ self.logger = QOpenGLDebugLogger(self)
+
+ def __del__(self):
+ self.cleanup()
+
+ def __dtor__(self):
+ self.cleanup()
+
+ def initializeGL(self):
+ if self.logger:
+ self.logger.initialize()
+ self.logger.messageLogged.connect(
+ lambda message: qDebug(self.tr("OpenGL debug message: {0}").format(message.message())))
+ self.logger.startLogging()
+
+ gl = QOpenGLVersionFunctionsFactory.get(glVersionProfile)
+ QOpenGLContext.currentContext().aboutToBeDestroyed.connect(self.cleanup)
+
+ self.clean = False
+
+ fragmentShader = None
+ vertexShader = vertexShader2D
+ if self.ddsFile.isCubemap:
+ fragmentShader = fragmentShaderCube
+ vertexShader = vertexShaderCube
+ if QOpenGLContext.currentContext().hasExtension(b"GL_ARB_seamless_cube_map"):
+ GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F
+ gl.glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS)
+ elif self.ddsFile.glFormat.samplerType == "F":
+ fragmentShader = fragmentShaderFloat
+ elif self.ddsFile.glFormat.samplerType == "UI":
+ fragmentShader = fragmentShaderUInt
+ else:
+ fragmentShader = fragmentShaderSInt
+
+ self.program = QOpenGLShaderProgram(self)
+ self.program.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Vertex, vertexShader)
+ self.program.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Fragment, fragmentShader)
+ self.program.bindAttributeLocation("position", 0)
+ self.program.bindAttributeLocation("texCoordIn", 1)
+ self.program.link()
+
+ self.transparecyProgram = QOpenGLShaderProgram(self)
+ self.transparecyProgram.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Vertex, transparencyVS)
+ self.transparecyProgram.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Fragment, transparencyFS)
+ self.transparecyProgram.bindAttributeLocation("position", 0)
+ self.transparecyProgram.link()
+
+ self.vao = QOpenGLVertexArrayObject(self)
+ vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
+
+ self.vbo = QOpenGLBuffer(QOpenGLBuffer.Type.VertexBuffer)
+ self.vbo.create()
+ self.vbo.bind()
+
+ theBytes = struct.pack("%sf" % len(vertices), *vertices)
+ self.vbo.allocate(theBytes, len(theBytes))
+
+ gl.glEnableVertexAttribArray(0)
+ gl.glEnableVertexAttribArray(1)
+ gl.glVertexAttribPointer(0, 4, gl.GL_FLOAT, False, 6 * 4, 0)
+ gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, False, 6 * 4, 4 * 4)
+
+ self.texture = self.ddsFile.asQOpenGLTexture(gl, QOpenGLContext.currentContext())
+
+ def resizeGL(self, w, h):
+ aspectRatioTex = self.texture.width() / self.texture.height() if self.texture else 1.0
+ aspectRatioWidget = w / h
+ ratioRatio = aspectRatioTex / aspectRatioWidget
+
+ self.program.bind()
+ self.program.setUniformValue("aspectRatioRatio", ratioRatio)
+ self.program.release()
+
+ def paintGL(self):
+ gl = QOpenGLVersionFunctionsFactory.get(glVersionProfile)
+
+ vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
+
+ # Draw checkerboard so transparency is obvious
+ self.transparecyProgram.bind()
+
+ backgroundColour = self.ddsOptions.getBackgroundColour()
+ if backgroundColour and backgroundColour.isValid():
+ self.transparecyProgram.setUniformValue("backgroundColour", backgroundColour)
+
+ gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
+
+ self.transparecyProgram.release()
+
+ self.program.bind()
+
+ if self.texture:
+ self.texture.bind()
+
+ gl.glEnable(gl.GL_BLEND)
+ gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
+
+ self.program.setUniformValue("channelMatrix", self.ddsOptions.getChannelMatrix())
+ self.program.setUniformValue("channelOffset", self.ddsOptions.getChannelOffset())
+
+ gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
+
+ if self.texture:
+ self.texture.release()
+ self.program.release()
+
+ def cleanup(self):
+ if not self.clean:
+ self.makeCurrent()
+
+ self.program = None
+ self.transparecyProgram = None
+ if self.texture:
+ self.texture.destroy()
+ self.texture = None
+ self.vbo.destroy()
+ self.vbo = None
+ self.vao.destroy()
+ self.vao = None
+
+ self.doneCurrent()
+ self.clean = True
+
+ def tr(self, str):
+ return QCoreApplication.translate("DDSWidget", str)
+
+
+class ColourChannels(enum.Enum):
+ RGBA = "Colour and Alpha"
+ RGB = "Colour"
+ A = "Alpha"
+ R = "Red"
+ G = "Green"
+ B = "Blue"
+
+
+class DDSChannelManager:
+ def __init__(self, channels: ColourChannels):
+ self.channels = channels
+
+ def setChannels(self, options: DDSOptions, channels: ColourChannels):
+ self.channels = channels
+
+ def drawColour(alpha: bool):
+ colorMatrix = QMatrix4x4()
+ colorOffset = QVector4D()
+ if not alpha:
+ colorMatrix[3, 3] = 0
+ colorOffset.setW(1.0)
+ options.setChannelMatrix(colorMatrix)
+ options.setChannelOffset(colorOffset)
+
+ def drawGrayscale(channel: ColourChannels):
+ colorOffset = QVector4D(0, 0, 0, 1)
+ channelVector = [0, 0, 0, 0]
+ if channels == ColourChannels.R:
+ channelVector[0] = 1
+ elif channel == ColourChannels.G:
+ channelVector[1] = 1
+ elif channel == ColourChannels.B:
+ channelVector[2] = 1
+ elif channels == ColourChannels.A:
+ channelVector[3] = 1
+ else:
+ raise ValueError("channel must be a single color channel.")
+ alphaVector = [0, 0, 0, 0]
+ colorMatrix = channelVector * 3 + alphaVector
+ options.setChannelMatrix(colorMatrix)
+ options.setChannelOffset(colorOffset)
+
+ if channels == ColourChannels.RGBA:
+ drawColour(True)
+ elif channels == ColourChannels.RGB:
+ drawColour(False)
+ else:
+ drawGrayscale(channels)
+
+
+class DDSPreview(mobase.IPluginPreview):
+
+ def __init__(self):
+ super().__init__()
+ self.__organizer = None
+ self.options = None
+ self.channelManager = None
+
+ def init(self, organizer: mobase.IOrganizer):
+ self.__organizer = organizer
+ savedColour = QColor(self.pluginSetting("background r"), self.pluginSetting("background g"),
+ self.pluginSetting("background b"), self.pluginSetting("background a"))
+ try:
+ savedChannels = ColourChannels[self.pluginSetting("channels")]
+ except KeyError:
+ savedChannels = ColourChannels.RGBA
+ self.options = DDSOptions(savedColour)
+ self.channelManager = DDSChannelManager(savedChannels)
+ self.channelManager.setChannels(self.options, savedChannels)
+ return True
+
+ def pluginSetting(self, name):
+ return self.__organizer.pluginSetting(self.name(), name)
+
+ def setPluginSetting(self, name, value):
+ self.__organizer.setPluginSetting(self.name(), name, value)
+
+ def name(self):
+ return "DDS Preview Plugin"
+
+ def author(self):
+ return "AnyOldName3"
+
+ def description(self):
+ return self.tr("Lets you preview DDS files by actually uploading them to the GPU.")
+
+ def version(self):
+ return mobase.VersionInfo(1, 0, 1, 0)
+
+ def settings(self):
+ return [mobase.PluginSetting("log gl errors", self.tr(
+ "If enabled, log OpenGL errors and debug messages. May decrease performance."), False),
+ mobase.PluginSetting("background r", self.tr("Red channel of background colour"), 0),
+ mobase.PluginSetting("background g", self.tr("Green channel of background colour"), 0),
+ mobase.PluginSetting("background b", self.tr("Blue channel of background colour"), 0),
+ mobase.PluginSetting("background a", self.tr("Alpha channel of background colour"), 0),
+ mobase.PluginSetting("channels", self.tr("The colour channels that are displayed."),
+ ColourChannels.RGBA.name)]
+
+ def supportedExtensions(self) -> set[str]:
+ return {"dds"}
+
+ def supportsArchives(self) -> bool:
+ return True
+
+ def genFilePreview(self, fileName: str, maxSize: QSize) -> QWidget:
+ return self.previewFromDDSFile(DDSFile.fromFile(fileName))
+
+ def genDataPreview(self, fileData: bytes, fileName: str, maxSize: QSize) -> QWidget:
+ return self.previewFromDDSFile(DDSFile(fileData, fileName))
+
+ def previewFromDDSFile(self, ddsFile: DDSFile) -> QWidget:
+ ddsFile.load()
+ layout = QGridLayout()
+ # Image grows before label and button
+ layout.setRowStretch(0, 1)
+ # Label grows before button
+ layout.setColumnStretch(0, 1)
+ layout.addWidget(self.__makeLabel(ddsFile), 1, 0, 1, 1)
+
+ ddsWidget = DDSWidget(ddsFile, self.options, self.__organizer.pluginSetting(self.name(), "log gl errors"))
+ layout.addWidget(ddsWidget, 0, 0, 1, 3)
+
+ layout.addWidget(self.__makeColourButton(ddsWidget), 1, 2, 1, 1)
+ layout.addWidget(self.__makeChannelsButton(ddsWidget), 1, 1, 1, 1)
+
+ widget = QWidget()
+ widget.setLayout(layout)
+ return widget
+
+ def tr(self, str):
+ return QCoreApplication.translate("DDSPreview", str)
+
+ def __makeLabel(self, ddsFile):
+ label = QLabel(ddsFile.getDescription())
+ label.setWordWrap(True)
+ label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+ return label
+
+ def __makeColourButton(self, ddsWidget):
+ button = QPushButton(self.tr("Pick background colour"))
+
+ def pickColour(unused):
+ newColour = QColorDialog.getColor(self.options.getBackgroundColour(), button, "Background colour",
+ QColorDialog.ColorDialogOption.ShowAlphaChannel)
+ if newColour.isValid():
+ self.setPluginSetting("background r", newColour.red())
+ self.setPluginSetting("background g", newColour.green())
+ self.setPluginSetting("background b", newColour.blue())
+ self.setPluginSetting("background a", newColour.alpha())
+ self.options.setBackgroundColour(newColour)
+ ddsWidget.update()
+
+ button.clicked.connect(pickColour)
+ return button
+
+ def __makeChannelsButton(self, ddsWidget):
+ listwidget = QComboBox()
+ channelKeys = [e.name for e in ColourChannels]
+ channelNames = [e.value for e in ColourChannels]
+
+ listwidget.addItems(channelNames)
+ listwidget.setCurrentText(self.channelManager.channels.value)
+ listwidget.setToolTip(self.tr("Select what colour channels are displayed."))
+
+ listwidget.showEvent = lambda _: listwidget.setCurrentText(self.channelManager.channels.value)
+
+ def onChanged(newIndex):
+ self.channelManager.setChannels(self.options, ColourChannels[channelKeys[newIndex]])
+ self.setPluginSetting("channels", self.channelManager.channels.name)
+ ddsWidget.update()
+
+ listwidget.currentIndexChanged.connect(onChanged)
+ return listwidget
+
+
+def createPlugin():
+ return DDSPreview()
diff --git a/libs/dds_header/src/DDSPreview_en.ts b/libs/dds_header/src/DDSPreview_en.ts
new file mode 100644
index 0000000..bc6308a
--- /dev/null
+++ b/libs/dds_header/src/DDSPreview_en.ts
@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS>
+<TS version="2.0">
+ <context>
+ <name>DDSFile</name>
+ <message>
+ <location filename="DDS\DDSFile.py" line="47" />
+ <source>Magic number mismatch.</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="101" />
+ <source>{0} (equivalent to {1})</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="109" />
+ <source>Red bitmask {0}, Green bitmask {1}, Blue bitmask {2}</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="115" />
+ <source>Luminance bitmask {0}</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="120" />
+ <source>Alpha bitmask {0}</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="122" />
+ <source>{0}×{1}</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="124" />
+ <source>Cubemap</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="124" />
+ <source>2D</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="126" />
+ <source>Mipmapped</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="126" />
+ <source>No mipmaps</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="128" />
+ <source>{0}, {1} {2}, {3}</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="150" />
+ <source>OpenGL driver incompatible with texture format.</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDS\DDSFile.py" line="156" />
+ <source>Cubemap faces must be square</source>
+ <translation type="unfinished" />
+ </message>
+ </context>
+ <context>
+ <name>DDSPreview</name>
+ <message>
+ <location filename="DDSPreview.py" line="435" />
+ <source>Lets you preview DDS files by actually uploading them to the GPU.</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDSPreview.py" line="441" />
+ <source>If enabled, log OpenGL errors and debug messages. May decrease performance.</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDSPreview.py" line="443" />
+ <source>Red channel of background colour</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDSPreview.py" line="444" />
+ <source>Green channel of background colour</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDSPreview.py" line="445" />
+ <source>Blue channel of background colour</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDSPreview.py" line="446" />
+ <source>Alpha channel of background colour</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDSPreview.py" line="447" />
+ <source>The colour channels that are displayed.</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDSPreview.py" line="491" />
+ <source>Pick background colour</source>
+ <translation type="unfinished" />
+ </message>
+ <message>
+ <location filename="DDSPreview.py" line="514" />
+ <source>Select what colour channels are displayed.</source>
+ <translation type="unfinished" />
+ </message>
+ </context>
+ <context>
+ <name>DDSWidget</name>
+ <message>
+ <location filename="DDSPreview.py" line="234" />
+ <source>OpenGL debug message: {0}</source>
+ <translation type="unfinished" />
+ </message>
+ </context>
+</TS>
diff --git a/libs/dds_header/vcpkg.json b/libs/dds_header/vcpkg.json
new file mode 100644
index 0000000..da01ba4
--- /dev/null
+++ b/libs/dds_header/vcpkg.json
@@ -0,0 +1,15 @@
+{
+ "features": {
+ "standalone": {
+ "description": "Build Standalone.",
+ "dependencies": ["mo2-cmake", "mo2-uibase"]
+ }
+ },
+ "vcpkg-configuration": {
+ "default-registry": {
+ "kind": "git",
+ "repository": "https://github.com/ModOrganizer2/vcpkg-registry",
+ "baseline": "27d8adbfe9e4ce88a875be3a45fadab69869eb60"
+ }
+ }
+}
generated by cgit v1.3.1 (git 2.54.0) at 2026-07-22 12:25:20 +0000