Unified handling of translating bpy PSK options to the options passed into the build function

Also fixed a bug where the normal export operator was exporting duplicate objects

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Versions**
+Blender: (example: 3.6.2)
+io_scene_psk_psa: (example: 5.0.0)
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Files**
+Please post attachments of the PSK and/or PSA files that you are using to encounter the bug, if any.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/main.yml

@@ -0,0 +1,54 @@
+name: Build Extension
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    env:
+      BLENDER_VERSION: blender-4.2.0-linux-x64
+      ADDON_NAME: io_scene_psk_psa
+    steps:
+      - uses: actions/checkout@v3
+      - uses: SebRollen/toml-action@v1.2.0
+        id: read_manifest
+        with:
+          file: '${{ env.ADDON_NAME }}/blender_manifest.toml'
+          field: 'version'
+      - name: Set derived environment variables
+        run: |
+          echo "BLENDER_FILENAME=${{ env.BLENDER_VERSION }}.tar.xz" >> $GITHUB_ENV
+          echo "BLENDER_URL=https://mirrors.iu13.net/blender/release/Blender4.2/${{ env.BLENDER_VERSION }}.tar.xz" >> $GITHUB_ENV
+      - name: Install Blender Dependencies
+        run: |
+          sudo apt-get install libxxf86vm-dev -y
+          sudo apt-get install libxfixes3 -y
+          sudo apt-get install libxi-dev -y
+          sudo apt-get install libxkbcommon-x11-0 -y
+          sudo apt-get install libgl1-mesa-glx -y
+      - name: Download & Extract Blender
+        run: |
+          wget -q $BLENDER_URL
+          tar -xf $BLENDER_FILENAME
+          rm -rf $BLENDER_FILENAME
+      - name: Add Blender executable to path
+        run: |
+          echo "${{ github.workspace }}/${{ env.BLENDER_VERSION }}/" >> $GITHUB_PATH
+      - name: Build extension
+        run: |
+          pushd ./${{ env.ADDON_NAME }}
+          blender --command extension build
+          mkdir artifact
+          unzip -q ${{ env.ADDON_NAME }}-${{ steps.read_manifest.outputs.value }}.zip -d ./artifact
+          popd
+      - name: Archive addon
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.ADDON_NAME }}-${{ github.ref_name }}-${{ github.sha }}
+          path: |
+            ./${{ env.ADDON_NAME }}/artifact/*

COPYING

@@ -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>.

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Darklight Games
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -1,49 +1,81 @@
-This Blender 2.90+ add-on allows you to import and export meshes and animations to and from the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats) used in many versions of the Unreal Engine.
+[![Blender](https://img.shields.io/badge/Blender->=2.9-blue?logo=blender&logoColor=white)](https://www.blender.org/download/ "Download Blender")
+[![GitHub release](https://img.shields.io/github/release/DarklightGames/io_scene_psk_psa?include_prereleases=&sort=semver&color=blue)](https://github.com/DarklightGames/io_scene_psk_psa/releases/)
+[![Build Extension](https://github.com/DarklightGames/io_scene_psk_psa/actions/workflows/main.yml/badge.svg)](https://github.com/DarklightGames/io_scene_psk_psa/actions/workflows/main.yml)
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/L4L3853VR)
+
+This Blender addon allows you to import and export meshes and animations to and from the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats) used in many versions of the Unreal Engine.
+
+This software is licensed under the [GPLv3](https://www.gnu.org/licenses/gpl-3.0.html) license.
 
 # Features
 * Full PSK/PSA import and export capabilities.
 * Non-standard file section data is supported for import only (vertex normals, extra UV channels, vertex colors, shape keys).
 * Fine-grained PSA sequence importing for efficient workflow when working with large PSA files.
-* PSA sequence metadata (e.g., frame rate, sequence name) is preserved on import, allowing this data to be reused on export.
+* PSA sequence metadata (e.g., frame rate) is preserved on import, allowing this data to be reused on export.
-* Specific [bone groups](https://docs.blender.org/manual/en/latest/animation/armatures/properties/bone_groups.html) can be excluded from PSK/PSA export (useful for excluding non-contributing bones such as IK controllers).
+* Specific bone collections can be excluded from PSK/PSA export (useful for excluding non-contributing bones such as IK controllers).
-* PSA sequences can be exported directly from actions or delineated using a scene's [timeline markers](https://docs.blender.org/manual/en/latest/animation/markers.html), allowing direct use of the [NLA](https://docs.blender.org/manual/en/latest/editors/nla/index.html) when creating sequences.
+* PSA sequences can be exported directly from actions or delineated using a scene's [timeline markers](https://docs.blender.org/manual/en/latest/animation/markers.html), pose markers, or NLA track strips, allowing direct use of the [NLA](https://docs.blender.org/manual/en/latest/editors/nla/index.html) when creating sequences.
 * Manual re-ordering of material slots when exporting multiple mesh objects.
 
 # Installation
-1. Download the zip file for the latest version from the [releases](https://github.com/DarklightGames/io_export_psk_psa/releases) page.
+For Blender 4.2 and higher, it is recommended to download the latest version from the [Blender Extensions](https://extensions.blender.org/add-ons/io-scene-psk-psa/) platform.
-2. Open Blender 2.90 or later.
+
-3. Navigate to the Blender Preferences (Edit > Preferences).
+For Blender 4.1 and lower, you can install the addon manually by following these steps:
-4. Select the "Add-ons" tab.
+
-5. Click the "Install..." button.
+1. Download the .zip file of the latest compatible version for your Blender version (see [Legacy Compatibility](#legacy-compatibility)).
-6. Select the .zip file that you downloaded earlier and click "Install Add-on".
+2. Open Blender.
-7. Enable the newly added "Import-Export: PSK/PSA Importer/Exporter" addon.
+3. Navigate to the Blender Preferences (`Edit` > `Preferences`).
+4. Select the `Add-ons` tab.
+5. Click the `Install...` button.
+6. Select the .zip file that you downloaded earlier and click `Install Add-on`.
+7. Enable the newly added `Import-Export: PSK/PSA Importer/Exporter` addon.
+
+# Legacy Compatibility
+
+Below is a table of the latest addon versions that are compatible with older versions of Blender. These versions are no longer maintained and may contain bugs that have been fixed in newer versions. It is recommended to use the latest version of the addon for the best experience.
+
+Critical bug fixes may be issued for legacy addon versions that are under [Blender's LTS maintenance period](https://www.blender.org/download/lts/). Once the LTS period has ended, legacy addon versions will no longer be supported by the maintainers of this repository, although the releases will still be available for download.
+
+| Blender Version| Addon Version                                                                  | Long Term Support |
+|-|--------------------------------------------------------------------------------|-----------------|
+| [4.1](https://www.blender.org/download/releases/4-1/)        | [7.0.0](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/7.0.0) | No              |
+| [4.0](https://www.blender.org/download/releases/4-0/)        | [6.2.1](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/6.2.1) | No              |
+| [3.4 - 3.6](https://www.blender.org/download/lts/3-6/)       | [5.0.6](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/5.0.6) | June 2025       |
+| [2.93 - 3.3](https://www.blender.org/download/releases/3-3/) | [4.3.0](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/4.3.0) | September 2024  |
 
 # Usage
 ## Exporting a PSK
 1. Select the mesh objects you wish to export.
-3. Navigate to File > Export > Unreal PSK (.psk)
+2. Navigate to `File` > `Export` > `Unreal PSK (.psk)`.
-4. Enter the file name and click "Export".
+3. Enter the file name and click `Export`.
 
 ## Importing a PSK/PSKX
-1. Navigate to File > Import > Unreal PSK (.psk/.pskx)
+1. Navigate to `File` > `Import` > `Unreal PSK (.psk/.pskx)`.
-2. Select the PSK file you want to import and click "Import".
+2. Select the PSK file you want to import and click `Import`.
 
 ## Exporting a PSA
 1. Select the armature objects you wish to export.
-2. Navigate to File > Export > Unreal PSA (.psa)
+2. Navigate to `File` > `Export` > `Unreal PSA (.psa)`.
-3. Enter the file name and click "Export".
+3. Enter the file name and click `Export`.
 
 ## Importing a PSA
-1. Select the armature object that you wish you import actions to.
+1. Select an armature that you want import animations for.
-2. Navigate to the Object Data Properties tab of the Properties editor.
+2. Navigate to `File` > `Import` > `Unreal PSA (.psa)`.
-3. Navigate to the PSA Import panel.
+3. Select the PSA file you want to import.
-4. Click "Select PSA File".
+4. Select the sequences that you want to import and click `Import`.
-5. Select the PSA file that you want to import animations from and click "Select".
+
-6. In the Actions box, select which animations you want to import.
+> Note that in order to see the imported actions applied to your armature, you must use the [Dope Sheet](https://docs.blender.org/manual/en/latest/editors/dope_sheet/introduction.html) or [Nonlinear Animation](https://docs.blender.org/manual/en/latest/editors/nla/introduction.html) editors.
-7. Click "Import".
 
 # FAQ
+
+## Why can't I see the animations imported from my PSA?
+Simply importing an animation into the scene will not automatically apply the action to the armature. This is in part because a PSA can have multiple sequences imported from it, and also that it's generally bad form for importers to modify the scene when they don't need to.
+
+The PSA importer creates [Actions](https://docs.blender.org/manual/en/latest/animation/actions.html) for each of the selected sequences in the PSA. These actions can be applied to your armature via the [Action Editor](https://docs.blender.org/manual/en/latest/editors/dope_sheet/action.html) or [NLA Editor](https://docs.blender.org/manual/en/latest/editors/nla/index.html).
+
 ## Why are the mesh normals not accurate when importing a PSK extracted from [UE Viewer](https://www.gildor.org/en/projects/umodel)?
 If preserving the mesh normals of models is important for your workflow, it is *not recommended* to export PSK files from UE Viewer. This is because UE Viewer makes no attempt to reconstruct the original [smoothing groups](https://en.wikipedia.org/wiki/Smoothing_group). As a result, the normals of imported PSK files will be incorrect when imported into Blender and will need to be manually fixed.
 
 As a workaround, it is recommended to export [glTF](https://en.wikipedia.org/wiki/GlTF) meshes out of UE Viewer instead, since the glTF format has support for explicit normals and UE Viewer can correctly preserve the mesh normals on export. Note, however, that the imported glTF armature may have it's bones oriented incorrectly when imported into Blender. To mitigate this, you can combine the armature of PSK and the mesh of the glTF for best results.
+
+There is also an open pull request to add support for exporting explicit normals from UE Viewer in the future: https://github.com/gildor2/UEViewer/pull/277.

io_scene_psk_psa/__init__.py

@@ -1,68 +1,92 @@
-bl_info = {
+from bpy.app.handlers import persistent
-    "name": "PSK/PSA Importer/Exporter",
-    "author": "Colin Basnett, Yurii Ti",
-    "version": (4, 3, 0),
-    "blender": (2, 90, 0),
-    # "location": "File > Export > PSK Export (.psk)",
-    "description": "PSK/PSA Import/Export (.psk/.psa)",
-    "warning": "",
-    "doc_url": "https://github.com/DarklightGames/io_scene_psk_psa",
-    "tracker_url": "https://github.com/DarklightGames/io_scene_psk_psa/issues",
-    "category": "Import-Export"
-}
 
 if 'bpy' in locals():
     import importlib
 
-    importlib.reload(psx_data)
+    importlib.reload(shared_data)
-    importlib.reload(psx_helpers)
+    importlib.reload(shared_helpers)
-    importlib.reload(psx_types)
+    importlib.reload(shared_types)
+    importlib.reload(shared_dfs)
+    importlib.reload(shared_ui)
+
     importlib.reload(psk_data)
-    importlib.reload(psk_builder)
-    importlib.reload(psk_exporter)
-    importlib.reload(psk_importer)
     importlib.reload(psk_reader)
+    importlib.reload(psk_writer)
+    importlib.reload(psk_builder)
+    importlib.reload(psk_importer)
+    importlib.reload(psk_properties)
+    importlib.reload(psk_ui)
+    importlib.reload(psk_export_properties)
+    importlib.reload(psk_export_operators)
+    importlib.reload(psk_export_ui)
+    importlib.reload(psk_import_operators)
+
     importlib.reload(psa_data)
-    importlib.reload(psa_builder)
+    importlib.reload(psa_config)
-    importlib.reload(psa_exporter)
     importlib.reload(psa_reader)
+    importlib.reload(psa_writer)
+    importlib.reload(psa_builder)
     importlib.reload(psa_importer)
+    importlib.reload(psa_export_properties)
+    importlib.reload(psa_export_operators)
+    importlib.reload(psa_export_ui)
+    importlib.reload(psa_import_properties)
+    importlib.reload(psa_import_operators)
+    importlib.reload(psa_import_ui)
 else:
-    # if i remove this line, it can be enabled just fine
+    from .shared import data as shared_data, types as shared_types, helpers as shared_helpers
-    from . import data as psx_data
+    from .shared import dfs as shared_dfs, ui as shared_ui
-    from . import helpers as psx_helpers
+    from .psk import data as psk_data, builder as psk_builder, writer as psk_writer, \
-    from . import types as psx_types
+    importer as psk_importer, properties as psk_properties
-    from .psk import data as psk_data
+    from .psk import reader as psk_reader, ui as psk_ui
-    from .psk import builder as psk_builder
+    from .psk.export import properties as psk_export_properties, ui as psk_export_ui, \
-    from .psk import exporter as psk_exporter
+        operators as psk_export_operators
-    from .psk import reader as psk_reader
+    from .psk.import_ import operators as psk_import_operators
-    from .psk import importer as psk_importer
+
-    from .psa import data as psa_data
+    from .psa import config as psa_config, data as psa_data, writer as psa_writer, reader as psa_reader, \
-    from .psa import builder as psa_builder
+        builder as psa_builder, importer as psa_importer
-    from .psa import exporter as psa_exporter
+    from .psa.export import properties as psa_export_properties, ui as psa_export_ui, \
-    from .psa import reader as psa_reader
+        operators as psa_export_operators
-    from .psa import importer as psa_importer
+    from .psa.import_ import operators as psa_import_operators
+    from .psa.import_ import ui as psa_import_ui, properties as psa_import_properties
 
 import bpy
 from bpy.props import PointerProperty
 
-classes = (psx_types.classes +
+# TODO: just here so that it's not unreferenced and removed on save.
-           psk_importer.classes +
+if [shared_data, shared_helpers, psk_data, psk_reader, psk_writer, psk_builder, psk_importer, psa_data, psa_config,
-           psk_exporter.classes +
+    psa_reader, psa_writer, psa_builder, psa_importer]:
-           psa_exporter.classes +
+    pass
-           psa_importer.classes)
+
+classes = shared_types.classes +\
+          psk_properties.classes +\
+          psk_ui.classes +\
+          psk_import_operators.classes +\
+          psk_export_properties.classes +\
+          psk_export_operators.classes +\
+          psk_export_ui.classes + \
+          psa_export_properties.classes +\
+          psa_export_operators.classes +\
+          psa_export_ui.classes + \
+          psa_import_properties.classes +\
+          psa_import_operators.classes +\
+          psa_import_ui.classes
 
 
 def psk_export_menu_func(self, context):
-    self.layout.operator(psk_exporter.PskExportOperator.bl_idname, text='Unreal PSK (.psk)')
+    self.layout.operator(psk_export_operators.PSK_OT_export.bl_idname, text='Unreal PSK (.psk)')
 
 
 def psk_import_menu_func(self, context):
-    self.layout.operator(psk_importer.PskImportOperator.bl_idname, text='Unreal PSK (.psk/.pskx)')
+    self.layout.operator(psk_import_operators.PSK_OT_import.bl_idname, text='Unreal PSK (.psk/.pskx)')
 
 
 def psa_export_menu_func(self, context):
-    self.layout.operator(psa_exporter.PsaExportOperator.bl_idname, text='Unreal PSA (.psa)')
+    self.layout.operator(psa_export_operators.PSA_OT_export.bl_idname, text='Unreal PSA (.psa)')
+
+
+def psa_import_menu_func(self, context):
+    self.layout.operator(psa_import_operators.PSA_OT_import.bl_idname, text='Unreal PSA (.psa)')
 
 
 def register():
@@ -71,23 +95,40 @@ def register():
     bpy.types.TOPBAR_MT_file_export.append(psk_export_menu_func)
     bpy.types.TOPBAR_MT_file_import.append(psk_import_menu_func)
     bpy.types.TOPBAR_MT_file_export.append(psa_export_menu_func)
-    bpy.types.Scene.psa_import = PointerProperty(type=psa_importer.PsaImportPropertyGroup)
+    bpy.types.TOPBAR_MT_file_import.append(psa_import_menu_func)
-    bpy.types.Scene.psk_import = PointerProperty(type=psk_importer.PskImportPropertyGroup)
+    bpy.types.Material.psk = PointerProperty(type=psk_properties.PSX_PG_material)
-    bpy.types.Scene.psa_export = PointerProperty(type=psa_exporter.PsaExportPropertyGroup)
+    bpy.types.Scene.psa_import = PointerProperty(type=psa_import_properties.PSA_PG_import)
-    bpy.types.Scene.psk_export = PointerProperty(type=psk_exporter.PskExportPropertyGroup)
+    bpy.types.Scene.psa_export = PointerProperty(type=psa_export_properties.PSA_PG_export)
+    bpy.types.Scene.psk_export = PointerProperty(type=psk_export_properties.PSK_PG_export)
+    bpy.types.Action.psa_export = PointerProperty(type=shared_types.PSX_PG_action_export)
 
 
 def unregister():
+    del bpy.types.Material.psk
     del bpy.types.Scene.psa_import
-    del bpy.types.Scene.psk_import
     del bpy.types.Scene.psa_export
     del bpy.types.Scene.psk_export
+    del bpy.types.Action.psa_export
     bpy.types.TOPBAR_MT_file_export.remove(psk_export_menu_func)
     bpy.types.TOPBAR_MT_file_import.remove(psk_import_menu_func)
     bpy.types.TOPBAR_MT_file_export.remove(psa_export_menu_func)
+    bpy.types.TOPBAR_MT_file_import.remove(psa_import_menu_func)
     for cls in reversed(classes):
         bpy.utils.unregister_class(cls)
 
 
 if __name__ == '__main__':
     register()
+
+
+@persistent
+def load_handler(dummy):
+    # Convert old `psa_sequence_fps` property to new `psa_export.fps` property.
+    # This is only needed for backwards compatibility with files that may have used older versions of the addon.
+    for action in bpy.data.actions:
+        if 'psa_sequence_fps' in action:
+            action.psa_export.fps = action['psa_sequence_fps']
+            del action['psa_sequence_fps']
+
+
+bpy.app.handlers.load_post.append(load_handler)

io_scene_psk_psa/blender_manifest.toml

@@ -0,0 +1,27 @@
+schema_version = "1.0.0"
+id = "io_scene_psk_psa"
+version = "7.1.3"
+name = "Unreal PSK/PSA (.psk/.psa)"
+tagline = "Import and export PSK and PSA files used in Unreal Engine"
+maintainer = "Colin Basnett <cmbasnett@gmail.com>"
+type = "add-on"
+website = "https://github.com/DarklightGames/io_scene_psk_psa/"
+tags = ["Game Engine", "Import-Export"]
+blender_version_min = "4.2.0"
+# Optional: maximum supported Blender version
+# blender_version_max = "5.1.0"
+license = [
+  "SPDX:GPL-3.0-or-later",
+]
+
+[build]
+paths_exclude_pattern = [
+  "/.git/",
+  "__pycache__/",
+  "/venv/",
+  "/.github/",
+  ".gitignore",
+]
+
+[permissions]
+files = "Import/export PSK and PSA files from/to disk"

io_scene_psk_psa/psa/builder.py

@@ -1,115 +1,67 @@
-from typing import Dict
+from typing import Optional
 
-from bpy.types import Action, Armature, Bone
+from bpy.types import Bone, Action, PoseBone
 
 from .data import *
-from ..helpers import *
+from ..shared.helpers import *
 
 
-class PsaBuildOptions(object):
+class PsaBuildSequence:
+    class NlaState:
+        def __init__(self):
+            self.action: Optional[Action] = None
+            self.frame_start: int = 0
+            self.frame_end: int = 0
+
+    def __init__(self, armature_object: Object, anim_data: AnimData):
+        self.armature_object = armature_object
+        self.anim_data = anim_data
+        self.name: str = ''
+        self.nla_state: PsaBuildSequence.NlaState = PsaBuildSequence.NlaState()
+        self.compression_ratio: float = 1.0
+        self.key_quota: int = 0
+        self.fps: float = 30.0
+
+
+class PsaBuildOptions:
     def __init__(self):
-        self.should_override_animation_data = False
+        self.animation_data: Optional[AnimData] = None
-        self.animation_data_override = None
+        self.sequences: List[PsaBuildSequence] = []
-        self.fps_source = 'SCENE'
+        self.bone_filter_mode: str = 'ALL'
-        self.fps_custom = 30.0
+        self.bone_collection_indices: List[int] = []
-        self.sequence_source = 'ACTIONS'
+        self.sequence_name_prefix: str = ''
-        self.actions = []
+        self.sequence_name_suffix: str = ''
-        self.marker_names = []
+        self.root_motion: bool = False
-        self.bone_filter_mode = 'ALL'
+        self.scale = 1.0
-        self.bone_group_indices = []
-        self.should_use_original_sequence_names = False
-        self.should_trim_timeline_marker_sequences = True
-        self.should_ignore_bone_name_restrictions = False
-        self.sequence_name_prefix = ''
-        self.sequence_name_suffix = ''
-        self.root_motion = False
 
 
-def get_sequence_fps(context, options: PsaBuildOptions, actions: Iterable[Action]) -> float:
+def _get_pose_bone_location_and_rotation(pose_bone: PoseBone, armature_object: Object, options: PsaBuildOptions):
-    if options.fps_source == 'SCENE':
+    if pose_bone.parent is not None:
-        return context.scene.render.fps
+        pose_bone_matrix = pose_bone.matrix
-    if options.fps_source == 'CUSTOM':
+        pose_bone_parent_matrix = pose_bone.parent.matrix
-        return options.fps_custom
+        pose_bone_matrix = pose_bone_parent_matrix.inverted() @ pose_bone_matrix
-    elif options.fps_source == 'ACTION_METADATA':
-        # Get the minimum value of action metadata FPS values.
-        fps_list = []
-        for action in filter(lambda x: 'psa_sequence_fps' in x, actions):
-            fps = action['psa_sequence_fps']
-            if type(fps) == int or type(fps) == float:
-                fps_list.append(fps)
-        if len(fps_list) > 0:
-            return min(fps_list)
-        else:
-            # No valid action metadata to use, fallback to scene FPS
-            return context.scene.render.fps
     else:
-        raise RuntimeError(f'Invalid FPS source "{options.fps_source}"')
+        if options.root_motion:
-
+            # Get the bone's pose matrix, taking the armature object's world matrix into account.
-
+            pose_bone_matrix = armature_object.matrix_world @ pose_bone.matrix
-def get_timeline_marker_sequence_frame_ranges(animation_data, context, options: PsaBuildOptions) -> Dict:
-    # Timeline markers need to be sorted so that we can determine the sequence start and end positions.
-    sequence_frame_ranges = dict()
-    sorted_timeline_markers = list(sorted(context.scene.timeline_markers, key=lambda x: x.frame))
-    sorted_timeline_marker_names = list(map(lambda x: x.name, sorted_timeline_markers))
-
-    for marker_name in options.marker_names:
-        marker = context.scene.timeline_markers[marker_name]
-        frame_min = marker.frame
-        # Determine the final frame of the sequence based on the next marker.
-        # If no subsequent marker exists, use the maximum frame_end from all NLA strips.
-        marker_index = sorted_timeline_marker_names.index(marker_name)
-        next_marker_index = marker_index + 1
-        frame_max = 0
-        if next_marker_index < len(sorted_timeline_markers):
-            # There is a next marker. Use that next marker's frame position as the last frame of this sequence.
-            frame_max = sorted_timeline_markers[next_marker_index].frame
-            if options.should_trim_timeline_marker_sequences:
-                nla_strips = get_nla_strips_in_timeframe(animation_data, marker.frame, frame_max)
-                if len(nla_strips) > 0:
-                    frame_max = min(frame_max, max(map(lambda nla_strip: nla_strip.frame_end, nla_strips)))
-                    frame_min = max(frame_min, min(map(lambda nla_strip: nla_strip.frame_start, nla_strips)))
-                else:
-                    # No strips in between this marker and the next, just export this as a one-frame animation.
-                    frame_max = frame_min
         else:
-            # There is no next marker.
+            # Use the bind pose matrix for the root bone.
-            # Find the final frame of all the NLA strips and use that as the last frame of this sequence.
+            pose_bone_matrix = pose_bone.matrix
-            for nla_track in animation_data.nla_tracks:
-                if nla_track.mute:
-                    continue
-                for strip in nla_track.strips:
-                    frame_max = max(frame_max, strip.frame_end)
 
-        if frame_min > frame_max:
+    location = pose_bone_matrix.to_translation()
-            continue
+    rotation = pose_bone_matrix.to_quaternion().normalized()
 
-        sequence_frame_ranges[marker_name] = int(frame_min), int(frame_max)
+    location *= options.scale
 
-    return sequence_frame_ranges
+    if pose_bone.parent is not None:
+        rotation.conjugate()
+
+    return location, rotation
 
 
 def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
     active_object = context.view_layer.objects.active
 
-    if active_object.type != 'ARMATURE':
-        raise RuntimeError('Selected object must be an Armature')
-
-    if options.should_override_animation_data:
-        animation_data_object = options.animation_data_override
-    else:
-        animation_data_object = active_object
-
-    animation_data = animation_data_object.animation_data
-
-    if animation_data is None:
-        raise RuntimeError(f'No animation data for object \'{animation_data_object.name}\'')
-
-    # Ensure that we actually have items that we are going to be exporting.
-    if options.sequence_source == 'ACTIONS' and len(options.actions) == 0:
-        raise RuntimeError('No actions were selected for export')
-    elif options.sequence_source == 'TIMELINE_MARKERS' and len(options.marker_names) == 0:
-        raise RuntimeError('No timeline markers were selected for export')
-
     psa = Psa()
 
     armature_object = active_object
@@ -120,37 +72,33 @@ def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
     # As a result, we need to reconstruct the list of pose bones in the same order as the
     # armature bones.
     bone_names = [x.name for x in bones]
-    pose_bones = [(bone_names.index(bone.name), bone) for bone in armature_object.pose.bones]
-    pose_bones.sort(key=lambda x: x[0])
-    pose_bones = [x[1] for x in pose_bones]
 
     # Get a list of all the bone indices and instigator bones for the bone filter settings.
-    export_bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_group_indices)
+    export_bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_collection_indices)
     bone_indices = [bone_names.index(x) for x in export_bone_names]
 
     # Make the bone lists contain only the bones that are going to be exported.
     bones = [bones[bone_index] for bone_index in bone_indices]
-    pose_bones = [pose_bones[bone_index] for bone_index in bone_indices]
 
     # No bones are going to be exported.
     if len(bones) == 0:
         raise RuntimeError('No bones available for export')
 
-    # Check that all bone names are valid.
-    if not options.should_ignore_bone_name_restrictions:
-        check_bone_names(map(lambda bone: bone.name, bones))
-
     # Build list of PSA bones.
     for bone in bones:
         psa_bone = Psa.Bone()
-        psa_bone.name = bytes(bone.name, encoding='windows-1252')
+
+        try:
+            psa_bone.name = bytes(bone.name, encoding='windows-1252')
+        except UnicodeEncodeError:
+            raise RuntimeError(f'Bone name "{bone.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
 
         try:
             parent_index = bones.index(bone.parent)
             psa_bone.parent_index = parent_index
             psa.bones[parent_index].children_count += 1
         except ValueError:
-            psa_bone.parent_index = -1
+            psa_bone.parent_index = 0
 
         if bone.parent is not None:
             rotation = bone.matrix.to_quaternion().conjugated()
@@ -177,102 +125,72 @@ def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
 
         psa.bones.append(psa_bone)
 
-    # Populate the export sequence list.
-    class NlaState:
-        def __init__(self):
-            self.frame_min = 0
-            self.frame_max = 0
-            self.action = None
-
-    class ExportSequence:
-        def __init__(self):
-            self.name = ''
-            self.nla_state = NlaState()
-            self.fps = 30.0
-
-    export_sequences = []
-
-    if options.sequence_source == 'ACTIONS':
-        for action in options.actions:
-            if len(action.fcurves) == 0:
-                continue
-            export_sequence = ExportSequence()
-            export_sequence.nla_state.action = action
-            export_sequence.name = get_psa_sequence_name(action, options.should_use_original_sequence_names)
-            frame_min, frame_max = [int(x) for x in action.frame_range]
-            export_sequence.nla_state.frame_min = frame_min
-            export_sequence.nla_state.frame_max = frame_max
-            export_sequence.fps = get_sequence_fps(context, options, [action])
-            export_sequences.append(export_sequence)
-        pass
-    elif options.sequence_source == 'TIMELINE_MARKERS':
-        sequence_frame_ranges = get_timeline_marker_sequence_frame_ranges(animation_data, context, options)
-
-        for name, (frame_min, frame_max) in sequence_frame_ranges.items():
-            export_sequence = ExportSequence()
-            export_sequence.name = name
-            export_sequence.nla_state.action = None
-            export_sequence.nla_state.frame_min = frame_min
-            export_sequence.nla_state.frame_max = frame_max
-
-            nla_strips_actions = set(
-                map(lambda x: x.action, get_nla_strips_in_timeframe(animation_data, frame_min, frame_max)))
-            export_sequence.fps = get_sequence_fps(context, options, nla_strips_actions)
-            export_sequences.append(export_sequence)
-    else:
-        raise ValueError(f'Unhandled sequence source: {options.sequence_source}')
-
     # Add prefixes and suffices to the names of the export sequences and strip whitespace.
-    for export_sequence in export_sequences:
+    for export_sequence in options.sequences:
         export_sequence.name = f'{options.sequence_name_prefix}{export_sequence.name}{options.sequence_name_suffix}'
         export_sequence.name = export_sequence.name.strip()
 
     # Save the current action and frame so that we can restore the state once we are done.
     saved_frame_current = context.scene.frame_current
-    saved_action = animation_data.action
+    saved_action = options.animation_data.action
 
     # Now build the PSA sequences.
     # We actually alter the timeline frame and simply record the resultant pose bone matrices.
     frame_start_index = 0
 
-    for export_sequence in export_sequences:
+    context.window_manager.progress_begin(0, len(options.sequences))
+
+    for export_sequence_index, export_sequence in enumerate(options.sequences):
+        # Look up the pose bones for the bones that are going to be exported.
+        pose_bones = [(bone_names.index(bone.name), bone) for bone in export_sequence.armature_object.pose.bones]
+        pose_bones.sort(key=lambda x: x[0])
+        pose_bones = [x[1] for x in pose_bones]
+        pose_bones = [pose_bones[bone_index] for bone_index in bone_indices]
+
         # Link the action to the animation data and update view layer.
-        animation_data.action = export_sequence.nla_state.action
+        export_sequence.anim_data.action = export_sequence.nla_state.action
         context.view_layer.update()
 
-        frame_min = export_sequence.nla_state.frame_min
+        frame_start = export_sequence.nla_state.frame_start
-        frame_max = export_sequence.nla_state.frame_max
+        frame_end = export_sequence.nla_state.frame_end
-        frame_count = frame_max - frame_min + 1
+
+        # Calculate the frame step based on the compression factor.
+        frame_extents = abs(frame_end - frame_start)
+        frame_count_raw = frame_extents + 1
+        frame_count = max(1, max(export_sequence.key_quota, int(frame_count_raw * export_sequence.compression_ratio)))
+
+        try:
+            frame_step = frame_extents / (frame_count - 1)
+        except ZeroDivisionError:
+            frame_step = 0.0
+
+        sequence_duration = frame_count_raw / export_sequence.fps
+
+        # If this is a reverse sequence, we need to reverse the frame step.
+        if frame_start > frame_end:
+            frame_step = -frame_step
 
         psa_sequence = Psa.Sequence()
-        psa_sequence.name = bytes(export_sequence.name, encoding='windows-1252')
+        try:
+            psa_sequence.name = bytes(export_sequence.name, encoding='windows-1252')
+        except UnicodeEncodeError:
+            raise RuntimeError(f'Sequence name "{export_sequence.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
         psa_sequence.frame_count = frame_count
         psa_sequence.frame_start_index = frame_start_index
-        psa_sequence.fps = export_sequence.fps
+        psa_sequence.fps = frame_count / sequence_duration
+        psa_sequence.bone_count = len(pose_bones)
+        psa_sequence.track_time = frame_count
+        psa_sequence.key_reduction = 1.0
 
-        for frame in range(frame_count):
+        frame = float(frame_start)
-            context.scene.frame_set(frame_min + frame)
+
+        for _ in range(frame_count):
+            context.scene.frame_set(frame=int(frame), subframe=frame % 1.0)
 
             for pose_bone in pose_bones:
+                location, rotation = _get_pose_bone_location_and_rotation(pose_bone, export_sequence.armature_object, options)
+
                 key = Psa.Key()
-
-                if pose_bone.parent is not None:
-                    pose_bone_matrix = pose_bone.matrix
-                    pose_bone_parent_matrix = pose_bone.parent.matrix
-                    pose_bone_matrix = pose_bone_parent_matrix.inverted() @ pose_bone_matrix
-                else:
-                    if options.root_motion:
-                        # Export root motion
-                        pose_bone_matrix = armature_object.matrix_world @ pose_bone.matrix
-                    else:
-                        pose_bone_matrix = pose_bone.matrix
-
-                location = pose_bone_matrix.to_translation()
-                rotation = pose_bone_matrix.to_quaternion().normalized()
-
-                if pose_bone.parent is not None:
-                    rotation.conjugate()
-
                 key.location.x = location.x
                 key.location.y = location.y
                 key.location.z = location.z
@@ -281,18 +199,20 @@ def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
                 key.rotation.z = rotation.z
                 key.rotation.w = rotation.w
                 key.time = 1.0 / psa_sequence.fps
-
                 psa.keys.append(key)
 
-            psa_sequence.bone_count = len(pose_bones)
+            frame += frame_step
-            psa_sequence.track_time = frame_count
 
         frame_start_index += frame_count
 
         psa.sequences[export_sequence.name] = psa_sequence
 
+        context.window_manager.progress_update(export_sequence_index)
+
     # Restore the previous action & frame.
-    animation_data.action = saved_action
+    options.animation_data.action = saved_action
     context.scene.frame_set(saved_frame_current)
 
+    context.window_manager.progress_end()
+
     return psa

io_scene_psk_psa/psa/config.py

@@ -0,0 +1,75 @@
+import re
+from configparser import ConfigParser
+from typing import Dict, List
+
+REMOVE_TRACK_LOCATION = (1 << 0)
+REMOVE_TRACK_ROTATION = (1 << 1)
+
+
+class PsaConfig:
+    def __init__(self):
+        self.sequence_bone_flags: Dict[str, Dict[int, int]] = dict()
+
+
+def _load_config_file(file_path: str) -> ConfigParser:
+    """
+    UEViewer exports a dialect of INI files that is not compatible with Python's ConfigParser.
+    Specifically, it allows values in this format:
+
+    [Section]
+    Key1
+    Key2
+
+    This is not allowed in Python's ConfigParser, which requires a '=' character after each key name.
+    To work around this, we'll modify the file to add the '=' character after each key name if it is missing.
+    """
+    with open(file_path, 'r') as f:
+        lines = f.read().split('\n')
+
+    lines = [re.sub(r'^\s*([^=]+)\s*$', r'\1=', line) for line in lines]
+
+    contents = '\n'.join(lines)
+
+    config = ConfigParser()
+    config.read_string(contents)
+
+    return config
+
+
+def _get_bone_flags_from_value(value: str) -> int:
+    match value:
+        case 'all':
+            return REMOVE_TRACK_LOCATION | REMOVE_TRACK_ROTATION
+        case 'trans':
+            return REMOVE_TRACK_LOCATION
+        case 'rot':
+            return REMOVE_TRACK_ROTATION
+        case _:
+            return 0
+
+
+def read_psa_config(psa_sequence_names: List[str], file_path: str) -> PsaConfig:
+    psa_config = PsaConfig()
+
+    config = _load_config_file(file_path)
+
+    if config.has_section('RemoveTracks'):
+        for key, value in config.items('RemoveTracks'):
+            match = re.match(f'^(.+)\.(\d+)$', key)
+            sequence_name = match.group(1)
+
+            # Map the sequence name onto the actual sequence name in the PSA file.
+            try:
+                lowercase_sequence_names = [sequence_name.lower() for sequence_name in psa_sequence_names]
+                sequence_name = psa_sequence_names[lowercase_sequence_names.index(sequence_name.lower())]
+            except ValueError:
+                # Sequence name is not in the PSA file.
+                continue
+
+            if sequence_name not in psa_config.sequence_bone_flags:
+                psa_config.sequence_bone_flags[sequence_name] = dict()
+
+            bone_index = int(match.group(2))
+            psa_config.sequence_bone_flags[sequence_name][bone_index] = _get_bone_flags_from_value(value)
+
+    return psa_config

io_scene_psk_psa/psa/data.py

@@ -2,15 +2,15 @@ import typing
 from collections import OrderedDict
 from typing import List
 
-from ..data import *
+from ..shared.data import *
 
-"""
+'''
 Note that keys are not stored within the Psa object.
 Use the PsaReader::get_sequence_keys to get the keys for a sequence.
-"""
+'''
 
 
-class Psa(object):
+class Psa:
     class Bone(Structure):
         _fields_ = [
             ('name', c_char * 64),

io_scene_psk_psa/psa/export/operators.py

@@ -0,0 +1,587 @@
+import re
+from collections import Counter
+from typing import List, Iterable, Dict, Tuple, cast, Optional
+
+import bpy
+from bpy.props import StringProperty
+from bpy.types import Context, Armature, Action, Object, AnimData, TimelineMarker
+from bpy_extras.io_utils import ExportHelper
+from bpy_types import Operator
+
+from .properties import PSA_PG_export, PSA_PG_export_action_list_item, filter_sequences, \
+    get_sequences_from_name_and_frame_range
+from ..builder import build_psa, PsaBuildSequence, PsaBuildOptions
+from ..writer import write_psa
+from ...shared.helpers import populate_bone_collection_list, get_nla_strips_in_frame_range
+from ...shared.ui import draw_bone_filter_mode
+
+
+def get_sequences_propnames_from_source(sequence_source: str) -> Optional[Tuple[str, str]]:
+    match sequence_source:
+        case 'ACTIONS':
+            return 'action_list', 'action_list_index'
+        case 'TIMELINE_MARKERS':
+            return 'marker_list', 'marker_list_index'
+        case 'NLA_TRACK_STRIPS':
+            return 'nla_strip_list', 'nla_strip_list_index'
+        case 'ACTIVE_ACTION':
+            return 'active_action_list', 'active_action_list_index'
+        case _:
+            raise ValueError(f'Unhandled sequence source: {sequence_source}')
+
+
+def is_action_for_armature(armature: Armature, action: Action):
+    if len(action.fcurves) == 0:
+        return False
+    bone_names = set([x.name for x in armature.bones])
+    for fcurve in action.fcurves:
+        match = re.match(r'pose\.bones\[\"([^\"]+)\"](\[\"([^\"]+)\"])?', fcurve.data_path)
+        if not match:
+            continue
+        bone_name = match.group(1)
+        if bone_name in bone_names:
+            return True
+    return False
+
+
+def update_actions_and_timeline_markers(context: Context):
+    pg = getattr(context.scene, 'psa_export')
+
+    # Clear actions and markers.
+    pg.action_list.clear()
+    pg.marker_list.clear()
+    pg.active_action_list.clear()
+
+    # Get animation data.
+    animation_data_object = get_animation_data_object(context)
+    animation_data = animation_data_object.animation_data if animation_data_object else None
+
+    if animation_data is None:
+        return
+
+    active_armature = cast(Armature, context.active_object.data)
+
+    # Populate actions list.
+    for action in bpy.data.actions:
+        if not is_action_for_armature(active_armature, action):
+            continue
+
+        if action.name != '' and not action.name.startswith('#'):
+            for (name, frame_start, frame_end) in get_sequences_from_action(action):
+                item = pg.action_list.add()
+                item.action = action
+                item.name = name
+                item.is_selected = False
+                item.is_pose_marker = False
+                item.frame_start = frame_start
+                item.frame_end = frame_end
+
+        # Pose markers are not guaranteed to be in frame-order, so make sure that they are.
+        pose_markers = sorted(action.pose_markers, key=lambda x: x.frame)
+        for pose_marker_index, pose_marker in enumerate(pose_markers):
+            if pose_marker.name.strip() == '' or pose_marker.name.startswith('#'):
+                continue
+            for (name, frame_start, frame_end) in get_sequences_from_action_pose_markers(action, pose_markers, pose_marker, pose_marker_index):
+                item = pg.action_list.add()
+                item.action = action
+                item.name = name
+                item.is_selected = False
+                item.is_pose_marker = True
+                item.frame_start = frame_start
+                item.frame_end = frame_end
+
+    # Populate timeline markers list.
+    marker_names = [x.name for x in context.scene.timeline_markers]
+    sequence_frame_ranges = get_timeline_marker_sequence_frame_ranges(animation_data, context, marker_names)
+
+    for marker_name in marker_names:
+        if marker_name not in sequence_frame_ranges:
+            continue
+        if marker_name.strip() == '' or marker_name.startswith('#'):
+            continue
+        frame_start, frame_end = sequence_frame_ranges[marker_name]
+        sequences = get_sequences_from_name_and_frame_range(marker_name, frame_start, frame_end)
+        for (sequence_name, frame_start, frame_end) in sequences:
+            item = pg.marker_list.add()
+            item.name = sequence_name
+            item.is_selected = False
+            item.frame_start = frame_start
+            item.frame_end = frame_end
+
+    # Populate the active action list.
+    for armature_object in context.selected_objects:
+        if armature_object.type != 'ARMATURE':
+            continue
+        action = armature_object.animation_data.action if armature_object.animation_data else None
+        if action is None:
+            continue
+        item = pg.active_action_list.add()
+        item.name = action.name
+        item.armature_object = armature_object
+        item.action = action
+        item.frame_start = int(item.action.frame_range[0])
+        item.frame_end = int(item.action.frame_range[1])
+        item.is_selected = True
+
+
+def get_sequence_fps(context: Context, fps_source: str, fps_custom: float, actions: Iterable[Action]) -> float:
+    match fps_source:
+        case 'SCENE':
+            return context.scene.render.fps
+        case 'CUSTOM':
+            return fps_custom
+        case 'ACTION_METADATA':
+            # Get the minimum value of action metadata FPS values.
+            return min([action.psa_export.fps for action in actions])
+        case _:
+            raise RuntimeError(f'Invalid FPS source "{fps_source}"')
+
+
+def get_animation_data_object(context: Context) -> Object:
+    pg: PSA_PG_export = getattr(context.scene, 'psa_export')
+
+    active_object = context.view_layer.objects.active
+
+    if active_object.type != 'ARMATURE':
+        raise RuntimeError('Selected object must be an Armature')
+
+    if pg.sequence_source != 'ACTIONS' and pg.should_override_animation_data:
+        animation_data_object = pg.animation_data_override
+    else:
+        animation_data_object = active_object
+
+    return animation_data_object
+
+
+def get_timeline_marker_sequence_frame_ranges(animation_data: AnimData, context: Context, marker_names: List[str]) -> Dict:
+    # Timeline markers need to be sorted so that we can determine the sequence start and end positions.
+    sequence_frame_ranges = dict()
+    sorted_timeline_markers = list(sorted(context.scene.timeline_markers, key=lambda x: x.frame))
+    sorted_timeline_marker_names = [x.name for x in sorted_timeline_markers]
+
+    for marker_name in marker_names:
+        marker = context.scene.timeline_markers[marker_name]
+        frame_start = marker.frame
+        # Determine the final frame of the sequence based on the next marker.
+        # If no subsequent marker exists, use the maximum frame_end from all NLA strips.
+        marker_index = sorted_timeline_marker_names.index(marker_name)
+        next_marker_index = marker_index + 1
+        frame_end = 0
+        if next_marker_index < len(sorted_timeline_markers):
+            # There is a next marker. Use that next marker's frame position as the last frame of this sequence.
+            frame_end = sorted_timeline_markers[next_marker_index].frame
+            nla_strips = list(get_nla_strips_in_frame_range(animation_data, marker.frame, frame_end))
+            if len(nla_strips) > 0:
+                frame_end = min(frame_end, max(map(lambda nla_strip: nla_strip.frame_end, nla_strips)))
+                frame_start = max(frame_start, min(map(lambda nla_strip: nla_strip.frame_start, nla_strips)))
+            else:
+                # No strips in between this marker and the next, just export this as a one-frame animation.
+                frame_end = frame_start
+        else:
+            # There is no next marker.
+            # Find the final frame of all the NLA strips and use that as the last frame of this sequence.
+            for nla_track in animation_data.nla_tracks:
+                if nla_track.mute:
+                    continue
+                for strip in nla_track.strips:
+                    frame_end = max(frame_end, strip.frame_end)
+
+        if frame_start > frame_end:
+            continue
+
+        sequence_frame_ranges[marker_name] = int(frame_start), int(frame_end)
+
+    return sequence_frame_ranges
+
+
+def get_sequences_from_action(action: Action) -> List[Tuple[str, int, int]]:
+    frame_start = int(action.frame_range[0])
+    frame_end = int(action.frame_range[1])
+    return get_sequences_from_name_and_frame_range(action.name, frame_start, frame_end)
+
+
+def get_sequences_from_action_pose_markers(action: Action, pose_markers: List[TimelineMarker], pose_marker: TimelineMarker, pose_marker_index: int) -> List[Tuple[str, int, int]]:
+    frame_start = pose_marker.frame
+    sequence_name = pose_marker.name
+    if pose_marker.name.startswith('!'):
+        # If the pose marker name starts with an exclamation mark, only export the first frame.
+        frame_end = frame_start
+        sequence_name = sequence_name[1:]
+    elif pose_marker_index + 1 < len(pose_markers):
+        frame_end = pose_markers[pose_marker_index + 1].frame
+    else:
+        frame_end = int(action.frame_range[1])
+    return get_sequences_from_name_and_frame_range(sequence_name, frame_start, frame_end)
+
+
+def get_visible_sequences(pg: PSA_PG_export, sequences) -> List[PSA_PG_export_action_list_item]:
+    visible_sequences = []
+    for i, flag in enumerate(filter_sequences(pg, sequences)):
+        if bool(flag & (1 << 30)):
+            visible_sequences.append(sequences[i])
+    return visible_sequences
+
+
+class PSA_OT_export(Operator, ExportHelper):
+    bl_idname = 'psa_export.operator'
+    bl_label = 'Export'
+    bl_options = {'INTERNAL', 'UNDO'}
+    bl_description = 'Export actions to PSA'
+    filename_ext = '.psa'
+    filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for exporting the PSA file',
+        maxlen=1024,
+        default='')
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.armature_object = None
+
+    @classmethod
+    def poll(cls, context):
+        try:
+            cls._check_context(context)
+        except RuntimeError as e:
+            cls.poll_message_set(str(e))
+            return False
+        return True
+
+    def draw(self, context):
+        layout = self.layout
+        pg = getattr(context.scene, 'psa_export')
+
+        sequences_header, sequences_panel = layout.panel('Sequences', default_closed=False)
+        sequences_header.label(text='Sequences', icon='ACTION')
+
+        if sequences_panel:
+            flow = sequences_panel.grid_flow()
+            flow.use_property_split = True
+            flow.use_property_decorate = False
+            flow.prop(pg, 'sequence_source', text='Source')
+
+            if pg.sequence_source in {'TIMELINE_MARKERS', 'NLA_TRACK_STRIPS'}:
+                # ANIMDATA SOURCE
+                flow.prop(pg, 'should_override_animation_data')
+                if pg.should_override_animation_data:
+                    flow.prop(pg, 'animation_data_override', text=' ')
+
+            if pg.sequence_source == 'NLA_TRACK_STRIPS':
+                flow = sequences_panel.grid_flow()
+                flow.use_property_split = True
+                flow.use_property_decorate = False
+                flow.prop(pg, 'nla_track')
+
+            # SELECT ALL/NONE
+            row = sequences_panel.row(align=True)
+            row.label(text='Select')
+            row.operator(PSA_OT_export_actions_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
+            row.operator(PSA_OT_export_actions_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+
+            from .ui import PSA_UL_export_sequences
+
+            propname, active_propname = get_sequences_propnames_from_source(pg.sequence_source)
+            sequences_panel.template_list(PSA_UL_export_sequences.bl_idname, '', pg, propname, pg, active_propname,
+                                          rows=max(3, min(len(getattr(pg, propname)), 10)))
+
+            flow = sequences_panel.grid_flow()
+            flow.use_property_split = True
+            flow.use_property_decorate = False
+            flow.prop(pg, 'sequence_name_prefix', text='Name Prefix')
+            flow.prop(pg, 'sequence_name_suffix')
+
+            # Determine if there is going to be a naming conflict and display an error, if so.
+            selected_items = [x for x in pg.action_list if x.is_selected]
+            action_names = [x.name for x in selected_items]
+            action_name_counts = Counter(action_names)
+            for action_name, count in action_name_counts.items():
+                if count > 1:
+                    layout.label(text=f'Duplicate action: {action_name}', icon='ERROR')
+                    break
+
+            # FPS
+            flow.prop(pg, 'fps_source')
+            if pg.fps_source == 'CUSTOM':
+                flow.prop(pg, 'fps_custom', text='Custom')
+
+        # BONES
+        bones_header, bones_panel = layout.panel('Bones', default_closed=False)
+        bones_header.label(text='Bones', icon='BONE_DATA')
+        if bones_panel:
+            row = bones_panel.row(align=True)
+
+            draw_bone_filter_mode(row, pg)
+
+            if pg.bone_filter_mode == 'BONE_COLLECTIONS':
+                row = bones_panel.row(align=True)
+                row.label(text='Select')
+                row.operator(PSA_OT_export_bone_collections_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
+                row.operator(PSA_OT_export_bone_collections_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+                rows = max(3, min(len(pg.bone_collection_list), 10))
+                bones_panel.template_list('PSX_UL_bone_collection_list', '', pg, 'bone_collection_list', pg, 'bone_collection_list_index',
+                                     rows=rows)
+
+        # TRANSFORM
+        transform_header, transform_panel = layout.panel('Advanced', default_closed=False)
+        transform_header.label(text='Transform')
+
+        if transform_panel:
+            flow = transform_panel.grid_flow()
+            flow.use_property_split = True
+            flow.use_property_decorate = False
+            flow.prop(pg, 'root_motion', text='Root Motion')
+            flow.prop(pg, 'scale', text='Scale')
+
+    @classmethod
+    def _check_context(cls, context):
+        if context.view_layer.objects.active is None:
+            raise RuntimeError('An armature must be selected')
+
+        if context.view_layer.objects.active.type != 'ARMATURE':
+            raise RuntimeError('The active object must be an armature')
+
+        # If we have multiple armatures selected, make sure that they all use the same underlying armature data.
+        armature_objects = [obj for obj in context.selected_objects if obj.type == 'ARMATURE']
+
+        for obj in armature_objects:
+            if obj.data != context.view_layer.objects.active.data:
+                raise RuntimeError(f'All selected armatures must use the same armature data block.\n\n'
+                                   f'\The armature data block for "{obj.name}\" (\'{obj.data.name}\') does not match '
+                                   f'the active armature data block (\'{context.view_layer.objects.active.name}\')')
+
+    def invoke(self, context, _event):
+        try:
+            self._check_context(context)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+
+        pg: PSA_PG_export = getattr(context.scene, 'psa_export')
+
+        self.armature_object = context.view_layer.objects.active
+
+        if self.armature_object.animation_data is None:
+            # This is required otherwise the action list will be empty if the armature has never had its animation
+            # data created before (i.e. if no action was ever assigned to it).
+            self.armature_object.animation_data_create()
+
+        update_actions_and_timeline_markers(context)
+
+        populate_bone_collection_list(self.armature_object, pg.bone_collection_list)
+
+        context.window_manager.fileselect_add(self)
+
+        return {'RUNNING_MODAL'}
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+
+        # Ensure that we actually have items that we are going to be exporting.
+        if pg.sequence_source == 'ACTIONS' and len(pg.action_list) == 0:
+            raise RuntimeError('No actions were selected for export')
+        elif pg.sequence_source == 'TIMELINE_MARKERS' and len(pg.marker_list) == 0:
+            raise RuntimeError('No timeline markers were selected for export')
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS' and len(pg.nla_strip_list) == 0:
+            raise RuntimeError('No NLA track strips were selected for export')
+
+        # Populate the export sequence list.
+        animation_data_object = get_animation_data_object(context)
+        animation_data = animation_data_object.animation_data
+
+        if animation_data is None:
+            raise RuntimeError(f'No animation data for object \'{animation_data_object.name}\'')
+
+        export_sequences: List[PsaBuildSequence] = []
+
+        selected_armature_objects = [obj for obj in context.selected_objects if obj.type == 'ARMATURE']
+
+        match pg.sequence_source:
+            case 'ACTIONS':
+                for action_item in filter(lambda x: x.is_selected, pg.action_list):
+                    if len(action_item.action.fcurves) == 0:
+                        continue
+                    export_sequence = PsaBuildSequence(context.active_object, animation_data)
+                    export_sequence.name = action_item.name
+                    export_sequence.nla_state.action = action_item.action
+                    export_sequence.nla_state.frame_start = action_item.frame_start
+                    export_sequence.nla_state.frame_end = action_item.frame_end
+                    export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [action_item.action])
+                    export_sequence.compression_ratio = action_item.action.psa_export.compression_ratio
+                    export_sequence.key_quota = action_item.action.psa_export.key_quota
+                    export_sequences.append(export_sequence)
+            case 'TIMELINE_MARKERS':
+                for marker_item in filter(lambda x: x.is_selected, pg.marker_list):
+                    export_sequence = PsaBuildSequence(context.active_object, animation_data)
+                    export_sequence.name = marker_item.name
+                    export_sequence.nla_state.frame_start = marker_item.frame_start
+                    export_sequence.nla_state.frame_end = marker_item.frame_end
+                    nla_strips_actions = set(
+                        map(lambda x: x.action, get_nla_strips_in_frame_range(animation_data, marker_item.frame_start, marker_item.frame_end)))
+                    export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, nla_strips_actions)
+                    export_sequences.append(export_sequence)
+            case 'NLA_TRACK_STRIPS':
+                for nla_strip_item in filter(lambda x: x.is_selected, pg.nla_strip_list):
+                    export_sequence = PsaBuildSequence(context.active_object, animation_data)
+                    export_sequence.name = nla_strip_item.name
+                    export_sequence.nla_state.frame_start = nla_strip_item.frame_start
+                    export_sequence.nla_state.frame_end = nla_strip_item.frame_end
+                    export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [nla_strip_item.action])
+                    export_sequence.compression_ratio = nla_strip_item.action.psa_export.compression_ratio
+                    export_sequence.key_quota = nla_strip_item.action.psa_export.key_quota
+                    export_sequences.append(export_sequence)
+            case 'ACTIVE_ACTION':
+                for active_action_item in filter(lambda x: x.is_selected, pg.active_action_list):
+                    export_sequence = PsaBuildSequence(active_action_item.armature_object, active_action_item.armature_object.animation_data)
+                    action = active_action_item.action
+                    export_sequence.name = action.name
+                    export_sequence.nla_state.action = action
+                    export_sequence.nla_state.frame_start = int(action.frame_range[0])
+                    export_sequence.nla_state.frame_end = int(action.frame_range[1])
+                    export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [action])
+                    export_sequence.compression_ratio = action.psa_export.compression_ratio
+                    export_sequence.key_quota = action.psa_export.key_quota
+                    export_sequences.append(export_sequence)
+            case _:
+                raise ValueError(f'Unhandled sequence source: {pg.sequence_source}')
+
+        options = PsaBuildOptions()
+        options.animation_data = animation_data
+        options.sequences = export_sequences
+        options.bone_filter_mode = pg.bone_filter_mode
+        options.bone_collection_indices = [x.index for x in pg.bone_collection_list if x.is_selected]
+        options.sequence_name_prefix = pg.sequence_name_prefix
+        options.sequence_name_suffix = pg.sequence_name_suffix
+        options.root_motion = pg.root_motion
+        options.scale = pg.scale
+
+        try:
+            psa = build_psa(context, options)
+            self.report({'INFO'}, f'PSA export successful')
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+
+        write_psa(psa, self.filepath)
+
+        return {'FINISHED'}
+
+
+class PSA_OT_export_actions_select_all(Operator):
+    bl_idname = 'psa_export.sequences_select_all'
+    bl_label = 'Select All'
+    bl_description = 'Select all visible sequences'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def get_item_list(cls, context):
+        pg = context.scene.psa_export
+        match pg.sequence_source:
+            case 'ACTIONS':
+                return pg.action_list
+            case 'TIMELINE_MARKERS':
+                return pg.marker_list
+            case 'NLA_TRACK_STRIPS':
+                return pg.nla_strip_list
+            case 'ACTIVE_ACTION':
+                return pg.active_action_list
+            case _:
+                return None
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = cls.get_item_list(context)
+        visible_sequences = get_visible_sequences(pg, item_list)
+        has_unselected_sequences = any(map(lambda item: not item.is_selected, visible_sequences))
+        return has_unselected_sequences
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+        sequences = self.get_item_list(context)
+        for sequence in get_visible_sequences(pg, sequences):
+            sequence.is_selected = True
+        return {'FINISHED'}
+
+
+class PSA_OT_export_actions_deselect_all(Operator):
+    bl_idname = 'psa_export.sequences_deselect_all'
+    bl_label = 'Deselect All'
+    bl_description = 'Deselect all visible sequences'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def get_item_list(cls, context):
+        pg = context.scene.psa_export
+        match pg.sequence_source:
+            case 'ACTIONS':
+                return pg.action_list
+            case 'TIMELINE_MARKERS':
+                return pg.marker_list
+            case 'NLA_TRACK_STRIPS':
+                return pg.nla_strip_list
+            case 'ACTIVE_ACTION':
+                return pg.active_action_list
+            case _:
+                return None
+
+    @classmethod
+    def poll(cls, context):
+        item_list = cls.get_item_list(context)
+        has_selected_items = any(map(lambda item: item.is_selected, item_list))
+        return len(item_list) > 0 and has_selected_items
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = self.get_item_list(context)
+        for sequence in get_visible_sequences(pg, item_list):
+            sequence.is_selected = False
+        return {'FINISHED'}
+
+
+class PSA_OT_export_bone_collections_select_all(Operator):
+    bl_idname = 'psa_export.bone_collections_select_all'
+    bl_label = 'Select All'
+    bl_description = 'Select all bone collections'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = pg.bone_collection_list
+        has_unselected_items = any(map(lambda action: not action.is_selected, item_list))
+        return len(item_list) > 0 and has_unselected_items
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+        for item in pg.bone_collection_list:
+            item.is_selected = True
+        return {'FINISHED'}
+
+
+class PSA_OT_export_bone_collections_deselect_all(Operator):
+    bl_idname = 'psa_export.bone_collections_deselect_all'
+    bl_label = 'Deselect All'
+    bl_description = 'Deselect all bone collections'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = pg.bone_collection_list
+        has_selected_actions = any(map(lambda action: action.is_selected, item_list))
+        return len(item_list) > 0 and has_selected_actions
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+        for action in pg.bone_collection_list:
+            action.is_selected = False
+        return {'FINISHED'}
+
+
+classes = (
+    PSA_OT_export,
+    PSA_OT_export_actions_select_all,
+    PSA_OT_export_actions_deselect_all,
+    PSA_OT_export_bone_collections_select_all,
+    PSA_OT_export_bone_collections_deselect_all,
+)

io_scene_psk_psa/psa/export/properties.py

@@ -0,0 +1,251 @@
+import re
+import sys
+from fnmatch import fnmatch
+from typing import List, Optional, Tuple
+
+from bpy.props import BoolProperty, PointerProperty, EnumProperty, FloatProperty, CollectionProperty, IntProperty, \
+    StringProperty
+from bpy.types import PropertyGroup, Object, Action, AnimData, Context
+
+from ...shared.data import bone_filter_mode_items
+from ...shared.types import PSX_PG_bone_collection_list_item
+
+
+def psa_export_property_group_animation_data_override_poll(_context, obj):
+    return obj.animation_data is not None
+
+
+empty_set = set()
+
+
+class PSA_PG_export_action_list_item(PropertyGroup):
+    action: PointerProperty(type=Action)
+    name: StringProperty()
+    is_selected: BoolProperty(default=True)
+    frame_start: IntProperty(options={'HIDDEN'})
+    frame_end: IntProperty(options={'HIDDEN'})
+    is_pose_marker: BoolProperty(options={'HIDDEN'})
+
+
+class PSA_PG_export_active_action_list_item(PropertyGroup):
+    action: PointerProperty(type=Action)
+    name: StringProperty()
+    armature_object: PointerProperty(type=Object)
+    is_selected: BoolProperty(default=True)
+    frame_start: IntProperty(options={'HIDDEN'})
+    frame_end: IntProperty(options={'HIDDEN'})
+
+
+class PSA_PG_export_timeline_markers(PropertyGroup):  # TODO: rename this to singular
+    marker_index: IntProperty()
+    name: StringProperty()
+    is_selected: BoolProperty(default=True)
+    frame_start: IntProperty(options={'HIDDEN'})
+    frame_end: IntProperty(options={'HIDDEN'})
+
+
+class PSA_PG_export_nla_strip_list_item(PropertyGroup):
+    name: StringProperty()
+    action: PointerProperty(type=Action)
+    frame_start: FloatProperty()
+    frame_end: FloatProperty()
+    is_selected: BoolProperty(default=True)
+
+
+def get_sequences_from_name_and_frame_range(name: str, frame_start: int, frame_end: int) -> List[Tuple[str, int, int]]:
+    reversed_pattern = r'(.+)/(.+)'
+    reversed_match = re.match(reversed_pattern, name)
+    if reversed_match:
+        forward_name = reversed_match.group(1)
+        backwards_name = reversed_match.group(2)
+        return [
+            (forward_name, frame_start, frame_end),
+            (backwards_name, frame_end, frame_start)
+        ]
+    else:
+        return [(name, frame_start, frame_end)]
+
+
+def nla_track_update_cb(self: 'PSA_PG_export', context: Context) -> None:
+    self.nla_strip_list.clear()
+    match = re.match(r'^(\d+).+$', self.nla_track)
+    self.nla_track_index = int(match.group(1)) if match else -1
+    if self.nla_track_index >= 0:
+        animation_data = get_animation_data(self, context)
+        if animation_data is None:
+            return
+        nla_track = animation_data.nla_tracks[self.nla_track_index]
+        for nla_strip in nla_track.strips:
+            for sequence_name, frame_start, frame_end in get_sequences_from_name_and_frame_range(nla_strip.name, nla_strip.frame_start, nla_strip.frame_end):
+                strip: PSA_PG_export_nla_strip_list_item = self.nla_strip_list.add()
+                strip.action = nla_strip.action
+                strip.name = sequence_name
+                strip.frame_start = frame_start
+                strip.frame_end = frame_end
+
+
+def get_animation_data(pg: 'PSA_PG_export', context: Context) -> Optional[AnimData]:
+    animation_data_object = context.object
+    if pg.should_override_animation_data:
+        animation_data_object = pg.animation_data_override
+    return animation_data_object.animation_data if animation_data_object else None
+
+
+def nla_track_search_cb(self, context: Context, edit_text: str):
+    pg = getattr(context.scene, 'psa_export')
+    animation_data = get_animation_data(pg, context)
+    if animation_data is not None:
+        for index, nla_track in enumerate(animation_data.nla_tracks):
+            yield f'{index} - {nla_track.name}'
+
+
+def animation_data_override_update_cb(self: 'PSA_PG_export', context: Context):
+    # Reset NLA track selection
+    self.nla_track = ''
+
+
+class PSA_PG_export(PropertyGroup):
+    root_motion: BoolProperty(
+        name='Root Motion',
+        options=empty_set,
+        default=False,
+        description='When enabled, the root bone will be transformed as it appears in the scene.\n\n'
+                    'You might want to disable this if you are exporting an animation for an armature that is '
+                    'attached to another object, such as a weapon or a shield',
+    )
+    should_override_animation_data: BoolProperty(
+        name='Override Animation Data',
+        options=empty_set,
+        default=False,
+        description='Use the animation data from a different object instead of the selected object',
+        update=animation_data_override_update_cb,
+    )
+    animation_data_override: PointerProperty(
+        type=Object,
+        update=animation_data_override_update_cb,
+        poll=psa_export_property_group_animation_data_override_poll
+    )
+    sequence_source: EnumProperty(
+        name='Source',
+        options=empty_set,
+        description='',
+        items=(
+            ('ACTIONS', 'Actions', 'Sequences will be exported using actions', 'ACTION', 0),
+            ('TIMELINE_MARKERS', 'Timeline Markers', 'Sequences are delineated by scene timeline markers', 'MARKER_HLT', 1),
+            ('NLA_TRACK_STRIPS', 'NLA Track Strips', 'Sequences are delineated by the start & end times of strips on the selected NLA track', 'NLA', 2),
+            ('ACTIVE_ACTION', 'Active Action', 'The active action will be exported for each selected armature', 'ACTION', 3),
+        )
+    )
+    nla_track: StringProperty(
+        name='NLA Track',
+        options=empty_set,
+        description='',
+        search=nla_track_search_cb,
+        update=nla_track_update_cb
+    )
+    nla_track_index: IntProperty(name='NLA Track Index', default=-1)
+    fps_source: EnumProperty(
+        name='FPS Source',
+        options=empty_set,
+        description='',
+        items=(
+            ('SCENE', 'Scene', '', 'SCENE_DATA', 0),
+            ('ACTION_METADATA', 'Action Metadata', 'The frame rate will be determined by action\'s FPS property found in the PSA Export panel.\n\nIf the Sequence Source is Timeline Markers, the lowest value of all contributing actions will be used', 'ACTION', 1),
+            ('CUSTOM', 'Custom', '', 2)
+        )
+    )
+    fps_custom: FloatProperty(default=30.0, min=sys.float_info.epsilon, soft_min=1.0, options=empty_set, step=100,
+                              soft_max=60.0)
+    action_list: CollectionProperty(type=PSA_PG_export_action_list_item)
+    action_list_index: IntProperty(default=0)
+    marker_list: CollectionProperty(type=PSA_PG_export_timeline_markers)
+    marker_list_index: IntProperty(default=0)
+    nla_strip_list: CollectionProperty(type=PSA_PG_export_nla_strip_list_item)
+    nla_strip_list_index: IntProperty(default=0)
+    active_action_list: CollectionProperty(type=PSA_PG_export_active_action_list_item)
+    active_action_list_index: IntProperty(default=0)
+    bone_filter_mode: EnumProperty(
+        name='Bone Filter',
+        options=empty_set,
+        description='',
+        items=bone_filter_mode_items,
+    )
+    bone_collection_list: CollectionProperty(type=PSX_PG_bone_collection_list_item)
+    bone_collection_list_index: IntProperty(default=0, name='', description='')
+    sequence_name_prefix: StringProperty(name='Prefix', options=empty_set)
+    sequence_name_suffix: StringProperty(name='Suffix', options=empty_set)
+    sequence_filter_name: StringProperty(
+        default='',
+        name='Filter by Name',
+        options={'TEXTEDIT_UPDATE'},
+        description='Only show items matching this name (use \'*\' as wildcard)')
+    sequence_use_filter_invert: BoolProperty(
+        default=False,
+        name='Invert',
+        options=empty_set,
+        description='Invert filtering (show hidden items, and vice versa)')
+    sequence_filter_asset: BoolProperty(
+        default=False,
+        name='Show assets',
+        options=empty_set,
+        description='Show actions that belong to an asset library')
+    sequence_filter_pose_marker: BoolProperty(
+        default=True,
+        name='Show pose markers',
+        options=empty_set)
+    sequence_use_filter_sort_reverse: BoolProperty(default=True, options=empty_set)
+    sequence_filter_reversed: BoolProperty(
+        default=True,
+        options=empty_set,
+        name='Show Reversed',
+        description='Show reversed sequences'
+    )
+    scale: FloatProperty(
+        name='Scale',
+        default=1.0,
+        description='Scale factor to apply to the bone translations. Use this if you are exporting animations for a scaled PSK mesh',
+        min=0.0,
+        soft_max=100.0
+    )
+
+
+def filter_sequences(pg: PSA_PG_export, sequences) -> List[int]:
+    bitflag_filter_item = 1 << 30
+    flt_flags = [bitflag_filter_item] * len(sequences)
+
+    if pg.sequence_filter_name:
+        # Filter name is non-empty.
+        for i, sequence in enumerate(sequences):
+            if not fnmatch(sequence.name, f'*{pg.sequence_filter_name}*'):
+                flt_flags[i] &= ~bitflag_filter_item
+
+        # Invert filter flags for all items.
+        if pg.sequence_use_filter_invert:
+            for i, sequence in enumerate(sequences):
+                flt_flags[i] ^= bitflag_filter_item
+
+    if not pg.sequence_filter_asset:
+        for i, sequence in enumerate(sequences):
+            if hasattr(sequence, 'action') and sequence.action is not None and sequence.action.asset_data is not None:
+                flt_flags[i] &= ~bitflag_filter_item
+
+    if not pg.sequence_filter_pose_marker:
+        for i, sequence in enumerate(sequences):
+            if hasattr(sequence, 'is_pose_marker') and sequence.is_pose_marker:
+                flt_flags[i] &= ~bitflag_filter_item
+
+    if not pg.sequence_filter_reversed:
+        for i, sequence in enumerate(sequences):
+            if sequence.frame_start > sequence.frame_end:
+                flt_flags[i] &= ~bitflag_filter_item
+
+    return flt_flags
+
+
+classes = (
+    PSA_PG_export_action_list_item,
+    PSA_PG_export_timeline_markers,
+    PSA_PG_export_nla_strip_list_item,
+    PSA_PG_export_active_action_list_item,
+    PSA_PG_export,
+)

io_scene_psk_psa/psa/export/ui.py

@@ -0,0 +1,57 @@
+import typing
+
+from bpy.types import UIList
+
+from .properties import PSA_PG_export_action_list_item, filter_sequences
+
+
+class PSA_UL_export_sequences(UIList):
+    bl_idname = 'PSA_UL_export_sequences'
+
+    def __init__(self, *args, **kwargs):
+        super(PSA_UL_export_sequences, self).__init__(*args, **kwargs)
+        # Show the filtering options by default.
+        self.use_filter_show = True
+
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+        item = typing.cast(PSA_PG_export_action_list_item, item)
+
+        is_pose_marker = hasattr(item, 'is_pose_marker') and item.is_pose_marker
+        layout.prop(item, 'is_selected', icon_only=True, text=item.name)
+        if hasattr(item, 'action') and item.action is not None and item.action.asset_data is not None:
+            layout.label(text='', icon='ASSET_MANAGER')
+
+        row = layout.row(align=True)
+        row.alignment = 'RIGHT'
+        if item.frame_end < item.frame_start:
+            row.label(text='', icon='FRAME_PREV')
+        if is_pose_marker:
+            row.label(text=item.action.name, icon='PMARKER')
+
+        if hasattr(item, 'armature_object') and item.armature_object is not None:
+            row.label(text=item.armature_object.name, icon='ARMATURE_DATA')
+
+    def draw_filter(self, context, layout):
+        pg = getattr(context.scene, 'psa_export')
+        row = layout.row()
+        subrow = row.row(align=True)
+        subrow.prop(pg, 'sequence_filter_name', text='')
+        subrow.prop(pg, 'sequence_use_filter_invert', text='', icon='ARROW_LEFTRIGHT')
+
+        if pg.sequence_source == 'ACTIONS':
+            subrow = row.row(align=True)
+            subrow.prop(pg, 'sequence_filter_asset', icon_only=True, icon='ASSET_MANAGER')
+            subrow.prop(pg, 'sequence_filter_pose_marker', icon_only=True, icon='PMARKER')
+            subrow.prop(pg, 'sequence_filter_reversed', text='', icon='FRAME_PREV')
+
+    def filter_items(self, context, data, prop):
+        pg = getattr(context.scene, 'psa_export')
+        actions = getattr(data, prop)
+        flt_flags = filter_sequences(pg, actions)
+        flt_neworder = list(range(len(actions)))
+        return flt_flags, flt_neworder
+
+
+classes = (
+    PSA_UL_export_sequences,
+)

io_scene_psk_psa/psa/exporter.py

@@ -1,547 +0,0 @@
-import fnmatch
-import sys
-from typing import Type
-
-import bpy
-from bpy.props import BoolProperty, CollectionProperty, EnumProperty, FloatProperty, IntProperty, PointerProperty, \
-    StringProperty
-from bpy.types import Action, Operator, PropertyGroup, UIList
-from bpy_extras.io_utils import ExportHelper
-
-from .builder import PsaBuildOptions, build_psa
-from .data import *
-from ..helpers import *
-from ..types import BoneGroupListItem
-
-
-def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
-    section = Section()
-    section.name = name
-    if data_type is not None and data is not None:
-        section.data_size = sizeof(data_type)
-        section.data_count = len(data)
-    fp.write(section)
-    if data is not None:
-        for datum in data:
-            fp.write(datum)
-
-
-def export_psa(psa: Psa, path: str):
-    with open(path, 'wb') as fp:
-        write_section(fp, b'ANIMHEAD')
-        write_section(fp, b'BONENAMES', Psa.Bone, psa.bones)
-        write_section(fp, b'ANIMINFO', Psa.Sequence, list(psa.sequences.values()))
-        write_section(fp, b'ANIMKEYS', Psa.Key, psa.keys)
-
-
-class PsaExportActionListItem(PropertyGroup):
-    action: PointerProperty(type=Action)
-    name: StringProperty()
-    is_selected: BoolProperty(default=False)
-
-
-class PsaExportTimelineMarkerListItem(PropertyGroup):
-    marker_index: IntProperty()
-    name: StringProperty()
-    is_selected: BoolProperty(default=True)
-
-
-def update_action_names(context):
-    pg = context.scene.psa_export
-    for item in pg.action_list:
-        action = item.action
-        item.action_name = get_psa_sequence_name(action, pg.should_use_original_sequence_names)
-
-
-def should_use_original_sequence_names_updated(_, context):
-    update_action_names(context)
-
-
-def psa_export_property_group_animation_data_override_poll(_context, obj):
-    return obj.animation_data is not None
-
-
-empty_set = set()
-
-
-class PsaExportPropertyGroup(PropertyGroup):
-    root_motion: BoolProperty(
-        name='Root Motion',
-        options=empty_set,
-        default=False,
-        description='The root bone will be transformed as it appears in the scene',
-    )
-    should_override_animation_data: BoolProperty(
-        name='Override Animation Data',
-        options=empty_set,
-        default=False,
-        description='Use the animation data from a different object instead of the selected object'
-    )
-    animation_data_override: PointerProperty(
-        type=bpy.types.Object,
-        poll=psa_export_property_group_animation_data_override_poll
-    )
-    sequence_source: EnumProperty(
-        name='Source',
-        options=empty_set,
-        description='',
-        items=(
-            ('ACTIONS', 'Actions', 'Sequences will be exported using actions', 'ACTION', 0),
-            ('TIMELINE_MARKERS', 'Timeline Markers', 'Sequences will be exported using timeline markers', 'MARKER_HLT',
-             1),
-        )
-    )
-    fps_source: EnumProperty(
-        name='FPS Source',
-        options=empty_set,
-        description='',
-        items=(
-            ('SCENE', 'Scene', '', 'SCENE_DATA', 0),
-            ('ACTION_METADATA', 'Action Metadata',
-             'The frame rate will be determined by action\'s "psa_sequence_fps" custom property, if it exists. If the Sequence Source is Timeline Markers, the lowest value of all contributing actions will be used. If no metadata is available, the scene\'s frame rate will be used.',
-             'PROPERTIES', 1),
-            ('CUSTOM', 'Custom', '', 2)
-        )
-    )
-    fps_custom: FloatProperty(default=30.0, min=sys.float_info.epsilon, soft_min=1.0, options=empty_set, step=100,
-                              soft_max=60.0)
-    action_list: CollectionProperty(type=PsaExportActionListItem)
-    action_list_index: IntProperty(default=0)
-    marker_list: CollectionProperty(type=PsaExportTimelineMarkerListItem)
-    marker_list_index: IntProperty(default=0)
-    bone_filter_mode: EnumProperty(
-        name='Bone Filter',
-        options=empty_set,
-        description='',
-        items=(
-            ('ALL', 'All', 'All bones will be exported.'),
-            ('BONE_GROUPS', 'Bone Groups', 'Only bones belonging to the selected bone groups and their ancestors will '
-                                           'be exported.'),
-        )
-    )
-    bone_group_list: CollectionProperty(type=BoneGroupListItem)
-    bone_group_list_index: IntProperty(default=0, name='', description='')
-    should_use_original_sequence_names: BoolProperty(
-        default=False,
-        name='Original Names',
-        options=empty_set,
-        update=should_use_original_sequence_names_updated,
-        description='If the action was imported from the PSA Import panel, the original name of the sequence will be '
-                    'used instead of the Blender action name',
-    )
-    should_trim_timeline_marker_sequences: BoolProperty(
-        default=True,
-        name='Trim Sequences',
-        options=empty_set,
-        description='Frames without NLA track information at the boundaries of timeline markers will be excluded from '
-                    'the exported sequences '
-    )
-    should_ignore_bone_name_restrictions: BoolProperty(
-        default=False,
-        name='Ignore Bone Name Restrictions',
-        description='Bone names restrictions will be ignored. Note that bone names without properly formatted names '
-                    'cannot be referenced in scripts.'
-    )
-    sequence_name_prefix: StringProperty(name='Prefix', options=empty_set)
-    sequence_name_suffix: StringProperty(name='Suffix', options=empty_set)
-    sequence_filter_name: StringProperty(
-        default='',
-        name='Filter by Name',
-        options={'TEXTEDIT_UPDATE'},
-        description='Only show items matching this name (use \'*\' as wildcard)')
-    sequence_use_filter_invert: BoolProperty(
-        default=False,
-        name='Invert',
-        options=empty_set,
-        description='Invert filtering (show hidden items, and vice versa)')
-    sequence_filter_asset: BoolProperty(
-        default=False,
-        name='Show assets',
-        options=empty_set,
-        description='Show actions that belong to an asset library')
-    sequence_use_filter_sort_reverse: BoolProperty(default=True, options=empty_set)
-
-
-def is_bone_filter_mode_item_available(context, identifier):
-    if identifier == 'BONE_GROUPS':
-        obj = context.active_object
-        if not obj.pose or not obj.pose.bone_groups:
-            return False
-    return True
-
-
-class PsaExportOperator(Operator, ExportHelper):
-    bl_idname = 'psa_export.operator'
-    bl_label = 'Export'
-    bl_options = {'INTERNAL', 'UNDO'}
-    __doc__ = 'Export actions to PSA'
-    filename_ext = '.psa'
-    filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
-    filepath: StringProperty(
-        name='File Path',
-        description='File path used for exporting the PSA file',
-        maxlen=1024,
-        default='')
-
-    def __init__(self):
-        self.armature = None
-
-    @classmethod
-    def poll(cls, context):
-        try:
-            cls._check_context(context)
-        except RuntimeError as e:
-            cls.poll_message_set(str(e))
-            return False
-        return True
-
-    def draw(self, context):
-        layout = self.layout
-        pg = getattr(context.scene, 'psa_export')
-
-        # FPS
-        layout.prop(pg, 'fps_source', text='FPS')
-        if pg.fps_source == 'CUSTOM':
-            layout.prop(pg, 'fps_custom', text='Custom')
-
-        # SOURCE
-        layout.prop(pg, 'sequence_source', text='Source')
-
-        if pg.sequence_source == 'TIMELINE_MARKERS':
-            # ANIMDATA SOURCE
-            layout.prop(pg, 'should_override_animation_data')
-            if pg.should_override_animation_data:
-                layout.prop(pg, 'animation_data_override', text='')
-
-        # SELECT ALL/NONE
-        row = layout.row(align=True)
-        row.label(text='Select')
-        row.operator(PsaExportActionsSelectAll.bl_idname, text='All', icon='CHECKBOX_HLT')
-        row.operator(PsaExportActionsDeselectAll.bl_idname, text='None', icon='CHECKBOX_DEHLT')
-
-        # ACTIONS
-        if pg.sequence_source == 'ACTIONS':
-            rows = max(3, min(len(pg.action_list), 10))
-
-            layout.template_list('PSA_UL_ExportSequenceList', '', pg, 'action_list', pg, 'action_list_index', rows=rows)
-
-            col = layout.column()
-            col.use_property_split = True
-            col.use_property_decorate = False
-            col.prop(pg, 'should_use_original_sequence_names')
-            col.prop(pg, 'sequence_name_prefix')
-            col.prop(pg, 'sequence_name_suffix')
-
-        elif pg.sequence_source == 'TIMELINE_MARKERS':
-            rows = max(3, min(len(pg.marker_list), 10))
-            layout.template_list('PSA_UL_ExportSequenceList', '', pg, 'marker_list', pg, 'marker_list_index',
-                                 rows=rows)
-
-            col = layout.column()
-            col.use_property_split = True
-            col.use_property_decorate = False
-            col.prop(pg, 'should_trim_timeline_marker_sequences')
-            col.prop(pg, 'sequence_name_prefix')
-            col.prop(pg, 'sequence_name_suffix')
-
-        # Determine if there is going to be a naming conflict and display an error, if so.
-        selected_items = [x for x in pg.action_list if x.is_selected]
-        action_names = [x.name for x in selected_items]
-        action_name_counts = Counter(action_names)
-        for action_name, count in action_name_counts.items():
-            if count > 1:
-                layout.label(text=f'Duplicate action: {action_name}', icon='ERROR')
-                break
-
-        layout.separator()
-
-        # BONES
-        row = layout.row(align=True)
-        row.prop(pg, 'bone_filter_mode', text='Bones')
-
-        if pg.bone_filter_mode == 'BONE_GROUPS':
-            row = layout.row(align=True)
-            row.label(text='Select')
-            row.operator(PsaExportBoneGroupsSelectAll.bl_idname, text='All', icon='CHECKBOX_HLT')
-            row.operator(PsaExportBoneGroupsDeselectAll.bl_idname, text='None', icon='CHECKBOX_DEHLT')
-            rows = max(3, min(len(pg.bone_group_list), 10))
-            layout.template_list('PSX_UL_BoneGroupList', '', pg, 'bone_group_list', pg, 'bone_group_list_index',
-                                 rows=rows)
-
-        layout.prop(pg, 'should_ignore_bone_name_restrictions')
-
-        layout.separator()
-
-        # ROOT MOTION
-        layout.prop(pg, 'root_motion', text='Root Motion')
-
-    def is_action_for_armature(self, action):
-        if len(action.fcurves) == 0:
-            return False
-        bone_names = set([x.name for x in self.armature.data.bones])
-        for fcurve in action.fcurves:
-            match = re.match(r'pose\.bones\[\"([^\"]+)\"](\[\"([^\"]+)\"])?', fcurve.data_path)
-            if not match:
-                continue
-            bone_name = match.group(1)
-            if bone_name in bone_names:
-                return True
-        return False
-
-    @classmethod
-    def _check_context(cls, context):
-        if context.view_layer.objects.active is None:
-            raise RuntimeError('An armature must be selected')
-
-        if context.view_layer.objects.active.type != 'ARMATURE':
-            raise RuntimeError('The selected object must be an armature')
-
-    def invoke(self, context, _event):
-        try:
-            self._check_context(context)
-        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-
-        pg = getattr(context.scene, 'psa_export')
-        self.armature = context.view_layer.objects.active
-
-        # Populate actions list.
-        pg.action_list.clear()
-        for action in bpy.data.actions:
-            if not self.is_action_for_armature(action):
-                continue
-            item = pg.action_list.add()
-            item.action = action
-            item.name = action.name
-            item.is_selected = False
-
-        update_action_names(context)
-
-        # Populate timeline markers list.
-        pg.marker_list.clear()
-        for marker in context.scene.timeline_markers:
-            item = pg.marker_list.add()
-            item.name = marker.name
-            item.is_selected = False
-
-        if len(pg.action_list) == 0 and len(pg.marker_list) == 0:
-            # If there are no actions at all, we have nothing to export, so just cancel the operation.
-            self.report({'ERROR_INVALID_CONTEXT'}, 'There are no actions or timeline markers to export.')
-            return {'CANCELLED'}
-
-        # Populate bone groups list.
-        populate_bone_group_list(self.armature, pg.bone_group_list)
-
-        context.window_manager.fileselect_add(self)
-
-        return {'RUNNING_MODAL'}
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_export')
-
-        actions = [x.action for x in pg.action_list if x.is_selected]
-        marker_names = [x.name for x in pg.marker_list if x.is_selected]
-
-        options = PsaBuildOptions()
-        options.should_override_animation_data = pg.should_override_animation_data
-        options.animation_data_override = pg.animation_data_override
-        options.fps_source = pg.fps_source
-        options.fps_custom = pg.fps_custom
-        options.sequence_source = pg.sequence_source
-        options.actions = actions
-        options.marker_names = marker_names
-        options.bone_filter_mode = pg.bone_filter_mode
-        options.bone_group_indices = [x.index for x in pg.bone_group_list if x.is_selected]
-        options.should_use_original_sequence_names = pg.should_use_original_sequence_names
-        options.should_trim_timeline_marker_sequences = pg.should_trim_timeline_marker_sequences
-        options.should_ignore_bone_name_restrictions = pg.should_ignore_bone_name_restrictions
-        options.sequence_name_prefix = pg.sequence_name_prefix
-        options.sequence_name_suffix = pg.sequence_name_suffix
-        options.root_motion = pg.root_motion
-
-        try:
-            psa = build_psa(context, options)
-            self.report({'INFO'}, f'PSA export successful')
-        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-            return {'CANCELLED'}
-
-        export_psa(psa, self.filepath)
-
-        return {'FINISHED'}
-
-
-def filter_sequences(pg: PsaExportPropertyGroup, sequences) -> List[int]:
-    bitflag_filter_item = 1 << 30
-    flt_flags = [bitflag_filter_item] * len(sequences)
-
-    if pg.sequence_filter_name:
-        # Filter name is non-empty.
-        for i, sequence in enumerate(sequences):
-            if not fnmatch.fnmatch(sequence.name, f'*{pg.sequence_filter_name}*'):
-                flt_flags[i] &= ~bitflag_filter_item
-
-        # Invert filter flags for all items.
-        if pg.sequence_use_filter_invert:
-            for i, sequence in enumerate(sequences):
-                flt_flags[i] ^= bitflag_filter_item
-
-    if not pg.sequence_filter_asset:
-        for i, sequence in enumerate(sequences):
-            if hasattr(sequence, 'action') and sequence.action.asset_data is not None:
-                flt_flags[i] &= ~bitflag_filter_item
-
-    return flt_flags
-
-
-def get_visible_sequences(pg: PsaExportPropertyGroup, sequences) -> List[PsaExportActionListItem]:
-    visible_sequences = []
-    for i, flag in enumerate(filter_sequences(pg, sequences)):
-        if bool(flag & (1 << 30)):
-            visible_sequences.append(sequences[i])
-    return visible_sequences
-
-
-class PSA_UL_ExportSequenceList(UIList):
-
-    def __init__(self):
-        super(PSA_UL_ExportSequenceList, self).__init__()
-        # Show the filtering options by default.
-        self.use_filter_show = True
-
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
-        layout.prop(item, 'is_selected', icon_only=True, text=item.name)
-        if hasattr(item, 'action') and item.action.asset_data is not None:
-            layout.label(text='', icon='ASSET_MANAGER')
-
-    def draw_filter(self, context, layout):
-        pg = getattr(context.scene, 'psa_export')
-        row = layout.row()
-        subrow = row.row(align=True)
-        subrow.prop(pg, 'sequence_filter_name', text="")
-        subrow.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
-        # subrow.prop(pg, 'sequence_use_filter_sort_reverse', text='', icon='SORT_ASC')
-
-        if pg.sequence_source == 'ACTIONS':
-            subrow = row.row(align=True)
-            subrow.prop(pg, 'sequence_filter_asset', icon_only=True, icon='ASSET_MANAGER')
-
-    def filter_items(self, context, data, prop):
-        pg = getattr(context.scene, 'psa_export')
-        actions = getattr(data, prop)
-        flt_flags = filter_sequences(pg, actions)
-        flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(actions, 'name')
-        return flt_flags, flt_neworder
-
-
-class PsaExportActionsSelectAll(Operator):
-    bl_idname = 'psa_export.sequences_select_all'
-    bl_label = 'Select All'
-    bl_description = 'Select all visible sequences'
-    bl_options = {'INTERNAL'}
-
-    @classmethod
-    def get_item_list(cls, context):
-        pg = context.scene.psa_export
-        if pg.sequence_source == 'ACTIONS':
-            return pg.action_list
-        elif pg.sequence_source == 'TIMELINE_MARKERS':
-            return pg.marker_list
-        return None
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_export')
-        item_list = cls.get_item_list(context)
-        visible_sequences = get_visible_sequences(pg, item_list)
-        has_unselected_sequences = any(map(lambda item: not item.is_selected, visible_sequences))
-        return has_unselected_sequences
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_export')
-        sequences = self.get_item_list(context)
-        for sequence in get_visible_sequences(pg, sequences):
-            sequence.is_selected = True
-        return {'FINISHED'}
-
-
-class PsaExportActionsDeselectAll(Operator):
-    bl_idname = 'psa_export.sequences_deselect_all'
-    bl_label = 'Deselect All'
-    bl_description = 'Deselect all visible sequences'
-    bl_options = {'INTERNAL'}
-
-    @classmethod
-    def get_item_list(cls, context):
-        pg = context.scene.psa_export
-        if pg.sequence_source == 'ACTIONS':
-            return pg.action_list
-        elif pg.sequence_source == 'TIMELINE_MARKERS':
-            return pg.marker_list
-        return None
-
-    @classmethod
-    def poll(cls, context):
-        item_list = cls.get_item_list(context)
-        has_selected_items = any(map(lambda item: item.is_selected, item_list))
-        return len(item_list) > 0 and has_selected_items
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_export')
-        item_list = self.get_item_list(context)
-        for sequence in get_visible_sequences(pg, item_list):
-            sequence.is_selected = False
-        return {'FINISHED'}
-
-
-class PsaExportBoneGroupsSelectAll(Operator):
-    bl_idname = 'psa_export.bone_groups_select_all'
-    bl_label = 'Select All'
-    bl_description = 'Select all bone groups'
-    bl_options = {'INTERNAL'}
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_export')
-        item_list = pg.bone_group_list
-        has_unselected_items = any(map(lambda action: not action.is_selected, item_list))
-        return len(item_list) > 0 and has_unselected_items
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_export')
-        for item in pg.bone_group_list:
-            item.is_selected = True
-        return {'FINISHED'}
-
-
-class PsaExportBoneGroupsDeselectAll(Operator):
-    bl_idname = 'psa_export.bone_groups_deselect_all'
-    bl_label = 'Deselect All'
-    bl_description = 'Deselect all bone groups'
-    bl_options = {'INTERNAL'}
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_export')
-        item_list = pg.bone_group_list
-        has_selected_actions = any(map(lambda action: action.is_selected, item_list))
-        return len(item_list) > 0 and has_selected_actions
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_export')
-        for action in pg.bone_group_list:
-            action.is_selected = False
-        return {'FINISHED'}
-
-
-classes = (
-    PsaExportActionListItem,
-    PsaExportTimelineMarkerListItem,
-    PsaExportPropertyGroup,
-    PsaExportOperator,
-    PSA_UL_ExportSequenceList,
-    PsaExportActionsSelectAll,
-    PsaExportActionsDeselectAll,
-    PsaExportBoneGroupsSelectAll,
-    PsaExportBoneGroupsDeselectAll,
-)

io_scene_psk_psa/psa/import_/operators.py

@@ -0,0 +1,387 @@
+import os
+from pathlib import Path
+from typing import List
+
+from bpy.props import StringProperty, CollectionProperty
+from bpy.types import Operator, Event, Context, FileHandler, OperatorFileListElement, Object
+from bpy_extras.io_utils import ImportHelper
+
+from .properties import get_visible_sequences
+from ..config import read_psa_config
+from ..importer import import_psa, PsaImportOptions
+from ..reader import PsaReader
+
+
+class PSA_OT_import_sequences_from_text(Operator):
+    bl_idname = 'psa_import.sequences_select_from_text'
+    bl_label = 'Select By Text List'
+    bl_description = 'Select sequences by name from text list'
+    bl_options = {'INTERNAL', 'UNDO'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_import')
+        return len(pg.sequence_list) > 0
+
+    def invoke(self, context, event):
+        return context.window_manager.invoke_props_dialog(self, width=256)
+
+    def draw(self, context):
+        layout = self.layout
+        pg = getattr(context.scene, 'psa_import')
+        layout.label(icon='INFO', text='Each sequence name should be on a new line.')
+        layout.prop(pg, 'select_text', text='')
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_import')
+        if pg.select_text is None:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No text block selected')
+            return {'CANCELLED'}
+        contents = pg.select_text.as_string()
+        count = 0
+        for line in contents.split('\n'):
+            for sequence in pg.sequence_list:
+                if sequence.action_name == line:
+                    sequence.is_selected = True
+                    count += 1
+        self.report({'INFO'}, f'Selected {count} sequence(s)')
+        return {'FINISHED'}
+
+
+class PSA_OT_import_sequences_select_all(Operator):
+    bl_idname = 'psa_import.sequences_select_all'
+    bl_label = 'All'
+    bl_description = 'Select all sequences'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_import')
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
+        has_unselected_actions = any(map(lambda action: not action.is_selected, visible_sequences))
+        return len(visible_sequences) > 0 and has_unselected_actions
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_import')
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
+        for sequence in visible_sequences:
+            sequence.is_selected = True
+        return {'FINISHED'}
+
+
+class PSA_OT_import_sequences_deselect_all(Operator):
+    bl_idname = 'psa_import.sequences_deselect_all'
+    bl_label = 'None'
+    bl_description = 'Deselect all visible sequences'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_import')
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
+        has_selected_sequences = any(map(lambda sequence: sequence.is_selected, visible_sequences))
+        return len(visible_sequences) > 0 and has_selected_sequences
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_import')
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
+        for sequence in visible_sequences:
+            sequence.is_selected = False
+        return {'FINISHED'}
+
+
+def load_psa_file(context, filepath: str):
+    pg = context.scene.psa_import
+    pg.sequence_list.clear()
+    pg.psa.bones.clear()
+    pg.psa_error = ''
+    try:
+        # Read the file and populate the action list.
+        p = os.path.abspath(filepath)
+        psa_reader = PsaReader(p)
+        for sequence in psa_reader.sequences.values():
+            item = pg.sequence_list.add()
+            item.action_name = sequence.name.decode('windows-1252')
+        for psa_bone in psa_reader.bones:
+            item = pg.psa.bones.add()
+            item.bone_name = psa_bone.name.decode('windows-1252')
+    except Exception as e:
+        pg.psa_error = str(e)
+
+
+def on_psa_file_path_updated(cls, context):
+    load_psa_file(context, cls.filepath)
+
+
+class PSA_OT_import_multiple(Operator):
+    bl_idname = 'psa_import.import_multiple'
+    bl_label = 'Import PSA'
+    bl_description = 'Import multiple PSA files'
+    bl_options = {'INTERNAL', 'UNDO'}
+
+    directory: StringProperty(subtype='FILE_PATH', options={'SKIP_SAVE', 'HIDDEN'})
+    files: CollectionProperty(type=OperatorFileListElement, options={'SKIP_SAVE', 'HIDDEN'})
+
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_import')
+        warnings = []
+
+        for file in self.files:
+            psa_path = os.path.join(self.directory, file.name)
+            psa_reader = PsaReader(psa_path)
+            sequence_names = list(psa_reader.sequences.keys())
+
+            result = _import_psa(context, pg, psa_path, sequence_names, context.view_layer.objects.active)
+            result.warnings.extend(warnings)
+
+        if len(result.warnings) > 0:
+            message = f'Imported {len(sequence_names)} action(s) with {len(result.warnings)} warning(s)\n'
+            self.report({'INFO'}, message)
+            for warning in result.warnings:
+                self.report({'WARNING'}, warning)
+
+        self.report({'INFO'}, f'Imported {len(sequence_names)} action(s)')
+
+        return {'FINISHED'}
+
+    def invoke(self, context: Context, event):
+        # Make sure the selected object is an armature.
+        active_object = context.view_layer.objects.active
+        if active_object is None or active_object.type != 'ARMATURE':
+            self.report({'ERROR_INVALID_CONTEXT'}, 'The active object must be an armature')
+            return {'CANCELLED'}
+
+        # Show the import operator properties in a pop-up dialog (do not use the file selector).
+        context.window_manager.invoke_props_dialog(self)
+        return {'RUNNING_MODAL'}
+
+    def draw(self, context):
+        layout = self.layout
+        pg = getattr(context.scene, 'psa_import')
+        draw_psa_import_options_no_panels(layout, pg)
+
+
+def _import_psa(context,
+                pg,
+                filepath: str,
+                sequence_names: List[str],
+                armature_object: Object
+                ):
+    options = PsaImportOptions()
+    options.sequence_names = sequence_names
+    options.should_use_fake_user = pg.should_use_fake_user
+    options.should_stash = pg.should_stash
+    options.action_name_prefix = pg.action_name_prefix if pg.should_use_action_name_prefix else ''
+    options.should_overwrite = pg.should_overwrite
+    options.should_write_metadata = pg.should_write_metadata
+    options.should_write_keyframes = pg.should_write_keyframes
+    options.should_convert_to_samples = pg.should_convert_to_samples
+    options.bone_mapping_mode = pg.bone_mapping_mode
+    options.fps_source = pg.fps_source
+    options.fps_custom = pg.fps_custom
+    options.translation_scale = pg.translation_scale
+
+    warnings = []
+
+    if options.should_use_config_file:
+        # Read the PSA config file if it exists.
+        config_path = Path(filepath).with_suffix('.config')
+        if config_path.exists():
+            try:
+                options.psa_config = read_psa_config(sequence_names, str(config_path))
+            except Exception as e:
+                warnings.append(f'Failed to read PSA config file: {e}')
+
+    psa_reader = PsaReader(filepath)
+
+    result = import_psa(context, psa_reader, armature_object, options)
+    result.warnings.extend(warnings)
+
+    return result
+
+
+class PSA_OT_import(Operator, ImportHelper):
+    bl_idname = 'psa_import.import'
+    bl_label = 'Import'
+    bl_description = 'Import the selected animations into the scene as actions'
+    bl_options = {'INTERNAL', 'UNDO'}
+
+    filename_ext = '.psa'
+    filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for importing the PSA file',
+        maxlen=1024,
+        default='',
+        update=on_psa_file_path_updated)
+
+    @classmethod
+    def poll(cls, context):
+        active_object = context.view_layer.objects.active
+        if active_object is None or active_object.type != 'ARMATURE':
+            cls.poll_message_set('The active object must be an armature')
+            return False
+        return True
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_import')
+        sequence_names = [x.action_name for x in pg.sequence_list if x.is_selected]
+
+        if len(sequence_names) == 0:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No sequences selected')
+            return {'CANCELLED'}
+
+        result = _import_psa(context, pg, self.filepath, sequence_names, context.view_layer.objects.active)
+
+        if len(result.warnings) > 0:
+            message = f'Imported {len(sequence_names)} action(s) with {len(result.warnings)} warning(s)\n'
+            self.report({'WARNING'}, message)
+            for warning in result.warnings:
+                self.report({'WARNING'}, warning)
+        else:
+            self.report({'INFO'}, f'Imported {len(sequence_names)} action(s)')
+
+        return {'FINISHED'}
+
+    def invoke(self, context: Context, event: Event):
+        # Attempt to load the PSA file for the pre-selected file.
+        load_psa_file(context, self.filepath)
+
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+    def draw(self, context: Context):
+        layout = self.layout
+        pg = getattr(context.scene, 'psa_import')
+
+        sequences_header, sequences_panel = layout.panel('sequences_panel_id', default_closed=False)
+        sequences_header.label(text='Sequences')
+
+        if sequences_panel:
+            if pg.psa_error:
+                row = sequences_panel.row()
+                row.label(text='Select a PSA file', icon='ERROR')
+            else:
+                # Select buttons.
+                rows = max(3, min(len(pg.sequence_list), 10))
+
+                row = sequences_panel.row()
+                col = row.column()
+
+                row2 = col.row(align=True)
+                row2.label(text='Select')
+                row2.operator(PSA_OT_import_sequences_from_text.bl_idname, text='', icon='TEXT')
+                row2.operator(PSA_OT_import_sequences_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
+                row2.operator(PSA_OT_import_sequences_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+
+                col = col.row()
+                col.template_list('PSA_UL_import_sequences', '', pg, 'sequence_list', pg, 'sequence_list_index', rows=rows)
+
+            col = sequences_panel.column(heading='')
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'fps_source')
+            if pg.fps_source == 'CUSTOM':
+                col.prop(pg, 'fps_custom')
+            col.prop(pg, 'should_overwrite')
+            col.prop(pg, 'should_use_action_name_prefix')
+            if pg.should_use_action_name_prefix:
+                col.prop(pg, 'action_name_prefix')
+
+        data_header, data_panel = layout.panel('data_panel_id', default_closed=False)
+        data_header.label(text='Data')
+
+        if data_panel:
+            col = data_panel.column(heading='Write')
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'should_write_keyframes')
+            col.prop(pg, 'should_write_metadata')
+
+            if pg.should_write_keyframes:
+                col = col.column(heading='Keyframes')
+                col.use_property_split = True
+                col.use_property_decorate = False
+                col.prop(pg, 'should_convert_to_samples')
+
+        advanced_header, advanced_panel = layout.panel('advanced_panel_id', default_closed=True)
+        advanced_header.label(text='Advanced')
+
+        if advanced_panel:
+            col = advanced_panel.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'bone_mapping_mode')
+
+            col = advanced_panel.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'translation_scale', text='Translation Scale')
+
+            col = advanced_panel.column(heading='Options')
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'should_use_fake_user')
+            col.prop(pg, 'should_stash')
+            col.prop(pg, 'should_use_config_file')
+
+
+def draw_psa_import_options_no_panels(layout, pg):
+    col = layout.column(heading='Sequences')
+    col.use_property_split = True
+    col.use_property_decorate = False
+    col.prop(pg, 'fps_source')
+    if pg.fps_source == 'CUSTOM':
+        col.prop(pg, 'fps_custom')
+    col.prop(pg, 'should_overwrite')
+    col.prop(pg, 'should_use_action_name_prefix')
+    if pg.should_use_action_name_prefix:
+        col.prop(pg, 'action_name_prefix')
+
+    col = layout.column(heading='Write')
+    col.use_property_split = True
+    col.use_property_decorate = False
+    col.prop(pg, 'should_write_keyframes')
+    col.prop(pg, 'should_write_metadata')
+
+    if pg.should_write_keyframes:
+        col = col.column(heading='Keyframes')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_convert_to_samples')
+
+    col = layout.column()
+    col.use_property_split = True
+    col.use_property_decorate = False
+    col.prop(pg, 'bone_mapping_mode')
+    col.prop(pg, 'translation_scale')
+
+    col = layout.column(heading='Options')
+    col.use_property_split = True
+    col.use_property_decorate = False
+    col.prop(pg, 'should_use_fake_user')
+    col.prop(pg, 'should_stash')
+    col.prop(pg, 'should_use_config_file')
+
+
+class PSA_FH_import(FileHandler):
+    bl_idname = 'PSA_FH_import'
+    bl_label = 'File handler for Unreal PSA import'
+    bl_import_operator = 'psa_import.import_multiple'
+    bl_export_operator = 'psa_export.export'
+    bl_file_extensions = '.psa'
+
+    @classmethod
+    def poll_drop(cls, context: Context):
+        return context.area and context.area.type == 'VIEW_3D'
+
+
+classes = (
+    PSA_OT_import_sequences_select_all,
+    PSA_OT_import_sequences_deselect_all,
+    PSA_OT_import_sequences_from_text,
+    PSA_OT_import,
+    PSA_OT_import_multiple,
+    PSA_FH_import,
+)

io_scene_psk_psa/psa/import_/properties.py

@@ -0,0 +1,161 @@
+import re
+from fnmatch import fnmatch
+from typing import List
+
+from bpy.props import StringProperty, BoolProperty, CollectionProperty, IntProperty, PointerProperty, EnumProperty, \
+    FloatProperty
+from bpy.types import PropertyGroup, Text
+
+empty_set = set()
+
+
+class PSA_PG_import_action_list_item(PropertyGroup):
+    action_name: StringProperty(options=empty_set)
+    is_selected: BoolProperty(default=True, options=empty_set)
+
+
+class PSA_PG_bone(PropertyGroup):
+    bone_name: StringProperty(options=empty_set)
+
+
+class PSA_PG_data(PropertyGroup):
+    bones: CollectionProperty(type=PSA_PG_bone)
+    sequence_count: IntProperty(default=0)
+
+
+class PSA_PG_import(PropertyGroup):
+    psa_error: StringProperty(default='')
+    psa: PointerProperty(type=PSA_PG_data)
+    sequence_list: CollectionProperty(type=PSA_PG_import_action_list_item)
+    sequence_list_index: IntProperty(name='', default=0)
+    should_use_fake_user: BoolProperty(default=True, name='Fake User',
+                                       description='Assign each imported action a fake user so that the data block is '
+                                                   'saved even it has no users',
+                                       options=empty_set)
+    should_use_config_file: BoolProperty(default=True, name='Use Config File',
+                                            description='Use the .config file that is sometimes generated when the PSA '
+                                                        'file is exported from UEViewer. This file contains '
+                                                        'options that can be used to filter out certain bones tracks '
+                                                        'from the imported actions',
+                                            options=empty_set)
+    should_stash: BoolProperty(default=False, name='Stash',
+                               description='Stash each imported action as a strip on a new non-contributing NLA track',
+                               options=empty_set)
+    should_use_action_name_prefix: BoolProperty(default=False, name='Prefix Action Name', options=empty_set)
+    action_name_prefix: StringProperty(default='', name='Prefix', options=empty_set)
+    should_overwrite: BoolProperty(default=False, name='Overwrite', options=empty_set,
+                                   description='If an action with a matching name already exists, the existing action '
+                                               'will have it\'s data overwritten instead of a new action being created')
+    should_write_keyframes: BoolProperty(default=True, name='Keyframes', options=empty_set)
+    should_write_metadata: BoolProperty(default=True, name='Metadata', options=empty_set,
+                                        description='Additional data will be written to the custom properties of the '
+                                                    'Action (e.g., frame rate)')
+    sequence_filter_name: StringProperty(default='', options={'TEXTEDIT_UPDATE'})
+    sequence_filter_is_selected: BoolProperty(default=False, options=empty_set, name='Only Show Selected',
+                                              description='Only show selected sequences')
+    sequence_use_filter_invert: BoolProperty(default=False, options=empty_set)
+    sequence_use_filter_regex: BoolProperty(default=False, name='Regular Expression',
+                                            description='Filter using regular expressions', options=empty_set)
+    select_text: PointerProperty(type=Text)
+    should_convert_to_samples: BoolProperty(
+        default=False,
+        name='Convert to Samples',
+        description='Convert keyframes to read-only samples. '
+                    'Recommended if you do not plan on editing the actions directly'
+    )
+    bone_mapping_mode: EnumProperty(
+        name='Bone Mapping',
+        options=empty_set,
+        description='The method by which bones from the incoming PSA file are mapped to the armature',
+        items=(
+            ('EXACT', 'Exact', 'Bone names must match exactly.', 'EXACT', 0),
+            ('CASE_INSENSITIVE', 'Case Insensitive', 'Bones names must match, ignoring case (e.g., the bone PSA bone '
+             '\'root\' can be mapped to the armature bone \'Root\')', 'CASE_INSENSITIVE', 1),
+        ),
+        default='CASE_INSENSITIVE'
+    )
+    fps_source: EnumProperty(name='FPS Source', items=(
+        ('SEQUENCE', 'Sequence', 'The sequence frame rate matches the original frame rate', 'ACTION', 0),
+        ('SCENE', 'Scene', 'The sequence is resampled to the frame rate of the scene', 'SCENE_DATA', 1),
+        ('CUSTOM', 'Custom', 'The sequence is resampled to a custom frame rate', 2),
+    ))
+    fps_custom: FloatProperty(
+        default=30.0,
+        name='Custom FPS',
+        description='The frame rate to which the imported sequences will be resampled to',
+        options=empty_set,
+        min=1.0,
+        soft_min=1.0,
+        soft_max=60.0,
+        step=100,
+    )
+    compression_ratio_source: EnumProperty(name='Compression Ratio Source', items=(
+        ('ACTION', 'Action', 'The compression ratio is sourced from the action metadata', 'ACTION', 0),
+        ('CUSTOM', 'Custom', 'The compression ratio is set to a custom value', 1),
+    ))
+    compression_ratio_custom: FloatProperty(
+        default=1.0,
+        name='Custom Compression Ratio',
+        description='The compression ratio to apply to the imported sequences',
+        options=empty_set,
+        min=0.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        step=0.0625,
+    )
+    translation_scale: FloatProperty(
+        name='Translation Scale',
+        default=1.0,
+        description='Scale factor for bone translation values. Use this when the scale of the armature does not match the PSA file'
+    )
+
+
+def filter_sequences(pg: PSA_PG_import, sequences) -> List[int]:
+    bitflag_filter_item = 1 << 30
+    flt_flags = [bitflag_filter_item] * len(sequences)
+
+    if pg.sequence_filter_name is not None:
+        # Filter name is non-empty.
+        if pg.sequence_use_filter_regex:
+            # Use regular expression. If regex pattern doesn't compile, just ignore it.
+            try:
+                regex = re.compile(pg.sequence_filter_name)
+                for i, sequence in enumerate(sequences):
+                    if not regex.match(sequence.action_name):
+                        flt_flags[i] &= ~bitflag_filter_item
+            except re.error:
+                pass
+        else:
+            # User regular text matching.
+            for i, sequence in enumerate(sequences):
+                if not fnmatch(sequence.action_name, f'*{pg.sequence_filter_name}*'):
+                    flt_flags[i] &= ~bitflag_filter_item
+
+    if pg.sequence_filter_is_selected:
+        for i, sequence in enumerate(sequences):
+            if not sequence.is_selected:
+                flt_flags[i] &= ~bitflag_filter_item
+
+    if pg.sequence_use_filter_invert:
+        # Invert filter flags for all items.
+        for i, sequence in enumerate(sequences):
+            flt_flags[i] ^= bitflag_filter_item
+
+    return flt_flags
+
+
+def get_visible_sequences(pg: PSA_PG_import, sequences) -> List[PSA_PG_import_action_list_item]:
+    bitflag_filter_item = 1 << 30
+    visible_sequences = []
+    for i, flag in enumerate(filter_sequences(pg, sequences)):
+        if bool(flag & bitflag_filter_item):
+            visible_sequences.append(sequences[i])
+    return visible_sequences
+
+
+classes = (
+    PSA_PG_import_action_list_item,
+    PSA_PG_bone,
+    PSA_PG_data,
+    PSA_PG_import,
+)

io_scene_psk_psa/psa/import_/ui.py

@@ -0,0 +1,49 @@
+import bpy
+from bpy.types import UIList
+
+from .properties import filter_sequences
+
+
+class PSA_UL_sequences_mixin(UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_property, index, flt_flag):
+        row = layout.row(align=True)
+        split = row.split(align=True, factor=0.75)
+        column = split.row(align=True)
+        column.alignment = 'LEFT'
+        column.prop(item, 'is_selected', icon_only=True)
+        column.label(text=getattr(item, 'action_name'))
+
+    def draw_filter(self, context, layout):
+        pg = getattr(context.scene, 'psa_import')
+        row = layout.row()
+        sub_row = row.row(align=True)
+        sub_row.prop(pg, 'sequence_filter_name', text='')
+        sub_row.prop(pg, 'sequence_use_filter_invert', text='', icon='ARROW_LEFTRIGHT')
+        sub_row.prop(pg, 'sequence_use_filter_regex', text='', icon='SORTBYEXT')
+        sub_row.prop(pg, 'sequence_filter_is_selected', text='', icon='CHECKBOX_HLT')
+
+    def filter_items(self, context, data, property_):
+        pg = getattr(context.scene, 'psa_import')
+        sequences = getattr(data, property_)
+        flt_flags = filter_sequences(pg, sequences)
+        flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(sequences, 'action_name')
+        return flt_flags, flt_neworder
+
+
+class PSA_UL_sequences(PSA_UL_sequences_mixin):
+    pass
+
+
+class PSA_UL_import_sequences(PSA_UL_sequences_mixin):
+    pass
+
+
+class PSA_UL_import_actions(PSA_UL_sequences_mixin):
+    pass
+
+
+classes = (
+    PSA_UL_sequences,
+    PSA_UL_import_sequences,
+    PSA_UL_import_actions,
+)

io_scene_psk_psa/psa/importer.py

@@ -1,17 +1,12 @@
-import fnmatch
-import os
-import re
 import typing
-from collections import Counter
 from typing import List, Optional
 
 import bpy
-import numpy
+import numpy as np
-from bpy.props import StringProperty, BoolProperty, CollectionProperty, PointerProperty, IntProperty, EnumProperty
+from bpy.types import FCurve, Object, Context
-from bpy.types import Operator, UIList, PropertyGroup, Panel, FCurve
-from bpy_extras.io_utils import ImportHelper
 from mathutils import Vector, Quaternion
 
+from .config import PsaConfig, REMOVE_TRACK_LOCATION, REMOVE_TRACK_ROTATION
 from .data import Psa
 from .reader import PsaReader
 
@@ -27,6 +22,11 @@ class PsaImportOptions(object):
         self.action_name_prefix = ''
         self.should_convert_to_samples = False
         self.bone_mapping_mode = 'CASE_INSENSITIVE'
+        self.fps_source = 'SEQUENCE'
+        self.fps_custom: float = 30.0
+        self.translation_scale: float = 1.0
+        self.should_use_config_file = True
+        self.psa_config: PsaConfig = PsaConfig()
 
 
 class ImportBone(object):
@@ -35,28 +35,28 @@ class ImportBone(object):
         self.parent: Optional[ImportBone] = None
         self.armature_bone = None
         self.pose_bone = None
-        self.orig_loc: Vector = Vector()
+        self.original_location: Vector = Vector()
-        self.orig_quat: Quaternion = Quaternion()
+        self.original_rotation: Quaternion = Quaternion()
-        self.post_quat: Quaternion = Quaternion()
+        self.post_rotation: Quaternion = Quaternion()
         self.fcurves: List[FCurve] = []
 
 
-def calculate_fcurve_data(import_bone: ImportBone, key_data: typing.Iterable[float]):
+def _calculate_fcurve_data(import_bone: ImportBone, key_data: typing.Iterable[float]):
     # Convert world-space transforms to local-space transforms.
     key_rotation = Quaternion(key_data[0:4])
     key_location = Vector(key_data[4:])
-    q = import_bone.post_quat.copy()
+    q = import_bone.post_rotation.copy()
-    q.rotate(import_bone.orig_quat)
+    q.rotate(import_bone.original_rotation)
-    quat = q
+    rotation = q
-    q = import_bone.post_quat.copy()
+    q = import_bone.post_rotation.copy()
     if import_bone.parent is None:
         q.rotate(key_rotation.conjugated())
     else:
         q.rotate(key_rotation)
-    quat.rotate(q.conjugated())
+    rotation.rotate(q.conjugated())
-    loc = key_location - import_bone.orig_loc
+    location = key_location - import_bone.original_location
-    loc.rotate(import_bone.post_quat.conjugated())
+    location.rotate(import_bone.post_rotation.conjugated())
-    return quat.w, quat.x, quat.y, quat.z, loc.x, loc.y, loc.z
+    return rotation.w, rotation.x, rotation.y, rotation.z, location.x, location.y, location.z
 
 
 class PsaImportResult:
@@ -64,44 +64,103 @@ class PsaImportResult:
         self.warnings: List[str] = []
 
 
-def import_psa(psa_reader: PsaReader, armature_object: bpy.types.Object, options: PsaImportOptions) -> PsaImportResult:
+def _get_armature_bone_index_for_psa_bone(psa_bone_name: str, armature_bone_names: List[str], bone_mapping_mode: str = 'EXACT') -> Optional[int]:
+    """
+    @param psa_bone_name: The name of the PSA bone.
+    @param armature_bone_names: The names of the bones in the armature.
+    @param bone_mapping_mode: One of 'EXACT' or 'CASE_INSENSITIVE'.
+    @return: The index of the armature bone that corresponds to the given PSA bone, or None if no such bone exists.
+    """
+    for armature_bone_index, armature_bone_name in enumerate(armature_bone_names):
+        if bone_mapping_mode == 'CASE_INSENSITIVE':
+            if armature_bone_name.lower() == psa_bone_name.lower():
+                return armature_bone_index
+        else:
+            if armature_bone_name == psa_bone_name:
+                return armature_bone_index
+    return None
+
+def _get_sample_frame_times(source_frame_count: int, frame_step: float) -> typing.Iterable[float]:
+    # TODO: for correctness, we should also emit the target frame time as well (because the last frame can be a
+    #  fractional frame).
+    time = 0.0
+    while time < source_frame_count - 1:
+        yield time
+        time += frame_step
+    yield source_frame_count - 1
+
+
+def _resample_sequence_data_matrix(sequence_data_matrix: np.ndarray, frame_step: float = 1.0) -> np.ndarray:
+    """
+    Resamples the sequence data matrix to the target frame count.
+    @param sequence_data_matrix: FxBx7 matrix where F is the number of frames, B is the number of bones, and X is the
+    number of data elements per bone.
+    @param frame_step: The step between frames in the resampled sequence.
+    @return: The resampled sequence data matrix, or sequence_data_matrix if no resampling is necessary.
+    """
+    if frame_step == 1.0:
+        # No resampling is necessary.
+        return sequence_data_matrix
+
+    source_frame_count, bone_count = sequence_data_matrix.shape[:2]
+    sample_frame_times = list(_get_sample_frame_times(source_frame_count, frame_step))
+    target_frame_count = len(sample_frame_times)
+    resampled_sequence_data_matrix = np.zeros((target_frame_count, bone_count, 7), dtype=float)
+
+    for sample_frame_index, sample_frame_time in enumerate(sample_frame_times):
+        frame_index = int(sample_frame_time)
+        if sample_frame_time % 1.0 == 0.0:
+            # Sample time has no fractional part, so just copy the frame.
+            resampled_sequence_data_matrix[sample_frame_index, :, :] = sequence_data_matrix[frame_index, :, :]
+        else:
+            # Sample time has a fractional part, so interpolate between two frames.
+            next_frame_index = frame_index + 1
+            for bone_index in range(bone_count):
+                source_frame_1_data = sequence_data_matrix[frame_index, bone_index, :]
+                source_frame_2_data = sequence_data_matrix[next_frame_index, bone_index, :]
+                factor = sample_frame_time - frame_index
+                q = Quaternion((source_frame_1_data[:4])).slerp(Quaternion((source_frame_2_data[:4])), factor)
+                q.normalize()
+                l = Vector(source_frame_1_data[4:]).lerp(Vector(source_frame_2_data[4:]), factor)
+                resampled_sequence_data_matrix[sample_frame_index, bone_index, :] = q.w, q.x, q.y, q.z, l.x, l.y, l.z
+
+    return resampled_sequence_data_matrix
+
+
+def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object, options: PsaImportOptions) -> PsaImportResult:
     result = PsaImportResult()
-    sequences = map(lambda x: psa_reader.sequences[x], options.sequence_names)
+    sequences = [psa_reader.sequences[x] for x in options.sequence_names]
     armature_data = typing.cast(bpy.types.Armature, armature_object.data)
 
     # Create an index mapping from bones in the PSA to bones in the target armature.
     psa_to_armature_bone_indices = {}
+    armature_to_psa_bone_indices = {}
     armature_bone_names = [x.name for x in armature_data.bones]
     psa_bone_names = []
+    duplicate_mappings = []
+
     for psa_bone_index, psa_bone in enumerate(psa_reader.bones):
         psa_bone_name: str = psa_bone.name.decode('windows-1252')
-        try:
+        armature_bone_index = _get_armature_bone_index_for_psa_bone(psa_bone_name, armature_bone_names, options.bone_mapping_mode)
-            psa_to_armature_bone_indices[psa_bone_index] = armature_bone_names.index(psa_bone_name)
+        if armature_bone_index is not None:
-        except ValueError:
+            # Ensure that no other PSA bone has been mapped to this armature bone yet.
-            # PSA bone could not be mapped directly to an armature bone by name.
+            if armature_bone_index not in armature_to_psa_bone_indices:
-            # Attempt to create a bone mapping by ignoring the case of the names.
+                psa_to_armature_bone_indices[psa_bone_index] = armature_bone_index
-            if options.bone_mapping_mode == 'CASE_INSENSITIVE':
+                armature_to_psa_bone_indices[armature_bone_index] = psa_bone_index
-                for armature_bone_index, armature_bone_name in enumerate(armature_bone_names):
+            else:
-                    if armature_bone_name.upper() == psa_bone_name.upper():
+                # This armature bone has already been mapped to a PSA bone.
-                        psa_to_armature_bone_indices[psa_bone_index] = armature_bone_index
+                duplicate_mappings.append((psa_bone_index, armature_bone_index, armature_to_psa_bone_indices[armature_bone_index]))
-                        psa_bone_name = armature_bone_name
+            psa_bone_names.append(armature_bone_names[armature_bone_index])
-                        break
+        else:
-        psa_bone_names.append(psa_bone_name)
+            psa_bone_names.append(psa_bone_name)
 
-    # Remove ambiguous bone mappings (where multiple PSA bones correspond to the same armature bone).
+    # Warn about duplicate bone mappings.
-    armature_bone_index_counts = Counter(psa_to_armature_bone_indices.values())
+    if len(duplicate_mappings) > 0:
-    for armature_bone_index, count in armature_bone_index_counts.items():
+        for (psa_bone_index, armature_bone_index, mapped_psa_bone_index) in duplicate_mappings:
-        if count > 1:
+            psa_bone_name = psa_bone_names[psa_bone_index]
-            psa_bone_indices = []
+            armature_bone_name = armature_bone_names[armature_bone_index]
-            for psa_bone_index, mapped_bone_index in psa_to_armature_bone_indices:
+            mapped_psa_bone_name = psa_bone_names[mapped_psa_bone_index]
-                if mapped_bone_index == armature_bone_index:
+            result.warnings.append(f'PSA bone {psa_bone_index} ({psa_bone_name}) could not be mapped to armature bone {armature_bone_index} ({armature_bone_name}) because the armature bone is already mapped to PSA bone {mapped_psa_bone_index} ({mapped_psa_bone_name})')
-                    psa_bone_indices.append(psa_bone_index)
-            ambiguous_psa_bone_names = list(sorted([psa_bone_names[x] for x in psa_bone_indices]))
-            result.warnings.append(
-                f'Ambiguous mapping for bone {armature_bone_names[armature_bone_index]}!\n'
-                f'The following PSA bones all map to the same armature bone: {ambiguous_psa_bone_names}\n'
-                f'These bones will be ignored.'
-            )
 
     # Report if there are missing bones in the target armature.
     missing_bone_names = set(psa_bone_names).difference(set(armature_bone_names))
@@ -115,7 +174,7 @@ def import_psa(psa_reader: PsaReader, armature_object: bpy.types.Object, options
 
     # Create intermediate bone data for import operations.
     import_bones = []
-    import_bones_dict = dict()
+    psa_bone_names_to_import_bones = dict()
 
     for (psa_bone_index, psa_bone), psa_bone_name in zip(enumerate(psa_reader.bones), psa_bone_names):
         if psa_bone_index not in psa_to_armature_bone_indices:
@@ -125,68 +184,99 @@ def import_psa(psa_reader: PsaReader, armature_object: bpy.types.Object, options
         import_bone = ImportBone(psa_bone)
         import_bone.armature_bone = armature_data.bones[psa_bone_name]
         import_bone.pose_bone = armature_object.pose.bones[psa_bone_name]
-        import_bones_dict[psa_bone_name] = import_bone
+        psa_bone_names_to_import_bones[psa_bone_name] = import_bone
         import_bones.append(import_bone)
 
+    bones_with_missing_parents = []
+
     for import_bone in filter(lambda x: x is not None, import_bones):
         armature_bone = import_bone.armature_bone
-        if armature_bone.parent is not None and armature_bone.parent.name in psa_bone_names:
+        has_parent = armature_bone.parent is not None
-            import_bone.parent = import_bones_dict[armature_bone.parent.name]
+        if has_parent:
-        # Calculate the original location & rotation of each bone (in world-space maybe?)
+            if armature_bone.parent.name in psa_bone_names:
-        if armature_bone.get('orig_quat') is not None:
+                import_bone.parent = psa_bone_names_to_import_bones[armature_bone.parent.name]
-            # TODO: ideally we don't rely on bone auxiliary data like this, the non-aux data path is incorrect
-            # (animations are flipped 180 around Z)
-            import_bone.orig_quat = Quaternion(armature_bone['orig_quat'])
-            import_bone.orig_loc = Vector(armature_bone['orig_loc'])
-            import_bone.post_quat = Quaternion(armature_bone['post_quat'])
-        else:
-            if import_bone.parent is not None:
-                import_bone.orig_loc = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
-                import_bone.orig_loc.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
-                import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
-                import_bone.orig_quat.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
-                import_bone.orig_quat.conjugate()
             else:
-                import_bone.orig_loc = armature_bone.matrix_local.translation.copy()
+                # Add a warning if the parent bone is not in the PSA.
-                import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
+                bones_with_missing_parents.append(armature_bone)
-            import_bone.post_quat = import_bone.orig_quat.conjugated()
+        # Calculate the original location & rotation of each bone (in world-space maybe?)
+        if has_parent:
+            import_bone.original_location = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
+            import_bone.original_location.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
+            import_bone.original_rotation = armature_bone.matrix_local.to_quaternion()
+            import_bone.original_rotation.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
+            import_bone.original_rotation.conjugate()
+        else:
+            import_bone.original_location = armature_bone.matrix_local.translation.copy()
+            import_bone.original_rotation = armature_bone.matrix_local.to_quaternion().conjugated()
+
+        import_bone.post_rotation = import_bone.original_rotation.conjugated()
+
+    # Warn about bones with missing parents.
+    if len(bones_with_missing_parents) > 0:
+        count = len(bones_with_missing_parents)
+        message = f'{count} bone(s) have parents that are not present in the PSA:\n' + str([x.name for x in bones_with_missing_parents])
+        result.warnings.append(message)
+
+    context.window_manager.progress_begin(0, len(sequences))
 
     # Create and populate the data for new sequences.
     actions = []
-    for sequence in sequences:
+    for sequence_index, sequence in enumerate(sequences):
         # Add the action.
         sequence_name = sequence.name.decode('windows-1252')
         action_name = options.action_name_prefix + sequence_name
 
+        # Get the bone track flags for this sequence, or an empty dictionary if none exist.
+        sequence_bone_track_flags = dict()
+        if sequence_name in options.psa_config.sequence_bone_flags.keys():
+            sequence_bone_track_flags = options.psa_config.sequence_bone_flags[sequence_name]
+
         if options.should_overwrite and action_name in bpy.data.actions:
             action = bpy.data.actions[action_name]
         else:
             action = bpy.data.actions.new(name=action_name)
 
+        # Calculate the target FPS.
+        match options.fps_source:
+            case 'CUSTOM':
+                target_fps = options.fps_custom
+            case 'SCENE':
+                target_fps = context.scene.render.fps
+            case 'SEQUENCE':
+                target_fps = sequence.fps
+            case _:
+                raise ValueError(f'Unknown FPS source: {options.fps_source}')
+
         if options.should_write_keyframes:
-            # Remove existing f-curves (replace with action.fcurves.clear() in Blender 3.2)
+            # Remove existing f-curves.
-            while len(action.fcurves) > 0:
+            action.fcurves.clear()
-                action.fcurves.remove(action.fcurves[-1])
 
             # Create f-curves for the rotation and location of each bone.
             for psa_bone_index, armature_bone_index in psa_to_armature_bone_indices.items():
+                bone_track_flags = sequence_bone_track_flags.get(psa_bone_index, 0)
                 import_bone = import_bones[psa_bone_index]
                 pose_bone = import_bone.pose_bone
                 rotation_data_path = pose_bone.path_from_id('rotation_quaternion')
                 location_data_path = pose_bone.path_from_id('location')
+                add_rotation_fcurves = (bone_track_flags & REMOVE_TRACK_ROTATION) == 0
+                add_location_fcurves = (bone_track_flags & REMOVE_TRACK_LOCATION) == 0
                 import_bone.fcurves = [
-                    action.fcurves.new(rotation_data_path, index=0, action_group=pose_bone.name),  # Qw
+                    action.fcurves.new(rotation_data_path, index=0, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qw
-                    action.fcurves.new(rotation_data_path, index=1, action_group=pose_bone.name),  # Qx
+                    action.fcurves.new(rotation_data_path, index=1, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qx
-                    action.fcurves.new(rotation_data_path, index=2, action_group=pose_bone.name),  # Qy
+                    action.fcurves.new(rotation_data_path, index=2, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qy
-                    action.fcurves.new(rotation_data_path, index=3, action_group=pose_bone.name),  # Qz
+                    action.fcurves.new(rotation_data_path, index=3, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qz
-                    action.fcurves.new(location_data_path, index=0, action_group=pose_bone.name),  # Lx
+                    action.fcurves.new(location_data_path, index=0, action_group=pose_bone.name) if add_location_fcurves else None,  # Lx
-                    action.fcurves.new(location_data_path, index=1, action_group=pose_bone.name),  # Ly
+                    action.fcurves.new(location_data_path, index=1, action_group=pose_bone.name) if add_location_fcurves else None,  # Ly
-                    action.fcurves.new(location_data_path, index=2, action_group=pose_bone.name),  # Lz
+                    action.fcurves.new(location_data_path, index=2, action_group=pose_bone.name) if add_location_fcurves else None,  # Lz
                 ]
 
             # Read the sequence data matrix from the PSA.
             sequence_data_matrix = psa_reader.read_sequence_data_matrix(sequence_name)
 
+            if options.translation_scale != 1.0:
+                # Scale the translation data.
+                sequence_data_matrix[:, :, 4:] *= options.translation_scale
+
             # Convert the sequence's data from world-space to local-space.
             for bone_index, import_bone in enumerate(import_bones):
                 if import_bone is None:
@@ -195,18 +285,30 @@ def import_psa(psa_reader: PsaReader, armature_object: bpy.types.Object, options
                     # This bone has writeable keyframes for this frame.
                     key_data = sequence_data_matrix[frame_index, bone_index]
                     # Calculate the local-space key data for the bone.
-                    sequence_data_matrix[frame_index, bone_index] = calculate_fcurve_data(import_bone, key_data)
+                    sequence_data_matrix[frame_index, bone_index] = _calculate_fcurve_data(import_bone, key_data)
+
+            # Resample the sequence data to the target FPS.
+            # If the target frame count is the same as the source frame count, this will be a no-op.
+            resampled_sequence_data_matrix = _resample_sequence_data_matrix(sequence_data_matrix,
+                                                                            frame_step=sequence.fps / target_fps)
 
             # Write the keyframes out.
-            fcurve_data = numpy.zeros(2 * sequence.frame_count, dtype=float)
+            # Note that the f-curve data consists of alternating time and value data.
-            fcurve_data[0::2] = range(sequence.frame_count)
+            target_frame_count = resampled_sequence_data_matrix.shape[0]
+            fcurve_data = np.zeros(2 * target_frame_count, dtype=float)
+            fcurve_data[0::2] = range(0, target_frame_count)
+
             for bone_index, import_bone in enumerate(import_bones):
                 if import_bone is None:
                     continue
                 for fcurve_index, fcurve in enumerate(import_bone.fcurves):
-                    fcurve_data[1::2] = sequence_data_matrix[:, bone_index, fcurve_index]
+                    if fcurve is None:
-                    fcurve.keyframe_points.add(sequence.frame_count)
+                        continue
+                    fcurve_data[1::2] = resampled_sequence_data_matrix[:, bone_index, fcurve_index]
+                    fcurve.keyframe_points.add(target_frame_count)
                     fcurve.keyframe_points.foreach_set('co', fcurve_data)
+                    for fcurve_keyframe in fcurve.keyframe_points:
+                        fcurve_keyframe.interpolation = 'LINEAR'
 
             if options.should_convert_to_samples:
                 # Bake the curve to samples.
@@ -215,13 +317,14 @@ def import_psa(psa_reader: PsaReader, armature_object: bpy.types.Object, options
 
         # Write meta-data.
         if options.should_write_metadata:
-            action['psa_sequence_name'] = sequence_name
+            action.psa_export.fps = target_fps
-            action['psa_sequence_fps'] = sequence.fps
 
         action.use_fake_user = options.should_use_fake_user
 
         actions.append(action)
 
+        context.window_manager.progress_update(sequence_index)
+
     # If the user specifies, store the new animations as strips on a non-contributing NLA track.
     if options.should_stash:
         if armature_object.animation_data is None:
@@ -232,458 +335,6 @@ def import_psa(psa_reader: PsaReader, armature_object: bpy.types.Object, options
             nla_track.mute = True
             nla_track.strips.new(name=action.name, start=0, action=action)
 
+    context.window_manager.progress_end()
+
     return result
-
-
-empty_set = set()
-
-
-class PsaImportActionListItem(PropertyGroup):
-    action_name: StringProperty(options=empty_set)
-    is_selected: BoolProperty(default=False, options=empty_set)
-
-
-def load_psa_file(context):
-    pg = context.scene.psa_import
-    pg.sequence_list.clear()
-    pg.psa.bones.clear()
-    pg.psa_error = ''
-    try:
-        # Read the file and populate the action list.
-        p = os.path.abspath(pg.psa_file_path)
-        psa_reader = PsaReader(p)
-        for sequence in psa_reader.sequences.values():
-            item = pg.sequence_list.add()
-            item.action_name = sequence.name.decode('windows-1252')
-        for psa_bone in psa_reader.bones:
-            item = pg.psa.bones.add()
-            item.bone_name = psa_bone.name.decode('windows-1252')
-    except Exception as e:
-        pg.psa_error = str(e)
-
-
-def on_psa_file_path_updated(property_, context):
-    load_psa_file(context)
-
-
-class PsaBonePropertyGroup(PropertyGroup):
-    bone_name: StringProperty(options=empty_set)
-
-
-class PsaDataPropertyGroup(PropertyGroup):
-    bones: CollectionProperty(type=PsaBonePropertyGroup)
-    sequence_count: IntProperty(default=0)
-
-
-class PsaImportPropertyGroup(PropertyGroup):
-    psa_file_path: StringProperty(default='', options=empty_set, update=on_psa_file_path_updated, name='PSA File Path')
-    psa_error: StringProperty(default='')
-    psa: PointerProperty(type=PsaDataPropertyGroup)
-    sequence_list: CollectionProperty(type=PsaImportActionListItem)
-    sequence_list_index: IntProperty(name='', default=0)
-    should_use_fake_user: BoolProperty(default=True, name='Fake User',
-                                       description='Assign each imported action a fake user so that the data block is '
-                                                   'saved even it has no users',
-                                       options=empty_set)
-    should_stash: BoolProperty(default=False, name='Stash',
-                               description='Stash each imported action as a strip on a new non-contributing NLA track',
-                               options=empty_set)
-    should_use_action_name_prefix: BoolProperty(default=False, name='Prefix Action Name', options=empty_set)
-    action_name_prefix: StringProperty(default='', name='Prefix', options=empty_set)
-    should_overwrite: BoolProperty(default=False, name='Reuse Existing Actions', options=empty_set,
-                                   description='If an action with a matching name already exists, the existing action '
-                                               'will have it\'s data overwritten instead of a new action being created')
-    should_write_keyframes: BoolProperty(default=True, name='Keyframes', options=empty_set)
-    should_write_metadata: BoolProperty(default=True, name='Metadata', options=empty_set,
-                                        description='Additional data will be written to the custom properties of the '
-                                                    'Action (e.g., frame rate)')
-    sequence_filter_name: StringProperty(default='', options={'TEXTEDIT_UPDATE'})
-    sequence_filter_is_selected: BoolProperty(default=False, options=empty_set, name='Only Show Selected',
-                                              description='Only show selected sequences')
-    sequence_use_filter_invert: BoolProperty(default=False, options=empty_set)
-    sequence_use_filter_regex: BoolProperty(default=False, name='Regular Expression',
-                                            description='Filter using regular expressions', options=empty_set)
-    select_text: PointerProperty(type=bpy.types.Text)
-    should_convert_to_samples: BoolProperty(
-        default=False,
-        name='Convert to Samples',
-        description='Convert keyframes to read-only samples. '
-                    'Recommended if you do not plan on editing the actions directly'
-    )
-    bone_mapping_mode: EnumProperty(
-        name='Bone Mapping',
-        options=empty_set,
-        description='The method by which bones from the incoming PSA file are mapped to the armature',
-        items=(
-            ('EXACT', 'Exact', 'Bone names must match exactly.', 'EXACT', 0),
-            ('CASE_INSENSITIVE', 'Case Insensitive', 'Bones names must match, ignoring case (e.g., the bone PSA bone '
-             '\'root\' can be mapped to the armature bone \'Root\')', 'CASE_INSENSITIVE', 1),
-        )
-    )
-
-
-def filter_sequences(pg: PsaImportPropertyGroup, sequences) -> List[int]:
-    bitflag_filter_item = 1 << 30
-    flt_flags = [bitflag_filter_item] * len(sequences)
-
-    if pg.sequence_filter_name is not None:
-        # Filter name is non-empty.
-        if pg.sequence_use_filter_regex:
-            # Use regular expression. If regex pattern doesn't compile, just ignore it.
-            try:
-                regex = re.compile(pg.sequence_filter_name)
-                for i, sequence in enumerate(sequences):
-                    if not regex.match(sequence.action_name):
-                        flt_flags[i] &= ~bitflag_filter_item
-            except re.error:
-                pass
-        else:
-            # User regular text matching.
-            for i, sequence in enumerate(sequences):
-                if not fnmatch.fnmatch(sequence.action_name, f'*{pg.sequence_filter_name}*'):
-                    flt_flags[i] &= ~bitflag_filter_item
-
-    if pg.sequence_filter_is_selected:
-        for i, sequence in enumerate(sequences):
-            if not sequence.is_selected:
-                flt_flags[i] &= ~bitflag_filter_item
-
-    if pg.sequence_use_filter_invert:
-        # Invert filter flags for all items.
-        for i, sequence in enumerate(sequences):
-            flt_flags[i] ^= bitflag_filter_item
-
-    return flt_flags
-
-
-def get_visible_sequences(pg: PsaImportPropertyGroup, sequences) -> List[PsaImportActionListItem]:
-    bitflag_filter_item = 1 << 30
-    visible_sequences = []
-    for i, flag in enumerate(filter_sequences(pg, sequences)):
-        if bool(flag & bitflag_filter_item):
-            visible_sequences.append(sequences[i])
-    return visible_sequences
-
-
-class PSA_UL_SequenceList(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_property, index, flt_flag):
-        row = layout.row(align=True)
-        split = row.split(align=True, factor=0.75)
-        column = split.row(align=True)
-        column.alignment = 'LEFT'
-        column.prop(item, 'is_selected', icon_only=True)
-        column.label(text=getattr(item, 'action_name'))
-
-    def draw_filter(self, context, layout):
-        pg = getattr(context.scene, 'psa_import')
-        row = layout.row()
-        sub_row = row.row(align=True)
-        sub_row.prop(pg, 'sequence_filter_name', text="")
-        sub_row.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
-        sub_row.prop(pg, 'sequence_use_filter_regex', text="", icon='SORTBYEXT')
-        sub_row.prop(pg, 'sequence_filter_is_selected', text="", icon='CHECKBOX_HLT')
-
-    def filter_items(self, context, data, property_):
-        pg = getattr(context.scene, 'psa_import')
-        sequences = getattr(data, property_)
-        flt_flags = filter_sequences(pg, sequences)
-        flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(sequences, 'action_name')
-        return flt_flags, flt_neworder
-
-
-class PSA_UL_ImportSequenceList(PSA_UL_SequenceList, UIList):
-    pass
-
-
-class PSA_UL_ImportActionList(PSA_UL_SequenceList, UIList):
-    pass
-
-
-class PsaImportSequencesFromText(Operator):
-    bl_idname = 'psa_import.sequences_select_from_text'
-    bl_label = 'Select By Text List'
-    bl_description = 'Select sequences by name from text list'
-    bl_options = {'INTERNAL', 'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_import')
-        return len(pg.sequence_list) > 0
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self, width=256)
-
-    def draw(self, context):
-        layout = self.layout
-        pg = getattr(context.scene, 'psa_import')
-        layout.label(icon='INFO', text='Each sequence name should be on a new line.')
-        layout.prop(pg, 'select_text', text='')
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        if pg.select_text is None:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'No text block selected')
-            return {'CANCELLED'}
-        contents = pg.select_text.as_string()
-        count = 0
-        for line in contents.split('\n'):
-            for sequence in pg.sequence_list:
-                if sequence.action_name == line:
-                    sequence.is_selected = True
-                    count += 1
-        self.report({'INFO'}, f'Selected {count} sequence(s)')
-        return {'FINISHED'}
-
-
-class PsaImportSequencesSelectAll(Operator):
-    bl_idname = 'psa_import.sequences_select_all'
-    bl_label = 'All'
-    bl_description = 'Select all sequences'
-    bl_options = {'INTERNAL'}
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_import')
-        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        has_unselected_actions = any(map(lambda action: not action.is_selected, visible_sequences))
-        return len(visible_sequences) > 0 and has_unselected_actions
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        for sequence in visible_sequences:
-            sequence.is_selected = True
-        return {'FINISHED'}
-
-
-class PsaImportSequencesDeselectAll(Operator):
-    bl_idname = 'psa_import.sequences_deselect_all'
-    bl_label = 'None'
-    bl_description = 'Deselect all visible sequences'
-    bl_options = {'INTERNAL'}
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_import')
-        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        has_selected_sequences = any(map(lambda sequence: sequence.is_selected, visible_sequences))
-        return len(visible_sequences) > 0 and has_selected_sequences
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        for sequence in visible_sequences:
-            sequence.is_selected = False
-        return {'FINISHED'}
-
-
-class PSA_PT_ImportPanel_Advanced(Panel):
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_label = 'Advanced'
-    bl_options = {'DEFAULT_CLOSED'}
-    bl_parent_id = 'PSA_PT_ImportPanel'
-
-    def draw(self, context):
-        layout = self.layout
-        pg = getattr(context.scene, 'psa_import')
-
-        col = layout.column()
-        col.use_property_split = True
-        col.use_property_decorate = False
-        col.prop(pg, 'bone_mapping_mode')
-
-        if pg.should_write_keyframes:
-            col = layout.column(heading='Keyframes')
-            col.use_property_split = True
-            col.use_property_decorate = False
-            col.prop(pg, 'should_convert_to_samples')
-            col.separator()
-
-        col = layout.column(heading='Options')
-        col.use_property_split = True
-        col.use_property_decorate = False
-        col.prop(pg, 'should_use_fake_user')
-        col.prop(pg, 'should_stash')
-        col.prop(pg, 'should_use_action_name_prefix')
-
-        if pg.should_use_action_name_prefix:
-            col.prop(pg, 'action_name_prefix')
-
-
-class PSA_PT_ImportPanel(Panel):
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_label = 'PSA Import'
-    bl_context = 'data'
-    bl_category = 'PSA Import'
-    bl_options = {'DEFAULT_CLOSED'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.view_layer.objects.active.type == 'ARMATURE'
-
-    def draw(self, context):
-        layout = self.layout
-        pg = getattr(context.scene, 'psa_import')
-
-        row = layout.row(align=True)
-        row.operator(PsaImportSelectFile.bl_idname, text='', icon='FILEBROWSER')
-        row.prop(pg, 'psa_file_path', text='')
-        row.operator(PsaImportFileReload.bl_idname, text='', icon='FILE_REFRESH')
-
-        if pg.psa_error != '':
-            row = layout.row()
-            row.label(text='File could not be read', icon='ERROR')
-
-        box = layout.box()
-
-        box.label(text=f'Sequences ({len(pg.sequence_list)})', icon='ARMATURE_DATA')
-
-        # select
-        rows = max(3, min(len(pg.sequence_list), 10))
-
-        row = box.row()
-        col = row.column()
-
-        row2 = col.row(align=True)
-        row2.label(text='Select')
-        row2.operator(PsaImportSequencesFromText.bl_idname, text='', icon='TEXT')
-        row2.operator(PsaImportSequencesSelectAll.bl_idname, text='All', icon='CHECKBOX_HLT')
-        row2.operator(PsaImportSequencesDeselectAll.bl_idname, text='None', icon='CHECKBOX_DEHLT')
-
-        col = col.row()
-        col.template_list('PSA_UL_ImportSequenceList', '', pg, 'sequence_list', pg, 'sequence_list_index', rows=rows)
-
-        col = layout.column(heading='')
-        col.use_property_split = True
-        col.use_property_decorate = False
-        col.prop(pg, 'should_overwrite')
-
-        col = layout.column(heading='Write')
-        col.use_property_split = True
-        col.use_property_decorate = False
-        col.prop(pg, 'should_write_keyframes')
-        col.prop(pg, 'should_write_metadata')
-
-        selected_sequence_count = sum(map(lambda x: x.is_selected, pg.sequence_list))
-
-        row = layout.row()
-
-        import_button_text = 'Import'
-        if selected_sequence_count > 0:
-            import_button_text = f'Import ({selected_sequence_count})'
-
-        row.operator(PsaImportOperator.bl_idname, text=import_button_text)
-
-
-class PsaImportFileReload(Operator):
-    bl_idname = 'psa_import.file_reload'
-    bl_label = 'Refresh'
-    bl_options = {'INTERNAL'}
-    bl_description = 'Refresh the PSA file'
-
-    def execute(self, context):
-        load_psa_file(context)
-        return {"FINISHED"}
-
-
-class PsaImportSelectFile(Operator):
-    bl_idname = 'psa_import.select_file'
-    bl_label = 'Select'
-    bl_options = {'INTERNAL'}
-    bl_description = 'Select a PSA file from which to import animations'
-    filepath: bpy.props.StringProperty(subtype='FILE_PATH')
-    filter_glob: bpy.props.StringProperty(default="*.psa", options={'HIDDEN'})
-
-    def execute(self, context):
-        getattr(context.scene, 'psa_import').psa_file_path = self.filepath
-        return {"FINISHED"}
-
-    def invoke(self, context, event):
-        context.window_manager.fileselect_add(self)
-        return {"RUNNING_MODAL"}
-
-
-class PsaImportOperator(Operator):
-    bl_idname = 'psa_import.import'
-    bl_label = 'Import'
-    bl_description = 'Import the selected animations into the scene as actions'
-    bl_options = {'INTERNAL', 'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_import')
-        active_object = context.view_layer.objects.active
-        if active_object is None or active_object.type != 'ARMATURE':
-            return False
-        return any(map(lambda x: x.is_selected, pg.sequence_list))
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        psa_reader = PsaReader(pg.psa_file_path)
-        sequence_names = [x.action_name for x in pg.sequence_list if x.is_selected]
-
-        options = PsaImportOptions()
-        options.sequence_names = sequence_names
-        options.should_use_fake_user = pg.should_use_fake_user
-        options.should_stash = pg.should_stash
-        options.action_name_prefix = pg.action_name_prefix if pg.should_use_action_name_prefix else ''
-        options.should_overwrite = pg.should_overwrite
-        options.should_write_metadata = pg.should_write_metadata
-        options.should_write_keyframes = pg.should_write_keyframes
-        options.should_convert_to_samples = pg.should_convert_to_samples
-        options.bone_mapping_mode = pg.bone_mapping_mode
-
-        result = import_psa(psa_reader, context.view_layer.objects.active, options)
-
-        if len(result.warnings) > 0:
-            message = f'Imported {len(sequence_names)} action(s) with {len(result.warnings)} warning(s)\n'
-            message += '\n'.join(result.warnings)
-            self.report({'WARNING'}, message)
-        else:
-            self.report({'INFO'}, f'Imported {len(sequence_names)} action(s)')
-
-        return {'FINISHED'}
-
-
-class PsaImportFileSelectOperator(Operator, ImportHelper):
-    bl_idname = 'psa_import.file_select'
-    bl_label = 'File Select'
-    bl_options = {'INTERNAL'}
-    filename_ext = '.psa'
-    filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
-    filepath: StringProperty(
-        name='File Path',
-        description='File path used for importing the PSA file',
-        maxlen=1024,
-        default='')
-
-    def invoke(self, context, event):
-        context.window_manager.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        pg.psa_file_path = self.filepath
-        return {'FINISHED'}
-
-
-classes = (
-    PsaImportActionListItem,
-    PsaBonePropertyGroup,
-    PsaDataPropertyGroup,
-    PsaImportPropertyGroup,
-    PSA_UL_SequenceList,
-    PSA_UL_ImportSequenceList,
-    PSA_UL_ImportActionList,
-    PsaImportSequencesSelectAll,
-    PsaImportSequencesDeselectAll,
-    PsaImportSequencesFromText,
-    PsaImportFileReload,
-    PSA_PT_ImportPanel,
-    PSA_PT_ImportPanel_Advanced,
-    PsaImportOperator,
-    PsaImportFileSelectOperator,
-    PsaImportSelectFile,
-)

io_scene_psk_psa/psa/reader.py

@@ -5,6 +5,23 @@ import numpy as np
 from .data import *
 
 
+def _try_fix_cue4parse_issue_103(sequences) -> bool:
+    # Detect if the file was exported from CUE4Parse prior to the fix for issue #103.
+    # https://github.com/FabianFG/CUE4Parse/issues/103
+    # The issue was that the frame_start_index was not being set correctly, and was always being set to the same value
+    # as the frame_count.
+    # This fix will eventually be deprecated as it is only necessary for files exported prior to the fix.
+    if len(sequences) > 0 and sequences[0].frame_start_index == sequences[0].frame_count:
+        # Manually set the frame_start_index for each sequence. This assumes that the sequences are in order with
+        # no shared frames between sequences (all exporters that I know of do this, so it's a safe assumption).
+        frame_start_index = 0
+        for i, sequence in enumerate(sequences):
+            sequence.frame_start_index = frame_start_index
+            frame_start_index += sequence.frame_count
+        return True
+    return False
+
+
 class PsaReader(object):
     """
     This class reads the sequences and bone information immediately upon instantiation and holds onto a file handle.
@@ -86,14 +103,15 @@ class PsaReader(object):
             elif section.name == b'ANIMINFO':
                 sequences = []
                 PsaReader._read_types(fp, Psa.Sequence, section, sequences)
+                # Try to fix CUE4Parse bug, if necessary.
+                _try_fix_cue4parse_issue_103(sequences)
                 for sequence in sequences:
                     psa.sequences[sequence.name.decode()] = sequence
             elif section.name == b'ANIMKEYS':
                 # Skip keys on this pass. We will keep this file open and read from it as needed.
                 self.keys_data_offset = fp.tell()
                 fp.seek(section.data_size * section.data_count, 1)
-            elif section.name == b'SCALEKEYS':
-                fp.seek(section.data_size * section.data_count, 1)
             else:
-                raise RuntimeError(f'Unrecognized section "{section.name}"')
+                fp.seek(section.data_size * section.data_count, 1)
+                print(f'Unrecognized section in PSA: "{section.name}"')
         return psa

io_scene_psk_psa/psa/writer.py

@@ -0,0 +1,25 @@
+from ctypes import Structure, sizeof
+from typing import Type
+
+from .data import Psa
+from ..shared.data import Section
+
+
+def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
+    section = Section()
+    section.name = name
+    if data_type is not None and data is not None:
+        section.data_size = sizeof(data_type)
+        section.data_count = len(data)
+    fp.write(section)
+    if data is not None:
+        for datum in data:
+            fp.write(datum)
+
+
+def write_psa(psa: Psa, path: str):
+    with open(path, 'wb') as fp:
+        write_section(fp, b'ANIMHEAD')
+        write_section(fp, b'BONENAMES', Psa.Bone, psa.bones)
+        write_section(fp, b'ANIMINFO', Psa.Sequence, list(psa.sequences.values()))
+        write_section(fp, b'ANIMKEYS', Psa.Key, psa.keys)

io_scene_psk_psa/psk/builder.py

@@ -1,49 +1,78 @@
 import typing
+from typing import Optional
 
 import bmesh
-import bpy
+import numpy as np
-from bpy.types import Armature
+from bpy.types import Material, Collection, Context
+from mathutils import Matrix, Vector
 
 from .data import *
-from ..helpers import *
+from .properties import triangle_type_and_bit_flags_to_poly_flags
+from ..shared.dfs import dfs_collection_objects, dfs_view_layer_objects, DfsObject
+from ..shared.helpers import *
 
 
 class PskInputObjects(object):
     def __init__(self):
-        self.mesh_objects = []
+        self.mesh_objects: List[DfsObject] = []
-        self.armature_object = None
+        self.armature_object: Optional[Object] = None
 
 
 class PskBuildOptions(object):
     def __init__(self):
         self.bone_filter_mode = 'ALL'
-        self.bone_group_indices: List[int] = []
+        self.bone_collection_indices: List[int] = []
-        self.use_raw_mesh_data = True
+        self.object_eval_state = 'EVALUATED'
-        self.material_names: List[str] = []
+        self.materials: List[Material] = []
-        self.should_ignore_bone_name_restrictions = False
+        self.scale = 1.0
+        self.export_space = 'WORLD'
+        self.forward_axis = 'X'
+        self.up_axis = 'Z'
 
 
-def get_psk_input_objects(context) -> PskInputObjects:
+def get_vector_from_axis_identifier(axis_identifier: str) -> Vector:
-    input_objects = PskInputObjects()
+    match axis_identifier:
-    for selected_object in context.view_layer.objects.selected:
+        case 'X':
-        if selected_object.type != 'MESH':
+            return Vector((1.0, 0.0, 0.0))
-            raise RuntimeError(f'Selected object "{selected_object.name}" is not a mesh')
+        case 'Y':
+            return Vector((0.0, 1.0, 0.0))
+        case 'Z':
+            return Vector((0.0, 0.0, 1.0))
+        case '-X':
+            return Vector((-1.0, 0.0, 0.0))
+        case '-Y':
+            return Vector((0.0, -1.0, 0.0))
+        case '-Z':
+            return Vector((0.0, 0.0, -1.0))
 
-    input_objects.mesh_objects = context.view_layer.objects.selected
 
-    if len(input_objects.mesh_objects) == 0:
+def get_coordinate_system_transform(forward_axis: str = 'X', up_axis: str = 'Z') -> Matrix:
-        raise RuntimeError('At least one mesh must be selected')
+    forward = get_vector_from_axis_identifier(forward_axis)
+    up = get_vector_from_axis_identifier(up_axis)
+    left = up.cross(forward)
+    return Matrix((
+        (forward.x, forward.y, forward.z, 0.0),
+        (left.x, left.y, left.z, 0.0),
+        (up.x, up.y, up.z, 0.0),
+        (0.0, 0.0, 0.0, 1.0)
+    )).inverted()
 
-    for mesh_object in input_objects.mesh_objects:
-        if len(mesh_object.data.materials) == 0:
-            raise RuntimeError(f'Mesh "{mesh_object.name}" must have at least one material')
 
-    # Ensure that there are either no armature modifiers (static mesh)
+def get_mesh_objects_for_collection(collection: Collection) -> Iterable[DfsObject]:
-    # or that there is exactly one armature modifier object shared between
+    return filter(lambda x: x.obj.type == 'MESH', dfs_collection_objects(collection))
-    # all selected meshes
+
+
+def get_mesh_objects_for_context(context: Context) -> Iterable[DfsObject]:
+    for dfs_object in dfs_view_layer_objects(context.view_layer):
+        if dfs_object.obj.type == 'MESH' and dfs_object.is_selected:
+            yield dfs_object
+
+
+def get_armature_for_mesh_objects(mesh_objects: Iterable[Object]) -> Optional[Object]:
+    # Ensure that there are either no armature modifiers (static mesh) or that there is exactly one armature modifier
+    # object shared between all meshes.
     armature_modifier_objects = set()
-
+    for mesh_object in mesh_objects:
-    for mesh_object in input_objects.mesh_objects:
         modifiers = [x for x in mesh_object.modifiers if x.type == 'ARMATURE']
         if len(modifiers) == 0:
             continue
@@ -52,44 +81,93 @@ def get_psk_input_objects(context) -> PskInputObjects:
         armature_modifier_objects.add(modifiers[0].object)
 
     if len(armature_modifier_objects) > 1:
-        raise RuntimeError('All selected meshes must have the same armature modifier')
+        armature_modifier_names = [x.name for x in armature_modifier_objects]
+        raise RuntimeError(
+            f'All meshes must have the same armature modifier, encountered {len(armature_modifier_names)} ({", ".join(armature_modifier_names)})')
     elif len(armature_modifier_objects) == 1:
-        input_objects.armature_object = list(armature_modifier_objects)[0]
+        return list(armature_modifier_objects)[0]
+    else:
+        return None
+
+
+def _get_psk_input_objects(mesh_objects: Iterable[DfsObject]) -> PskInputObjects:
+    mesh_objects = list(mesh_objects)
+    if len(mesh_objects) == 0:
+        raise RuntimeError('At least one mesh must be selected')
+
+    input_objects = PskInputObjects()
+    input_objects.mesh_objects = mesh_objects
+    input_objects.armature_object = get_armature_for_mesh_objects([x.obj for x in mesh_objects])
 
     return input_objects
 
 
-def build_psk(context, options: PskBuildOptions) -> Psk:
+def get_psk_input_objects_for_context(context: Context) -> PskInputObjects:
-    input_objects = get_psk_input_objects(context)
+    mesh_objects = list(get_mesh_objects_for_context(context))
+    return _get_psk_input_objects(mesh_objects)
 
+
+def get_psk_input_objects_for_collection(collection: Collection, should_exclude_hidden_meshes: bool = True) -> PskInputObjects:
+    mesh_objects = get_mesh_objects_for_collection(collection)
+    if should_exclude_hidden_meshes:
+        mesh_objects = filter(lambda x: x.is_visible, mesh_objects)
+    return _get_psk_input_objects(mesh_objects)
+
+
+class PskBuildResult(object):
+    def __init__(self):
+        self.psk = None
+        self.warnings: List[str] = []
+
+
+def build_psk(context, input_objects: PskInputObjects, options: PskBuildOptions) -> PskBuildResult:
     armature_object: bpy.types.Object = input_objects.armature_object
 
+    result = PskBuildResult()
     psk = Psk()
     bones = []
 
-    if armature_object is None:
+    def get_export_space_matrix():
-        # If the mesh has no armature object, simply assign it a dummy bone at the root to satisfy the requirement
+        match options.export_space:
-        # that a PSK file must have at least one bone.
+            case 'WORLD':
+                return Matrix.Identity(4)
+            case 'ARMATURE':
+                if armature_object is not None:
+                    return armature_object.matrix_world.inverted()
+                else:
+                    return Matrix.Identity(4)
+            case _:
+                raise ValueError(f'Invalid export space: {options.export_space}')
+
+    coordinate_system_matrix = get_coordinate_system_transform(options.forward_axis, options.up_axis)
+    coordinate_system_default_rotation = coordinate_system_matrix.to_quaternion()
+
+    export_space_matrix = get_export_space_matrix()  # TODO: maybe neutralize the scale here?
+    scale_matrix = coordinate_system_matrix @ Matrix.Scale(options.scale, 4)
+
+    if armature_object is None or len(armature_object.data.bones) == 0:
+        # If the mesh has no armature object or no bones, simply assign it a dummy bone at the root to satisfy the
+        # requirement that a PSK file must have at least one bone.
         psk_bone = Psk.Bone()
         psk_bone.name = bytes('root', encoding='windows-1252')
         psk_bone.flags = 0
         psk_bone.children_count = 0
         psk_bone.parent_index = 0
         psk_bone.location = Vector3.zero()
-        psk_bone.rotation = Quaternion.identity()
+        psk_bone.rotation = coordinate_system_default_rotation
         psk.bones.append(psk_bone)
     else:
-        bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_group_indices)
+        bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_collection_indices)
         armature_data = typing.cast(Armature, armature_object.data)
         bones = [armature_data.bones[bone_name] for bone_name in bone_names]
 
-        # Check that all bone names are valid.
-        if not options.should_ignore_bone_name_restrictions:
-            check_bone_names(map(lambda x: x.name, bones))
-
         for bone in bones:
             psk_bone = Psk.Bone()
-            psk_bone.name = bytes(bone.name, encoding='windows-1252')
+            try:
+                psk_bone.name = bytes(bone.name, encoding='windows-1252')
+            except UnicodeEncodeError:
+                raise RuntimeError(
+                    f'Bone name "{bone.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
             psk_bone.flags = 0
             psk_bone.children_count = 0
 
@@ -98,7 +176,7 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
                 psk_bone.parent_index = parent_index
                 psk.bones[parent_index].children_count += 1
             except ValueError:
-                psk_bone.parent_index = -1
+                psk_bone.parent_index = 0
 
             if bone.parent is not None:
                 rotation = bone.matrix.to_quaternion().conjugated()
@@ -107,12 +185,30 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
                 parent_tail = inverse_parent_rotation @ bone.parent.tail
                 location = (parent_tail - parent_head) + bone.head
             else:
-                armature_local_matrix = armature_object.matrix_local
+                def get_armature_local_matrix():
+                    match options.export_space:
+                        case 'WORLD':
+                            return armature_object.matrix_world
+                        case 'ARMATURE':
+                            return Matrix.Identity(4)
+                        case _:
+                            raise ValueError(f'Invalid export space: {options.export_space}')
+
+                armature_local_matrix = get_armature_local_matrix()
                 location = armature_local_matrix @ bone.head
                 bone_rotation = bone.matrix.to_quaternion().conjugated()
                 local_rotation = armature_local_matrix.to_3x3().to_quaternion().conjugated()
                 rotation = bone_rotation @ local_rotation
                 rotation.conjugate()
+                rotation = coordinate_system_default_rotation @ rotation
+
+            location = scale_matrix @ location
+
+            # If the armature object has been scaled, we need to scale the bone's location to match.
+            _, _, armature_object_scale = armature_object.matrix_world.decompose()
+            location.x *= armature_object_scale.x
+            location.y *= armature_object_scale.y
+            location.z *= armature_object_scale.z
 
             psk_bone.location.x = location.x
             psk_bone.location.y = location.y
@@ -126,53 +222,119 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
             psk.bones.append(psk_bone)
 
     # MATERIALS
-    material_names = options.material_names
+    for material in options.materials:
-
-    for material_name in material_names:
         psk_material = Psk.Material()
-        psk_material.name = bytes(material_name, encoding='windows-1252')
+        try:
+            psk_material.name = bytes(material.name, encoding='windows-1252')
+        except UnicodeEncodeError:
+            raise RuntimeError(f'Material name "{material.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
         psk_material.texture_index = len(psk.materials)
+        psk_material.poly_flags = triangle_type_and_bit_flags_to_poly_flags(material.psk.mesh_triangle_type,
+                                                                            material.psk.mesh_triangle_bit_flags)
         psk.materials.append(psk_material)
 
-    for input_mesh_object in input_objects.mesh_objects:
+    # TODO: This wasn't left in a good state. We should detect if we need to add a "default" material.
+    #  This can be done by checking if there is an empty material slot on any of the mesh objects, or if there are
+    #  no material slots on any of the mesh objects.
+    #  If so, it should be added to the end of the list of materials, and its index should mapped to a None value in the
+    #  material indices list.
+    if len(psk.materials) == 0:
+        # Add a default material if no materials are present.
+        psk_material = Psk.Material()
+        psk_material.name = bytes('None', encoding='windows-1252')
+        psk.materials.append(psk_material)
+
+    context.window_manager.progress_begin(0, len(input_objects.mesh_objects))
+
+    material_names = [m.name for m in options.materials]
+
+    for object_index, input_mesh_object in enumerate(input_objects.mesh_objects):
+
+        obj, instance_objects, matrix_world = input_mesh_object.obj, input_mesh_object.instance_objects, input_mesh_object.matrix_world
+
+        should_flip_normals = False
+
+        def get_material_name_indices(obj: Object, material_names: List[str]) -> Iterable[int]:
+            '''
+            Returns the index of the material in the list of material names.
+            If the material is not found, the index 0 is returned.
+            '''
+            for material_slot in obj.material_slots:
+                if material_slot.material is None:
+                    yield 0
+                else:
+                    try:
+                        yield material_names.index(material_slot.material.name)
+                    except ValueError:
+                        yield 0
 
         # MATERIALS
-        material_indices = [material_names.index(material.name) for material in input_mesh_object.data.materials]
+        material_indices = list(get_material_name_indices(obj, material_names))
+
+        if len(material_indices) == 0:
+            # Add a default material if no materials are present.
+            material_indices = [0]
 
         # MESH DATA
-        if options.use_raw_mesh_data:
+        match options.object_eval_state:
-            mesh_object = input_mesh_object
+            case 'ORIGINAL':
-            mesh_data = input_mesh_object.data
+                mesh_object = obj
-        else:
+                mesh_data = obj.data
-            # Create a copy of the mesh object after non-armature modifiers are applied.
+            case 'EVALUATED':
+                # Create a copy of the mesh object after non-armature modifiers are applied.
 
-            # Temporarily force the armature into the rest position.
+                # Temporarily force the armature into the rest position.
-            # We will undo this later.
+                # We will undo this later.
-            old_pose_position = armature_object.data.pose_position
+                old_pose_position = None
-            armature_object.data.pose_position = 'REST'
+                if armature_object is not None:
+                    old_pose_position = armature_object.data.pose_position
+                    armature_object.data.pose_position = 'REST'
 
-            depsgraph = context.evaluated_depsgraph_get()
+                depsgraph = context.evaluated_depsgraph_get()
-            bm = bmesh.new()
+                bm = bmesh.new()
-            bm.from_object(input_mesh_object, depsgraph)
-            mesh_data = bpy.data.meshes.new('')
-            bm.to_mesh(mesh_data)
-            del bm
-            mesh_object = bpy.data.objects.new('', mesh_data)
-            mesh_object.matrix_world = input_mesh_object.matrix_world
 
-            # Copy the vertex groups
+                try:
-            for vertex_group in input_mesh_object.vertex_groups:
+                    bm.from_object(obj, depsgraph)
-                mesh_object.vertex_groups.new(name=vertex_group.name)
+                except ValueError:
+                    raise RuntimeError(f'Object "{obj.name}" is not evaluated.\n'
+                    'This is likely because the object is in a collection that has been excluded from the view layer.')
 
-            # Restore the previous pose position on the armature.
+                mesh_data = bpy.data.meshes.new('')
-            armature_object.data.pose_position = old_pose_position
+                bm.to_mesh(mesh_data)
+                del bm
+                mesh_object = bpy.data.objects.new('', mesh_data)
+                mesh_object.matrix_world = matrix_world
+
+                # Extract the scale from the matrix.
+                _, _, scale = matrix_world.decompose()
+
+                # Negative scaling in Blender results in inverted normals after the scale is applied. However, if the scale
+                # is not applied, the normals will appear unaffected in the viewport. The evaluated mesh data used in the
+                # export will have the scale applied, but this behavior is not obvious to the user.
+                #
+                # In order to have the exporter be as WYSIWYG as possible, we need to check for negative scaling and invert
+                # the normals if necessary. If two axes have negative scaling and the third has positive scaling, the
+                # normals will be correct. We can detect this by checking if the number of negative scaling axes is odd. If
+                # it is, we need to invert the normals of the mesh by swapping the order of the vertices in each face.
+                should_flip_normals = sum(1 for x in scale if x < 0) % 2 == 1
+
+                # Copy the vertex groups
+                for vertex_group in obj.vertex_groups:
+                    mesh_object.vertex_groups.new(name=vertex_group.name)
+
+                # Restore the previous pose position on the armature.
+                if old_pose_position is not None:
+                    armature_object.data.pose_position = old_pose_position
+            case _:
+                raise ValueError(f'Invalid object evaluation state: {options.object_eval_state}')
 
         vertex_offset = len(psk.points)
+        matrix_world = scale_matrix @ export_space_matrix @ mesh_object.matrix_world
 
         # VERTICES
         for vertex in mesh_data.vertices:
             point = Vector3()
-            v = mesh_object.matrix_world @ vertex.co
+            v = matrix_world @ vertex.co
             point.x = v.x
             point.y = v.y
             point.z = v.z
@@ -186,11 +348,11 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
         # Build a list of non-unique wedges.
         wedges = []
         for loop_index, loop in enumerate(mesh_data.loops):
-            wedge = Psk.Wedge()
+            wedges.append(Psk.Wedge(
-            wedge.point_index = loop.vertex_index + vertex_offset
+                point_index=loop.vertex_index + vertex_offset,
-            wedge.u, wedge.v = uv_layer[loop_index].uv
+                u=uv_layer[loop_index].uv[0],
-            wedge.v = 1.0 - wedge.v
+                v=1.0 - uv_layer[loop_index].uv[1]
-            wedges.append(wedge)
+            ))
 
         # Assign material indices to the wedges.
         for triangle in mesh_data.loop_triangles:
@@ -198,8 +360,8 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
                 wedges[loop_index].material_index = material_indices[triangle.material_index]
 
         # Populate the list of wedges with unique wedges & build a look-up table of loop indices to wedge indices
-        wedge_indices = {}
+        wedge_indices = dict()
-        loop_wedge_indices = [-1] * len(mesh_data.loops)
+        loop_wedge_indices = np.full(len(mesh_data.loops), -1)
         for loop_index, wedge in enumerate(wedges):
             wedge_hash = hash(wedge)
             if wedge_hash in wedge_indices:
@@ -212,6 +374,7 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
 
         # FACES
         poly_groups, groups = mesh_data.calc_smooth_groups(use_bitflags=True)
+        psk_face_start_index = len(psk.faces)
         for f in mesh_data.loop_triangles:
             face = Psk.Face()
             face.material_index = material_indices[f.material_index]
@@ -221,6 +384,11 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
             face.smoothing_groups = poly_groups[f.polygon_index]
             psk.faces.append(face)
 
+        if should_flip_normals:
+            # Invert the normals of the faces.
+            for face in psk.faces[psk_face_start_index:]:
+                face.wedge_indices[0], face.wedge_indices[2] = face.wedge_indices[2], face.wedge_indices[0]
+
         # WEIGHTS
         if armature_object is not None:
             armature_data = typing.cast(Armature, armature_object.data)
@@ -246,6 +414,12 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
                                 break
                             except ValueError:
                                 bone = bone.parent
+
+            # Keep track of which vertices have been assigned weights.
+            # The ones that have not been assigned weights will be assigned to the root bone.
+            # Without this, some older versions of UnrealEd may have corrupted meshes.
+            vertices_assigned_weights = np.full(len(mesh_data.vertices), False)
+
             for vertex_group_index, vertex_group in enumerate(mesh_object.vertex_groups):
                 if vertex_group_index not in vertex_group_bone_indices:
                     # Vertex group has no associated bone, skip it.
@@ -263,10 +437,26 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
                     w.point_index = vertex_offset + vertex_index
                     w.weight = weight
                     psk.weights.append(w)
+                    vertices_assigned_weights[vertex_index] = True
 
-        if not options.use_raw_mesh_data:
+            # Assign vertices that have not been assigned weights to the root bone.
+            for vertex_index, assigned in enumerate(vertices_assigned_weights):
+                if not assigned:
+                    w = Psk.Weight()
+                    w.bone_index = 0
+                    w.point_index = vertex_offset + vertex_index
+                    w.weight = 1.0
+                    psk.weights.append(w)
+
+        if options.object_eval_state == 'EVALUATED':
             bpy.data.objects.remove(mesh_object)
             bpy.data.meshes.remove(mesh_data)
             del mesh_data
 
-    return psk
+        context.window_manager.progress_update(object_index)
+
+    context.window_manager.progress_end()
+
+    result.psk = psk
+
+    return result

io_scene_psk_psa/psk/data.py

@@ -1,23 +1,22 @@
 from typing import List
 
-from ..data import *
+from ..shared.data import *
 
 
 class Psk(object):
     class Wedge(object):
-        def __init__(self):
+        def __init__(self, point_index: int, u: float, v: float, material_index: int = 0):
-            self.point_index: int = 0
+            self.point_index: int = point_index
-            self.u: float = 0.0
+            self.u: float = u
-            self.v: float = 0.0
+            self.v: float = v
-            self.material_index: int = 0
+            self.material_index = material_index
 
         def __hash__(self):
             return hash(f'{self.point_index}-{self.u}-{self.v}-{self.material_index}')
 
     class Wedge16(Structure):
         _fields_ = [
-            ('point_index', c_uint16),
+            ('point_index', c_uint32),
-            ('padding1', c_int16),
             ('u', c_float),
             ('v', c_float),
             ('material_index', c_uint8),
@@ -105,6 +104,10 @@ class Psk(object):
     def has_vertex_normals(self):
         return len(self.vertex_normals) > 0
 
+    @property
+    def has_material_references(self):
+        return len(self.material_references) > 0
+
     @property
     def has_morph_data(self):
         return len(self.morph_infos) > 0
@@ -121,3 +124,4 @@ class Psk(object):
         self.vertex_normals: List[Vector3] = []
         self.morph_infos: List[Psk.MorphInfo] = []
         self.morph_data: List[Psk.MorphData] = []
+        self.material_references: List[str] = []

io_scene_psk_psa/psk/export/operators.py

@@ -0,0 +1,425 @@
+from typing import List, Optional, cast, Iterable
+
+import bpy
+from bpy.props import StringProperty
+from bpy.types import Operator, Context, Object, Collection, SpaceProperties, Depsgraph, Material
+from bpy_extras.io_utils import ExportHelper
+
+from .properties import add_psk_export_properties
+from ..builder import build_psk, PskBuildOptions, get_psk_input_objects_for_context, \
+    get_psk_input_objects_for_collection
+from ..writer import write_psk
+from ...shared.helpers import populate_bone_collection_list
+from ...shared.ui import draw_bone_filter_mode
+
+
+def get_materials_for_mesh_objects(depsgraph: Depsgraph, mesh_objects: Iterable[Object]):
+    materials = []
+    for mesh_object in mesh_objects:
+        evaluated_mesh_object = mesh_object.evaluated_get(depsgraph)
+        for i, material_slot in enumerate(evaluated_mesh_object.material_slots):
+            material = material_slot.material
+            if material is None:
+                raise RuntimeError('Material slot cannot be empty (index ' + str(i) + ')')
+            if material not in materials:
+                materials.append(material)
+    return materials
+
+
+def populate_material_name_list(depsgraph: Depsgraph, mesh_objects, material_list):
+    materials = get_materials_for_mesh_objects(depsgraph, mesh_objects)
+    material_list.clear()
+    for index, material in enumerate(materials):
+        m = material_list.add()
+        m.material_name = material.name
+        m.index = index
+
+
+
+def get_collection_from_context(context: Context) -> Optional[Collection]:
+    if context.space_data.type != 'PROPERTIES':
+        return None
+
+    space_data = cast(SpaceProperties, context.space_data)
+
+    if space_data.use_pin_id:
+        return cast(Collection, space_data.pin_id)
+    else:
+        return context.collection
+
+
+def get_collection_export_operator_from_context(context: Context) -> Optional[object]:
+    collection = get_collection_from_context(context)
+    if collection is None:
+        return None
+    if 0 > collection.active_exporter_index >= len(collection.exporters):
+        return None
+    exporter = collection.exporters[collection.active_exporter_index]
+    # TODO: make sure this is actually an ASE exporter.
+    return exporter.export_properties
+
+
+class PSK_OT_populate_bone_collection_list(Operator):
+    bl_idname = 'psk_export.populate_bone_collection_list'
+    bl_label = 'Populate Bone Collection List'
+    bl_description = 'Populate the bone collection list from the armature that will be used in this collection export'
+    bl_options = {'INTERNAL'}
+
+    def execute(self, context):
+        export_operator = get_collection_export_operator_from_context(context)
+        if export_operator is None:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No valid export operator found in context')
+            return {'CANCELLED'}
+        input_objects = get_psk_input_objects_for_collection(context.collection)
+        if input_objects.armature_object is None:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No armature found in collection')
+            return {'CANCELLED'}
+        populate_bone_collection_list(input_objects.armature_object, export_operator.bone_collection_list)
+        return {'FINISHED'}
+
+
+class PSK_OT_populate_material_name_list(Operator):
+    bl_idname = 'psk_export.populate_material_name_list'
+    bl_label = 'Populate Material Name List'
+    bl_description = 'Populate the material name list from the objects that will be used in this export'
+    bl_options = {'INTERNAL'}
+
+    def execute(self, context):
+        export_operator = get_collection_export_operator_from_context(context)
+        if export_operator is None:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No valid export operator found in context')
+            return {'CANCELLED'}
+        depsgraph = context.evaluated_depsgraph_get()
+        input_objects = get_psk_input_objects_for_collection(context.collection)
+        try:
+            populate_material_name_list(depsgraph, [x.obj for x in input_objects.mesh_objects], export_operator.material_name_list)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+        return {'FINISHED'}
+
+
+class PSK_OT_material_list_move_up(Operator):
+    bl_idname = 'psk_export.material_list_item_move_up'
+    bl_label = 'Move Up'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Move the selected material up one slot'
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psk_export')
+        return pg.material_name_list_index > 0
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psk_export')
+        pg.material_name_list.move(pg.material_name_list_index, pg.material_name_list_index - 1)
+        pg.material_name_list_index -= 1
+        return {'FINISHED'}
+
+
+class PSK_OT_material_list_move_down(Operator):
+    bl_idname = 'psk_export.material_list_item_move_down'
+    bl_label = 'Move Down'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Move the selected material down one slot'
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psk_export')
+        return pg.material_name_list_index < len(pg.material_name_list) - 1
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psk_export')
+        pg.material_name_list.move(pg.material_name_list_index, pg.material_name_list_index + 1)
+        pg.material_name_list_index += 1
+        return {'FINISHED'}
+
+
+class PSK_OT_material_list_name_move_up(Operator):
+    bl_idname = 'psk_export.material_name_list_item_move_up'
+    bl_label = 'Move Up'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Move the selected material name up one slot'
+
+    @classmethod
+    def poll(cls, context):
+        export_operator = get_collection_export_operator_from_context(context)
+        if export_operator is None:
+            return False
+        return export_operator.material_name_list_index > 0
+
+    def execute(self, context):
+        export_operator = get_collection_export_operator_from_context(context)
+        if export_operator is None:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No valid export operator found in context')
+            return {'CANCELLED'}
+        export_operator.material_name_list.move(export_operator.material_name_list_index, export_operator.material_name_list_index - 1)
+        export_operator.material_name_list_index -= 1
+        return {'FINISHED'}
+
+
+class PSK_OT_material_list_name_move_down(Operator):
+    bl_idname = 'psk_export.material_name_list_item_move_down'
+    bl_label = 'Move Down'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Move the selected material name down one slot'
+
+    @classmethod
+    def poll(cls, context):
+        export_operator = get_collection_export_operator_from_context(context)
+        if export_operator is None:
+            return False
+        return export_operator.material_name_list_index < len(export_operator.material_name_list) - 1
+
+    def execute(self, context):
+        export_operator = get_collection_export_operator_from_context(context)
+        if export_operator is None:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No valid export operator found in context')
+            return {'CANCELLED'}
+        export_operator.material_name_list.move(export_operator.material_name_list_index, export_operator.material_name_list_index + 1)
+        export_operator.material_name_list_index += 1
+        return {'FINISHED'}
+
+
+empty_set = set()
+
+
+def get_sorted_materials_by_names(materials: Iterable[Material], material_names: List[str]) -> List[Material]:
+    """
+    Sorts the materials by the order of the material names list. Any materials not in the list will be appended to the
+    end of the list in the order they are found.
+    @param materials: A list of materials to sort
+    @param material_names: A list of material names to sort by
+    @return: A sorted list of materials
+    """
+    materials_in_collection = [m for m in materials if m.name in material_names]
+    materials_not_in_collection = [m for m in materials if m.name not in material_names]
+    materials_in_collection = sorted(materials_in_collection, key=lambda x: material_names.index(x.name))
+    return materials_in_collection + materials_not_in_collection
+
+
+def get_psk_build_options_from_property_group(mesh_objects: Iterable[Object],  pg: 'PSK_PG_export', depsgraph: Optional[Depsgraph] = None) -> PskBuildOptions:
+    if depsgraph is None:
+        depsgraph = bpy.context.evaluated_depsgraph_get()
+
+    options = PskBuildOptions()
+    options.object_eval_state = pg.object_eval_state
+    options.export_space = pg.export_space
+    options.bone_filter_mode = pg.bone_filter_mode
+    options.bone_collection_indices = [x.index for x in pg.bone_collection_list if x.is_selected]
+    options.scale = pg.scale
+    options.forward_axis = pg.forward_axis
+    options.up_axis = pg.up_axis
+
+    # TODO: perhaps move this into the build function and replace the materials list with a material names list.
+    materials = get_materials_for_mesh_objects(depsgraph, mesh_objects)
+    options.materials = get_sorted_materials_by_names(materials, [m.material_name for m in pg.material_name_list])
+
+    return options
+
+
+class PSK_OT_export_collection(Operator, ExportHelper):
+    bl_idname = 'export.psk_collection'
+    bl_label = 'Export'
+    bl_options = {'INTERNAL'}
+    filename_ext = '.psk'
+    filter_glob: StringProperty(default='*.psk', options={'HIDDEN'})
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for exporting the PSK file',
+        maxlen=1024,
+        default='',
+        subtype='FILE_PATH')
+    collection: StringProperty(options={'HIDDEN'})
+
+    def execute(self, context):
+        collection = bpy.data.collections.get(self.collection)
+
+        try:
+            input_objects = get_psk_input_objects_for_collection(collection, self.should_exclude_hidden_meshes)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+
+        options = get_psk_build_options_from_property_group([x.obj for x in input_objects.mesh_objects], self)
+
+        try:
+            result = build_psk(context, input_objects, options)
+            for warning in result.warnings:
+                self.report({'WARNING'}, warning)
+            write_psk(result.psk, self.filepath)
+            if len(result.warnings) > 0:
+                self.report({'WARNING'}, f'PSK export successful with {len(result.warnings)} warnings')
+            else:
+                self.report({'INFO'}, f'PSK export successful')
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+
+        return {'FINISHED'}
+
+    def draw(self, context: Context):
+        layout = self.layout
+
+        flow = layout.grid_flow(row_major=True)
+        flow.use_property_split = True
+        flow.use_property_decorate = False
+
+        # MESH
+        mesh_header, mesh_panel = layout.panel('Mesh', default_closed=False)
+        mesh_header.label(text='Mesh', icon='MESH_DATA')
+        if mesh_panel:
+            flow = mesh_panel.grid_flow(row_major=True)
+            flow.use_property_split = True
+            flow.use_property_decorate = False
+            flow.prop(self, 'object_eval_state', text='Data')
+            flow.prop(self, 'should_exclude_hidden_meshes')
+
+        # BONES
+        bones_header, bones_panel = layout.panel('Bones', default_closed=False)
+        bones_header.label(text='Bones', icon='BONE_DATA')
+        if bones_panel:
+            draw_bone_filter_mode(bones_panel, self)
+            if self.bone_filter_mode == 'BONE_COLLECTIONS':
+                bones_panel.operator(PSK_OT_populate_bone_collection_list.bl_idname, icon='FILE_REFRESH')
+                rows = max(3, min(len(self.bone_collection_list), 10))
+                bones_panel.template_list('PSX_UL_bone_collection_list', '', self, 'bone_collection_list', self, 'bone_collection_list_index', rows=rows)
+
+        # MATERIALS
+        materials_header, materials_panel = layout.panel('Materials', default_closed=False)
+        materials_header.label(text='Materials', icon='MATERIAL')
+
+        if materials_panel:
+            materials_panel.operator(PSK_OT_populate_material_name_list.bl_idname, icon='FILE_REFRESH')
+            rows = max(3, min(len(self.material_name_list), 10))
+            row = materials_panel.row()
+            row.template_list('PSK_UL_material_names', '', self, 'material_name_list', self, 'material_name_list_index', rows=rows)
+            col = row.column(align=True)
+            col.operator(PSK_OT_material_list_name_move_up.bl_idname, text='', icon='TRIA_UP')
+            col.operator(PSK_OT_material_list_name_move_down.bl_idname, text='', icon='TRIA_DOWN')
+
+        # TRANSFORM
+        transform_header, transform_panel = layout.panel('Transform', default_closed=False)
+        transform_header.label(text='Transform')
+        if transform_panel:
+            flow = transform_panel.grid_flow(row_major=True)
+            flow.use_property_split = True
+            flow.use_property_decorate = False
+            flow.prop(self, 'export_space')
+            flow.prop(self, 'scale')
+            flow.prop(self, 'forward_axis')
+            flow.prop(self, 'up_axis')
+
+
+
+add_psk_export_properties(PSK_OT_export_collection)
+
+
+
+class PSK_OT_export(Operator, ExportHelper):
+    bl_idname = 'export.psk'
+    bl_label = 'Export'
+    bl_options = {'INTERNAL', 'UNDO'}
+    bl_description = 'Export mesh and armature to PSK'
+    filename_ext = '.psk'
+    filter_glob: StringProperty(default='*.psk', options={'HIDDEN'})
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for exporting the PSK file',
+        maxlen=1024,
+        default='')
+
+    def invoke(self, context, event):
+        try:
+            input_objects = get_psk_input_objects_for_context(context)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+
+        if len(input_objects.mesh_objects) == 0:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No mesh objects selected')
+            return {'CANCELLED'}
+
+        pg = getattr(context.scene, 'psk_export')
+
+        populate_bone_collection_list(input_objects.armature_object, pg.bone_collection_list)
+
+        depsgraph = context.evaluated_depsgraph_get()
+
+        try:
+            populate_material_name_list(depsgraph, [x.obj for x in input_objects.mesh_objects], pg.material_name_list)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+
+        context.window_manager.fileselect_add(self)
+
+        return {'RUNNING_MODAL'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        pg = getattr(context.scene, 'psk_export')
+
+        # MESH
+        mesh_header, mesh_panel = layout.panel('Mesh', default_closed=False)
+        mesh_header.label(text='Mesh', icon='MESH_DATA')
+        if mesh_panel:
+            flow = mesh_panel.grid_flow(row_major=True)
+            flow.use_property_split = True
+            flow.use_property_decorate = False
+            flow.prop(pg, 'object_eval_state', text='Data')
+
+        # BONES
+        bones_header, bones_panel = layout.panel('Bones', default_closed=False)
+        bones_header.label(text='Bones', icon='BONE_DATA')
+        if bones_panel:
+            draw_bone_filter_mode(bones_panel, pg)
+            if pg.bone_filter_mode == 'BONE_COLLECTIONS':
+                row = bones_panel.row()
+                rows = max(3, min(len(pg.bone_collection_list), 10))
+                row.template_list('PSX_UL_bone_collection_list', '', pg, 'bone_collection_list', pg, 'bone_collection_list_index', rows=rows)
+
+        # MATERIALS
+        materials_header, materials_panel = layout.panel('Materials', default_closed=False)
+        materials_header.label(text='Materials', icon='MATERIAL')
+        if materials_panel:
+            row = materials_panel.row()
+            rows = max(3, min(len(pg.bone_collection_list), 10))
+            row.template_list('PSK_UL_material_names', '', pg, 'material_name_list', pg, 'material_name_list_index', rows=rows)
+            col = row.column(align=True)
+            col.operator(PSK_OT_material_list_move_up.bl_idname, text='', icon='TRIA_UP')
+            col.operator(PSK_OT_material_list_move_down.bl_idname, text='', icon='TRIA_DOWN')
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psk_export')
+
+        input_objects = get_psk_input_objects_for_context(context)
+        options = get_psk_build_options_from_property_group([x.obj for x in input_objects.mesh_objects], pg)
+
+        try:
+            result = build_psk(context, input_objects, options)
+            for warning in result.warnings:
+                self.report({'WARNING'}, warning)
+            write_psk(result.psk, self.filepath)
+            if len(result.warnings) > 0:
+                self.report({'WARNING'}, f'PSK export successful with {len(result.warnings)} warnings')
+            else:
+                self.report({'INFO'}, f'PSK export successful')
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+
+        return {'FINISHED'}
+
+
+classes = (
+    PSK_OT_material_list_move_up,
+    PSK_OT_material_list_move_down,
+    PSK_OT_export,
+    PSK_OT_export_collection,
+    PSK_OT_populate_bone_collection_list,
+    PSK_OT_populate_material_name_list,
+    PSK_OT_material_list_name_move_up,
+    PSK_OT_material_list_name_move_down,
+)

io_scene_psk_psa/psk/export/properties.py

@@ -0,0 +1,126 @@
+from bpy.props import EnumProperty, CollectionProperty, IntProperty, PointerProperty, FloatProperty, StringProperty, \
+    BoolProperty
+from bpy.types import PropertyGroup, Material
+
+from ...shared.data import bone_filter_mode_items
+from ...shared.types import PSX_PG_bone_collection_list_item
+
+empty_set = set()
+
+object_eval_state_items = (
+    ('EVALUATED', 'Evaluated', 'Use data from fully evaluated object'),
+    ('ORIGINAL', 'Original', 'Use data from original object with no modifiers applied'),
+)
+
+export_space_items = [
+    ('WORLD', 'World', 'Export in world space'),
+    ('ARMATURE', 'Armature', 'Export in armature space'),
+]
+
+
+axis_identifiers = ('X', 'Y', 'Z', '-X', '-Y', '-Z')
+forward_items = (
+    ('X', 'X Forward', ''),
+    ('Y', 'Y Forward', ''),
+    ('Z', 'Z Forward', ''),
+    ('-X', '-X Forward', ''),
+    ('-Y', '-Y Forward', ''),
+    ('-Z', '-Z Forward', ''),
+)
+
+up_items = (
+    ('X', 'X Up', ''),
+    ('Y', 'Y Up', ''),
+    ('Z', 'Z Up', ''),
+    ('-X', '-X Up', ''),
+    ('-Y', '-Y Up', ''),
+    ('-Z', '-Z Up', ''),
+)
+
+class PSK_PG_material_list_item(PropertyGroup):
+    material: PointerProperty(type=Material)
+    index: IntProperty()
+
+class PSK_PG_material_name_list_item(PropertyGroup):
+    material_name: StringProperty()
+    index: IntProperty()
+
+
+
+
+def forward_axis_update(self, _context):
+    if self.forward_axis == self.up_axis:
+        # Automatically set the up axis to the next available axis
+        self.up_axis = next((axis for axis in axis_identifiers if axis != self.forward_axis), 'Z')
+
+
+def up_axis_update(self, _context):
+    if self.up_axis == self.forward_axis:
+        # Automatically set the forward axis to the next available axis
+        self.forward_axis = next((axis for axis in axis_identifiers if axis != self.up_axis), 'X')
+
+
+
+# In order to share the same properties between the PSA and PSK export properties, we need to define the properties in a
+# separate function and then apply them to the classes. This is because the collection exporter cannot have
+# PointerProperties, so we must effectively duplicate the storage of the properties.
+def add_psk_export_properties(cls):
+        cls.__annotations__['object_eval_state'] = EnumProperty(
+            items=object_eval_state_items,
+            name='Object Evaluation State',
+            default='EVALUATED'
+        )
+        cls.__annotations__['should_exclude_hidden_meshes'] = BoolProperty(
+            default=False,
+            name='Visible Only',
+            description='Export only visible meshes'
+        )
+        cls.__annotations__['scale'] = FloatProperty(
+            name='Scale',
+            default=1.0,
+            description='Scale factor to apply to the exported mesh and armature',
+            min=0.0001,
+            soft_max=100.0
+        )
+        cls.__annotations__['export_space'] = EnumProperty(
+            name='Export Space',
+            description='Space to export the mesh in',
+            items=export_space_items,
+            default='WORLD'
+        )
+        cls.__annotations__['bone_filter_mode'] = EnumProperty(
+            name='Bone Filter',
+            options=empty_set,
+            description='',
+            items=bone_filter_mode_items,
+        )
+        cls.__annotations__['bone_collection_list'] = CollectionProperty(type=PSX_PG_bone_collection_list_item)
+        cls.__annotations__['bone_collection_list_index'] = IntProperty(default=0)
+        cls.__annotations__['forward_axis'] = EnumProperty(
+            name='Forward',
+            items=forward_items,
+            default='X',
+            update=forward_axis_update
+        )
+        cls.__annotations__['up_axis'] = EnumProperty(
+            name='Up',
+            items=up_items,
+            default='Z',
+            update=up_axis_update
+        )
+        cls.__annotations__['material_name_list'] = CollectionProperty(type=PSK_PG_material_name_list_item)
+        cls.__annotations__['material_name_list_index'] = IntProperty(default=0)
+
+
+class PSK_PG_export(PropertyGroup):
+    pass
+
+
+add_psk_export_properties(PSK_PG_export)
+
+
+classes = (
+    PSK_PG_material_list_item,
+    PSK_PG_material_name_list_item,
+    PSK_PG_export,
+)

io_scene_psk_psa/psk/export/ui.py

@@ -0,0 +1,14 @@
+import bpy
+from bpy.types import UIList
+
+
+class PSK_UL_material_names(UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+        row = layout.row()
+        material = bpy.data.materials.get(item.material_name, None)
+        row.prop(item, 'material_name', text='', emboss=False, icon_value=layout.icon(material) if material else 0)
+
+
+classes = (
+    PSK_UL_material_names,
+)

io_scene_psk_psa/psk/exporter.py

@@ -1,272 +0,0 @@
-from typing import Type
-
-from bpy.props import BoolProperty, StringProperty, CollectionProperty, IntProperty, EnumProperty
-from bpy.types import Operator, PropertyGroup, UIList
-from bpy_extras.io_utils import ExportHelper
-
-from .builder import build_psk, PskBuildOptions, get_psk_input_objects
-from .data import *
-from ..helpers import populate_bone_group_list
-from ..types import BoneGroupListItem
-
-MAX_WEDGE_COUNT = 65536
-MAX_POINT_COUNT = 4294967296
-MAX_BONE_COUNT = 256
-MAX_MATERIAL_COUNT = 256
-
-
-def _write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
-    section = Section()
-    section.name = name
-    if data_type is not None and data is not None:
-        section.data_size = sizeof(data_type)
-        section.data_count = len(data)
-    fp.write(section)
-    if data is not None:
-        for datum in data:
-            fp.write(datum)
-
-
-def export_psk(psk: Psk, path: str):
-    if len(psk.wedges) > MAX_WEDGE_COUNT:
-        raise RuntimeError(f'Number of wedges ({len(psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
-    if len(psk.points) > MAX_POINT_COUNT:
-        raise RuntimeError(f'Numbers of vertices ({len(psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
-    if len(psk.materials) > MAX_MATERIAL_COUNT:
-        raise RuntimeError(f'Number of materials ({len(psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
-    if len(psk.bones) > MAX_BONE_COUNT:
-        raise RuntimeError(f'Number of bones ({len(psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
-    elif len(psk.bones) == 0:
-        raise RuntimeError(f'At least one bone must be marked for export')
-
-    with open(path, 'wb') as fp:
-        _write_section(fp, b'ACTRHEAD')
-        _write_section(fp, b'PNTS0000', Vector3, psk.points)
-
-        wedges = []
-        for index, w in enumerate(psk.wedges):
-            wedge = Psk.Wedge16()
-            wedge.material_index = w.material_index
-            wedge.u = w.u
-            wedge.v = w.v
-            wedge.point_index = w.point_index
-            wedges.append(wedge)
-
-        _write_section(fp, b'VTXW0000', Psk.Wedge16, wedges)
-        _write_section(fp, b'FACE0000', Psk.Face, psk.faces)
-        _write_section(fp, b'MATT0000', Psk.Material, psk.materials)
-        _write_section(fp, b'REFSKELT', Psk.Bone, psk.bones)
-        _write_section(fp, b'RAWWEIGHTS', Psk.Weight, psk.weights)
-
-
-def is_bone_filter_mode_item_available(context, identifier):
-    input_objects = get_psk_input_objects(context)
-    armature_object = input_objects.armature_object
-    if identifier == 'BONE_GROUPS':
-        if not armature_object or not armature_object.pose or not armature_object.pose.bone_groups:
-            return False
-    # else if... you can set up other conditions if you add more options
-    return True
-
-
-class PSK_UL_MaterialList(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
-        row = layout.row()
-        row.label(text=str(getattr(item, 'material_name')), icon='MATERIAL')
-
-
-class MaterialListItem(PropertyGroup):
-    material_name: StringProperty()
-    index: IntProperty()
-
-    @property
-    def name(self):
-        return self.material_name
-
-
-def populate_material_list(mesh_objects, material_list):
-    material_list.clear()
-
-    material_names = []
-    for mesh_object in mesh_objects:
-        for i, material in enumerate(mesh_object.data.materials):
-            # TODO: put this in the poll arg?
-            if material is None:
-                raise RuntimeError('Material cannot be empty (index ' + str(i) + ')')
-            if material.name not in material_names:
-                material_names.append(material.name)
-
-    for index, material_name in enumerate(material_names):
-        m = material_list.add()
-        m.material_name = material_name
-        m.index = index
-
-
-class PskMaterialListItemMoveUp(Operator):
-    bl_idname = 'psk_export.material_list_item_move_up'
-    bl_label = 'Move Up'
-    bl_options = {'INTERNAL'}
-    bl_description = 'Move the selected material up one slot'
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psk_export')
-        return pg.material_list_index > 0
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psk_export')
-        pg.material_list.move(pg.material_list_index, pg.material_list_index - 1)
-        pg.material_list_index -= 1
-        return {"FINISHED"}
-
-
-class PskMaterialListItemMoveDown(Operator):
-    bl_idname = 'psk_export.material_list_item_move_down'
-    bl_label = 'Move Down'
-    bl_options = {'INTERNAL'}
-    bl_description = 'Move the selected material down one slot'
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psk_export')
-        return pg.material_list_index < len(pg.material_list) - 1
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psk_export')
-        pg.material_list.move(pg.material_list_index, pg.material_list_index + 1)
-        pg.material_list_index += 1
-        return {"FINISHED"}
-
-
-class PskExportOperator(Operator, ExportHelper):
-    bl_idname = 'export.psk'
-    bl_label = 'Export'
-    bl_options = {'INTERNAL', 'UNDO'}
-    __doc__ = 'Export mesh and armature to PSK'
-    filename_ext = '.psk'
-    filter_glob: StringProperty(default='*.psk', options={'HIDDEN'})
-
-    filepath: StringProperty(
-        name='File Path',
-        description='File path used for exporting the PSK file',
-        maxlen=1024,
-        default='')
-
-    def invoke(self, context, event):
-        try:
-            input_objects = get_psk_input_objects(context)
-        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-            return {'CANCELLED'}
-
-        pg = getattr(context.scene, 'psk_export')
-
-        # Populate bone groups list.
-        populate_bone_group_list(input_objects.armature_object, pg.bone_group_list)
-
-        try:
-            populate_material_list(input_objects.mesh_objects, pg.material_list)
-        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-            return {'CANCELLED'}
-
-        context.window_manager.fileselect_add(self)
-
-        return {'RUNNING_MODAL'}
-
-    @classmethod
-    def poll(cls, context):
-        try:
-            get_psk_input_objects(context)
-        except RuntimeError as e:
-            cls.poll_message_set(str(e))
-            return False
-        return True
-
-    def draw(self, context):
-        layout = self.layout
-        pg = getattr(context.scene, 'psk_export')
-
-        layout.prop(pg, 'use_raw_mesh_data')
-
-        # BONES
-        layout.label(text='Bones', icon='BONE_DATA')
-        bone_filter_mode_items = pg.bl_rna.properties['bone_filter_mode'].enum_items_static
-        row = layout.row(align=True)
-        for item in bone_filter_mode_items:
-            identifier = item.identifier
-            item_layout = row.row(align=True)
-            item_layout.prop_enum(pg, 'bone_filter_mode', item.identifier)
-            item_layout.enabled = is_bone_filter_mode_item_available(context, identifier)
-
-        if pg.bone_filter_mode == 'BONE_GROUPS':
-            row = layout.row()
-            rows = max(3, min(len(pg.bone_group_list), 10))
-            row.template_list('PSX_UL_BoneGroupList', '', pg, 'bone_group_list', pg, 'bone_group_list_index', rows=rows)
-
-        layout.separator()
-
-        # MATERIALS
-        layout.label(text='Materials', icon='MATERIAL')
-        row = layout.row()
-        rows = max(3, min(len(pg.bone_group_list), 10))
-        row.template_list('PSK_UL_MaterialList', '', pg, 'material_list', pg, 'material_list_index', rows=rows)
-        col = row.column(align=True)
-        col.operator(PskMaterialListItemMoveUp.bl_idname, text='', icon='TRIA_UP')
-        col.operator(PskMaterialListItemMoveDown.bl_idname, text='', icon='TRIA_DOWN')
-
-        layout.separator()
-
-        layout.prop(pg, 'should_ignore_bone_name_restrictions')
-
-    def execute(self, context):
-        pg = context.scene.psk_export
-        options = PskBuildOptions()
-        options.bone_filter_mode = pg.bone_filter_mode
-        options.bone_group_indices = [x.index for x in pg.bone_group_list if x.is_selected]
-        options.use_raw_mesh_data = pg.use_raw_mesh_data
-        options.material_names = [m.material_name for m in pg.material_list]
-        options.should_ignore_bone_name_restrictions = pg.should_ignore_bone_name_restrictions
-
-        try:
-            psk = build_psk(context, options)
-            export_psk(psk, self.filepath)
-            self.report({'INFO'}, f'PSK export successful')
-        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-            return {'CANCELLED'}
-        return {'FINISHED'}
-
-
-class PskExportPropertyGroup(PropertyGroup):
-    bone_filter_mode: EnumProperty(
-        name='Bone Filter',
-        options=set(),
-        description='',
-        items=(
-            ('ALL', 'All', 'All bones will be exported.'),
-            ('BONE_GROUPS', 'Bone Groups',
-             'Only bones belonging to the selected bone groups and their ancestors will be exported.')
-        )
-    )
-    bone_group_list: CollectionProperty(type=BoneGroupListItem)
-    bone_group_list_index: IntProperty(default=0)
-    use_raw_mesh_data: BoolProperty(default=False, name='Raw Mesh Data', description='No modifiers will be evaluated as part of the exported mesh')
-    material_list: CollectionProperty(type=MaterialListItem)
-    material_list_index: IntProperty(default=0)
-    should_ignore_bone_name_restrictions: BoolProperty(
-        default=False,
-        name='Ignore Bone Name Restrictions',
-        description='Bone names restrictions will be ignored. Note that bone names without properly formatted names '
-                    'cannot be referenced in scripts.'
-    )
-
-
-classes = (
-    MaterialListItem,
-    PSK_UL_MaterialList,
-    PskMaterialListItemMoveUp,
-    PskMaterialListItemMoveDown,
-    PskExportOperator,
-    PskExportPropertyGroup,
-)

io_scene_psk_psa/psk/import_/operators.py

@@ -0,0 +1,187 @@
+import os
+import sys
+
+from bpy.props import StringProperty, BoolProperty, EnumProperty, FloatProperty
+from bpy.types import Operator, FileHandler, Context
+from bpy_extras.io_utils import ImportHelper
+
+from ..importer import PskImportOptions, import_psk
+from ..reader import read_psk
+
+empty_set = set()
+
+
+class PSK_FH_import(FileHandler):
+    bl_idname = 'PSK_FH_import'
+    bl_label = 'Unreal PSK'
+    bl_import_operator = 'import_scene.psk'
+    bl_export_operator = 'export.psk_collection'
+    bl_file_extensions = '.psk;.pskx'
+
+    @classmethod
+    def poll_drop(cls, context: Context):
+        return context.area and context.area.type == 'VIEW_3D'
+
+
+class PSK_OT_import(Operator, ImportHelper):
+    bl_idname = 'import_scene.psk'
+    bl_label = 'Import'
+    bl_options = {'INTERNAL', 'UNDO', 'PRESET'}
+    bl_description = 'Import a PSK file'
+    filename_ext = '.psk'
+    filter_glob: StringProperty(default='*.psk;*.pskx', options={'HIDDEN'})
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for exporting the PSK file',
+        maxlen=1024,
+        default='')
+
+    should_import_vertex_colors: BoolProperty(
+        default=True,
+        options=empty_set,
+        name='Import Vertex Colors',
+        description='Import vertex colors, if available'
+    )
+    vertex_color_space: EnumProperty(
+        name='Vertex Color Space',
+        options=empty_set,
+        description='The source vertex color space',
+        default='SRGBA',
+        items=(
+            ('LINEAR', 'Linear', ''),
+            ('SRGBA', 'sRGBA', ''),
+        )
+    )
+    should_import_vertex_normals: BoolProperty(
+        default=True,
+        name='Import Vertex Normals',
+        options=empty_set,
+        description='Import vertex normals, if available'
+    )
+    should_import_extra_uvs: BoolProperty(
+        default=True,
+        name='Import Extra UVs',
+        options=empty_set,
+        description='Import extra UV maps, if available'
+    )
+    should_import_mesh: BoolProperty(
+        default=True,
+        name='Import Mesh',
+        options=empty_set,
+        description='Import mesh'
+    )
+    should_import_materials: BoolProperty(
+        default=True,
+        name='Import Materials',
+        options=empty_set,
+    )
+    should_import_skeleton: BoolProperty(
+        default=True,
+        name='Import Skeleton',
+        options=empty_set,
+        description='Import skeleton'
+    )
+    bone_length: FloatProperty(
+        default=1.0,
+        min=sys.float_info.epsilon,
+        step=100,
+        soft_min=1.0,
+        name='Bone Length',
+        options=empty_set,
+        subtype='DISTANCE',
+        description='Length of the bones'
+    )
+    should_import_shape_keys: BoolProperty(
+        default=True,
+        name='Import Shape Keys',
+        options=empty_set,
+        description='Import shape keys, if available'
+    )
+    scale: FloatProperty(
+        name='Scale',
+        default=1.0,
+        soft_min=0.0,
+    )
+    bdk_repository_id: StringProperty(
+        name='BDK Repository ID',
+        default='',
+        options=empty_set,
+        description='The ID of the BDK repository to use for loading materials'
+    )
+
+    def execute(self, context):
+        psk = read_psk(self.filepath)
+
+        options = PskImportOptions()
+        options.name = os.path.splitext(os.path.basename(self.filepath))[0]
+        options.should_import_mesh = self.should_import_mesh
+        options.should_import_extra_uvs = self.should_import_extra_uvs
+        options.should_import_vertex_colors = self.should_import_vertex_colors
+        options.should_import_vertex_normals = self.should_import_vertex_normals
+        options.vertex_color_space = self.vertex_color_space
+        options.should_import_skeleton = self.should_import_skeleton
+        options.bone_length = self.bone_length
+        options.should_import_materials = self.should_import_materials
+        options.should_import_shape_keys = self.should_import_shape_keys
+        options.scale = self.scale
+
+        if self.bdk_repository_id:
+            options.bdk_repository_id = self.bdk_repository_id
+
+        if not options.should_import_mesh and not options.should_import_skeleton:
+            self.report({'ERROR'}, 'Nothing to import')
+            return {'CANCELLED'}
+
+        result = import_psk(psk, context, options)
+
+        if len(result.warnings):
+            message = f'PSK imported with {len(result.warnings)} warning(s)\n'
+            message += '\n'.join(result.warnings)
+            self.report({'WARNING'}, message)
+        else:
+            self.report({'INFO'}, f'PSK imported ({options.name})')
+
+        return {'FINISHED'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        row = layout.row()
+
+        col = row.column()
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(self, 'scale')
+        col.prop(self, 'export_space')
+
+        mesh_header, mesh_panel = layout.panel('mesh_panel_id', default_closed=False)
+        mesh_header.prop(self, 'should_import_mesh')
+
+        if mesh_panel and self.should_import_mesh:
+            row = mesh_panel.row()
+            col = row.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(self, 'should_import_materials', text='Materials')
+            col.prop(self, 'should_import_vertex_normals', text='Vertex Normals')
+            col.prop(self, 'should_import_extra_uvs', text='Extra UVs')
+            col.prop(self, 'should_import_vertex_colors', text='Vertex Colors')
+            if self.should_import_vertex_colors:
+                col.prop(self, 'vertex_color_space')
+            col.prop(self, 'should_import_shape_keys', text='Shape Keys')
+
+        skeleton_header, skeleton_panel = layout.panel('skeleton_panel_id', default_closed=False)
+        skeleton_header.prop(self, 'should_import_skeleton')
+
+        if skeleton_panel and self.should_import_skeleton:
+            row = skeleton_panel.row()
+            col = row.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(self, 'bone_length')
+
+
+classes = (
+    PSK_OT_import,
+    PSK_FH_import,
+)

io_scene_psk_psa/psk/importer.py

@@ -1,38 +1,37 @@
-import os
-import sys
-from math import inf
 from typing import Optional, List
 
 import bmesh
 import bpy
 import numpy as np
-from bpy.props import BoolProperty, EnumProperty, FloatProperty, StringProperty
+from bpy.types import VertexGroup
-from bpy.types import Operator, PropertyGroup, VertexGroup
-from bpy_extras.io_utils import ImportHelper
 from mathutils import Quaternion, Vector, Matrix
 
 from .data import Psk
-from .reader import read_psk
+from .properties import poly_flags_to_triangle_type_and_bit_flags
-from ..helpers import rgb_to_srgb
+from ..shared.helpers import rgb_to_srgb, is_bdk_addon_loaded
 
 
-class PskImportOptions(object):
+class PskImportOptions:
     def __init__(self):
         self.name = ''
         self.should_import_mesh = True
+        self.should_reuse_materials = True
         self.should_import_vertex_colors = True
-        self.vertex_color_space = 'sRGB'
+        self.vertex_color_space = 'SRGB'
         self.should_import_vertex_normals = True
         self.should_import_extra_uvs = True
         self.should_import_skeleton = True
         self.should_import_shape_keys = True
         self.bone_length = 1.0
+        self.should_import_materials = True
+        self.scale = 1.0
+        self.bdk_repository_id = None
 
 
-class ImportBone(object):
+class ImportBone:
-    """
+    '''
     Intermediate bone type for the purpose of construction.
-    """
+    '''
     def __init__(self, index: int, psk_bone: Psk.Bone):
         self.index: int = index
         self.psk_bone: Psk.Bone = psk_bone
@@ -42,9 +41,9 @@ class ImportBone(object):
         self.world_rotation_matrix: Matrix = Matrix()
         self.world_matrix: Matrix = Matrix()
         self.vertex_group = None
-        self.orig_quat: Quaternion = Quaternion()
+        self.original_rotation: Quaternion = Quaternion()
-        self.orig_loc: Vector = Vector()
+        self.original_location: Vector = Vector()
-        self.post_quat: Quaternion = Quaternion()
+        self.post_rotation: Quaternion = Quaternion()
 
 
 class PskImportResult:
@@ -55,6 +54,7 @@ class PskImportResult:
 def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
     result = PskImportResult()
     armature_object = None
+    mesh_object = None
 
     if options.should_import_skeleton:
         # ARMATURE
@@ -114,22 +114,34 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
             edit_bone_matrix.translation = import_bone.world_matrix.translation
             edit_bone.matrix = edit_bone_matrix
 
-            # Store bind pose information in the bone's custom properties.
-            # This information is used when importing animations from PSA files.
-            edit_bone['orig_quat'] = import_bone.local_rotation
-            edit_bone['orig_loc'] = import_bone.local_translation
-            edit_bone['post_quat'] = import_bone.local_rotation.conjugated()
-
     # MESH
     if options.should_import_mesh:
         mesh_data = bpy.data.meshes.new(options.name)
         mesh_object = bpy.data.objects.new(options.name, mesh_data)
 
         # MATERIALS
-        for material in psk.materials:
+        if options.should_import_materials:
-            # TODO: re-use of materials should be an option
+            for material_index, psk_material in enumerate(psk.materials):
-            bpy_material = bpy.data.materials.new(material.name.decode('utf-8'))
+                material_name = psk_material.name.decode('utf-8')
-            mesh_data.materials.append(bpy_material)
+                material = None
+                if options.should_reuse_materials and material_name in bpy.data.materials:
+                    # Material already exists, just re-use it.
+                    material = bpy.data.materials[material_name]
+                elif is_bdk_addon_loaded() and psk.has_material_references:
+                    # Material does not yet exist, and we have the BDK addon installed.
+                    # Attempt to load it using BDK addon's operator.
+                    material_reference = psk.material_references[material_index]
+                    repository_id = options.bdk_repository_id if options.bdk_repository_id is not None else ''
+                    if material_reference and bpy.ops.bdk.link_material(reference=material_reference, repository_id=repository_id) == {'FINISHED'}:
+                        material = bpy.data.materials[material_name]
+                else:
+                    # Just create a blank material.
+                    material = bpy.data.materials.new(material_name)
+                    mesh_triangle_type, mesh_triangle_bit_flags = poly_flags_to_triangle_type_and_bit_flags(psk_material.poly_flags)
+                    material.psk.mesh_triangle_type = mesh_triangle_type
+                    material.psk.mesh_triangle_bit_flags = mesh_triangle_bit_flags
+                    material.use_nodes = True
+                mesh_data.materials.append(material)
 
         bm = bmesh.new()
 
@@ -139,85 +151,90 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
 
         bm.verts.ensure_lookup_table()
 
-        degenerate_face_indices = set()
+        # FACES
+        invalid_face_indices = set()
         for face_index, face in enumerate(psk.faces):
-            point_indices = [bm.verts[psk.wedges[i].point_index] for i in reversed(face.wedge_indices)]
+            point_indices = map(lambda i: psk.wedges[i].point_index, reversed(face.wedge_indices))
+            points = [bm.verts[i] for i in point_indices]
             try:
-                bm_face = bm.faces.new(point_indices)
+                bm_face = bm.faces.new(points)
                 bm_face.material_index = face.material_index
             except ValueError:
-                degenerate_face_indices.add(face_index)
+                # This happens for two reasons:
+                # 1. Two or more of the face's points are the same. (i.e, point indices of [0, 0, 1])
+                # 2. The face is a duplicate of another face. (i.e., point indices of [0, 1, 2] and [0, 1, 2])
+                invalid_face_indices.add(face_index)
 
-        if len(degenerate_face_indices) > 0:
+        # TODO: Handle invalid faces better.
-            result.warnings.append(f'Discarded {len(degenerate_face_indices)} degenerate face(s).')
+        if len(invalid_face_indices) > 0:
+            result.warnings.append(f'Discarded {len(invalid_face_indices)} invalid face(s).')
 
         bm.to_mesh(mesh_data)
 
         # TEXTURE COORDINATES
-        data_index = 0
+        uv_layer_data_index = 0
-        uv_layer = mesh_data.uv_layers.new(name='VTXW0000')
+        uv_layer = mesh_data.uv_layers.new(name='UVMap')
         for face_index, face in enumerate(psk.faces):
-            if face_index in degenerate_face_indices:
+            if face_index in invalid_face_indices:
                 continue
             face_wedges = [psk.wedges[i] for i in reversed(face.wedge_indices)]
             for wedge in face_wedges:
-                uv_layer.data[data_index].uv = wedge.u, 1.0 - wedge.v
+                uv_layer.data[uv_layer_data_index].uv = wedge.u, 1.0 - wedge.v
-                data_index += 1
+                uv_layer_data_index += 1
 
         # EXTRA UVS
         if psk.has_extra_uvs and options.should_import_extra_uvs:
             extra_uv_channel_count = int(len(psk.extra_uvs) / len(psk.wedges))
             wedge_index_offset = 0
             for extra_uv_index in range(extra_uv_channel_count):
-                data_index = 0
+                uv_layer_data_index = 0
                 uv_layer = mesh_data.uv_layers.new(name=f'EXTRAUV{extra_uv_index}')
                 for face_index, face in enumerate(psk.faces):
-                    if face_index in degenerate_face_indices:
+                    if face_index in invalid_face_indices:
                         continue
                     for wedge_index in reversed(face.wedge_indices):
                         u, v = psk.extra_uvs[wedge_index_offset + wedge_index]
-                        uv_layer.data[data_index].uv = u, 1.0 - v
+                        uv_layer.data[uv_layer_data_index].uv = u, 1.0 - v
-                        data_index += 1
+                        uv_layer_data_index += 1
                 wedge_index_offset += len(psk.wedges)
 
         # VERTEX COLORS
         if psk.has_vertex_colors and options.should_import_vertex_colors:
-            size = (len(psk.points), 4)
+            # Convert vertex colors to sRGB if necessary.
-            vertex_colors = np.full(size, inf)
+            psk_vertex_colors = np.zeros((len(psk.vertex_colors), 4))
-            vertex_color_data = mesh_data.vertex_colors.new(name='VERTEXCOLOR')
+            for vertex_color_index in range(len(psk.vertex_colors)):
-            ambiguous_vertex_color_point_indices = []
+                psk_vertex_colors[vertex_color_index,:] = psk.vertex_colors[vertex_color_index].normalized()
+            match options.vertex_color_space:
+                case 'SRGBA':
+                    for i in range(psk_vertex_colors.shape[0]):
+                        psk_vertex_colors[i, :3] = tuple(map(lambda x: rgb_to_srgb(x), psk_vertex_colors[i, :3]))
+                case _:
+                    pass
 
-            for wedge_index, wedge in enumerate(psk.wedges):
+            # Map the PSK vertex colors to the face corners.
-                point_index = wedge.point_index
+            face_count = len(psk.faces) - len(invalid_face_indices)
-                psk_vertex_color = psk.vertex_colors[wedge_index].normalized()
+            face_corner_colors = np.full((face_count * 3, 4), 1.0)
-                if vertex_colors[point_index, 0] != inf and tuple(vertex_colors[point_index]) != psk_vertex_color:
+            face_corner_color_index = 0
-                    ambiguous_vertex_color_point_indices.append(point_index)
+            for face_index, face in enumerate(psk.faces):
-                else:
+                if face_index in invalid_face_indices:
-                    vertex_colors[point_index] = psk_vertex_color
+                    continue
+                for wedge_index in reversed(face.wedge_indices):
+                    face_corner_colors[face_corner_color_index] = psk_vertex_colors[wedge_index]
+                    face_corner_color_index += 1
 
-            if options.vertex_color_space == 'SRGBA':
+            # Create the vertex color attribute.
-                for i in range(vertex_colors.shape[0]):
+            face_corner_color_attribute = mesh_data.attributes.new(name='VERTEXCOLOR', type='FLOAT_COLOR', domain='CORNER')
-                    vertex_colors[i, :3] = tuple(map(lambda x: rgb_to_srgb(x), vertex_colors[i, :3]))
+            face_corner_color_attribute.data.foreach_set('color', face_corner_colors.flatten())
-
-            for loop_index, loop in enumerate(mesh_data.loops):
-                vertex_color = vertex_colors[loop.vertex_index]
-                if vertex_color is not None:
-                    vertex_color_data.data[loop_index].color = vertex_color
-                else:
-                    vertex_color_data.data[loop_index].color = 1.0, 1.0, 1.0, 1.0
-
-            if len(ambiguous_vertex_color_point_indices) > 0:
-                result.warnings.append(
-                    f'{len(ambiguous_vertex_color_point_indices)} vertex(es) with ambiguous vertex colors.')
 
         # VERTEX NORMALS
         if psk.has_vertex_normals and options.should_import_vertex_normals:
-            mesh_data.polygons.foreach_set("use_smooth", [True] * len(mesh_data.polygons))
+            mesh_data.polygons.foreach_set('use_smooth', [True] * len(mesh_data.polygons))
             normals = []
             for vertex_normal in psk.vertex_normals:
                 normals.append(tuple(vertex_normal))
             mesh_data.normals_split_custom_set_from_vertices(normals)
-            mesh_data.use_auto_smooth = True
+        else:
+            mesh_data.shade_smooth()
 
         bm.normal_update()
         bm.free()
@@ -255,138 +272,12 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
             armature_modifier.object = armature_object
             mesh_object.parent = armature_object
 
+    root_object = armature_object if options.should_import_skeleton else mesh_object
+    root_object.scale = (options.scale, options.scale, options.scale)
+
     try:
         bpy.ops.object.mode_set(mode='OBJECT')
     except:
         pass
 
     return result
-
-
-empty_set = set()
-
-
-class PskImportPropertyGroup(PropertyGroup):
-    should_import_vertex_colors: BoolProperty(
-        default=True,
-        options=empty_set,
-        name='Vertex Colors',
-        description='Import vertex colors from PSKX files, if available'
-    )
-    vertex_color_space: EnumProperty(
-        name='Vertex Color Space',
-        options=empty_set,
-        description='The source vertex color space',
-        default='SRGBA',
-        items=(
-            ('LINEAR', 'Linear', ''),
-            ('SRGBA', 'sRGBA', ''),
-        )
-    )
-    should_import_vertex_normals: BoolProperty(
-        default=True,
-        name='Vertex Normals',
-        options=empty_set,
-        description='Import vertex normals, if available'
-    )
-    should_import_extra_uvs: BoolProperty(
-        default=True,
-        name='Extra UVs',
-        options=empty_set,
-        description='Import extra UV maps, if available'
-    )
-    should_import_mesh: BoolProperty(
-        default=True,
-        name='Import Mesh',
-        options=empty_set,
-        description='Import mesh'
-    )
-    should_import_skeleton: BoolProperty(
-        default=True,
-        name='Import Skeleton',
-        options=empty_set,
-        description='Import skeleton'
-    )
-    bone_length: FloatProperty(
-        default=1.0,
-        min=sys.float_info.epsilon,
-        step=100,
-        soft_min=1.0,
-        name='Bone Length',
-        options=empty_set,
-        description='Length of the bones'
-    )
-    should_import_shape_keys: BoolProperty(
-        default=True,
-        name='Import Shape Keys',
-        options=empty_set,
-        description='Import shape keys, if available'
-    )
-
-
-class PskImportOperator(Operator, ImportHelper):
-    bl_idname = 'import.psk'
-    bl_label = 'Import'
-    bl_options = {'INTERNAL', 'UNDO'}
-    __doc__ = 'Load a PSK file'
-    filename_ext = '.psk'
-    filter_glob: StringProperty(default='*.psk;*.pskx', options={'HIDDEN'})
-    filepath: StringProperty(
-        name='File Path',
-        description='File path used for exporting the PSK file',
-        maxlen=1024,
-        default='')
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psk_import')
-
-        psk = read_psk(self.filepath)
-
-        options = PskImportOptions()
-        options.name = os.path.splitext(os.path.basename(self.filepath))[0]
-        options.should_import_mesh = pg.should_import_mesh
-        options.should_import_extra_uvs = pg.should_import_extra_uvs
-        options.should_import_vertex_colors = pg.should_import_vertex_colors
-        options.should_import_vertex_normals = pg.should_import_vertex_normals
-        options.vertex_color_space = pg.vertex_color_space
-        options.should_import_skeleton = pg.should_import_skeleton
-        options.should_import_shape_keys = pg.should_import_shape_keys
-        options.bone_length = pg.bone_length
-
-        result = import_psk(psk, context, options)
-
-        if len(result.warnings):
-            message = f'PSK imported with {len(result.warnings)} warning(s)\n'
-            message += '\n'.join(result.warnings)
-            self.report({'WARNING'}, message)
-        else:
-            self.report({'INFO'}, f'PSK imported')
-
-        return {'FINISHED'}
-
-    def draw(self, context):
-        pg = getattr(context.scene, 'psk_import')
-        layout = self.layout
-        layout.prop(pg, 'should_import_mesh')
-        row = layout.column()
-        row.use_property_split = True
-        row.use_property_decorate = False
-        if pg.should_import_mesh:
-            row.prop(pg, 'should_import_vertex_normals')
-            row.prop(pg, 'should_import_extra_uvs')
-            row.prop(pg, 'should_import_vertex_colors')
-            if pg.should_import_vertex_colors:
-                row.prop(pg, 'vertex_color_space')
-        layout.prop(pg, 'should_import_skeleton')
-        row = layout.column()
-        row.use_property_split = True
-        row.use_property_decorate = False
-        if pg.should_import_skeleton:
-            row.prop(pg, 'bone_length')
-        layout.prop(pg, 'should_import_shape_keys')
-
-
-classes = (
-    PskImportOperator,
-    PskImportPropertyGroup,
-)

io_scene_psk_psa/psk/properties.py

@@ -0,0 +1,48 @@
+from bpy.props import EnumProperty
+from bpy.types import PropertyGroup
+
+mesh_triangle_types_items = (
+    ('NORMAL', 'Normal', 'Normal one-sided', 0),
+    ('NORMAL_TWO_SIDED', 'Normal Two-Sided', 'Normal but two-sided', 1),
+    ('TRANSLUCENT', 'Translucent', 'Translucent two-sided', 2),
+    ('MASKED', 'Masked', 'Masked two-sided', 3),
+    ('MODULATE', 'Modulate', 'Modulation blended two-sided', 4),
+    ('PLACEHOLDER', 'Placeholder', 'Placeholder triangle for positioning weapon. Invisible', 8),
+)
+
+mesh_triangle_bit_flags_items = (
+    ('UNLIT', 'Unlit', 'Full brightness, no lighting', 16),
+    ('FLAT', 'Flat', 'Flat surface, don\'t do bMeshCurvy thing', 32),
+    ('ENVIRONMENT', 'Environment', 'Environment mapped', 64),
+    ('NO_SMOOTH', 'No Smooth', 'No bilinear filtering on this poly\'s texture', 128),
+)
+
+class PSX_PG_material(PropertyGroup):
+    mesh_triangle_type: EnumProperty(items=mesh_triangle_types_items, name='Triangle Type')
+    mesh_triangle_bit_flags: EnumProperty(items=mesh_triangle_bit_flags_items, name='Triangle Bit Flags',
+                                          options={'ENUM_FLAG'})
+
+mesh_triangle_types_items_dict = {item[0]: item[3] for item in mesh_triangle_types_items}
+mesh_triangle_bit_flags_items_dict = {item[0]: item[3] for item in mesh_triangle_bit_flags_items}
+
+
+def triangle_type_and_bit_flags_to_poly_flags(mesh_triangle_type: str, mesh_triangle_bit_flags: set[str]) -> int:
+    poly_flags = 0
+    poly_flags |= mesh_triangle_types_items_dict.get(mesh_triangle_type, 0)
+    for flag in mesh_triangle_bit_flags:
+        poly_flags |= mesh_triangle_bit_flags_items_dict.get(flag, 0)
+    return poly_flags
+
+
+def poly_flags_to_triangle_type_and_bit_flags(poly_flags: int) -> (str, set[str]):
+    try:
+        triangle_type = next(item[0] for item in mesh_triangle_types_items if item[3] == (poly_flags & 15))
+    except StopIteration:
+        triangle_type = 'NORMAL'
+    triangle_bit_flags = {item[0] for item in mesh_triangle_bit_flags_items if item[3] & poly_flags}
+    return triangle_type, triangle_bit_flags
+
+
+classes = (
+    PSX_PG_material,
+)

io_scene_psk_psa/psk/reader.py

@@ -1,5 +1,8 @@
 import ctypes
 import os
+import re
+import warnings
+from pathlib import Path
 
 from .data import *
 
@@ -13,45 +16,80 @@ def _read_types(fp, data_class, section: Section, data):
         offset += section.data_size
 
 
+def _read_material_references(path: str) -> List[str]:
+    property_file_path = Path(path).with_suffix('.props.txt')
+    if not property_file_path.is_file():
+        # Property file does not exist.
+        return []
+    # Do a crude regex match to find the Material list entries.
+    contents = property_file_path.read_text()
+    pattern = r'Material\s*=\s*([^\s^,]+)'
+    return re.findall(pattern, contents)
+
+
 def read_psk(path: str) -> Psk:
+
     psk = Psk()
+
+    # Read the PSK file sections.
     with open(path, 'rb') as fp:
         while fp.read(1):
             fp.seek(-1, 1)
             section = Section.from_buffer_copy(fp.read(ctypes.sizeof(Section)))
-            if section.name == b'ACTRHEAD':
+            match section.name:
-                pass
+                case b'ACTRHEAD':
-            elif section.name == b'PNTS0000':
+                    pass
-                _read_types(fp, Vector3, section, psk.points)
+                case b'PNTS0000':
-            elif section.name == b'VTXW0000':
+                    _read_types(fp, Vector3, section, psk.points)
-                if section.data_size == ctypes.sizeof(Psk.Wedge16):
+                case b'VTXW0000':
-                    _read_types(fp, Psk.Wedge16, section, psk.wedges)
+                    if section.data_size == ctypes.sizeof(Psk.Wedge16):
-                elif section.data_size == ctypes.sizeof(Psk.Wedge32):
+                        _read_types(fp, Psk.Wedge16, section, psk.wedges)
-                    _read_types(fp, Psk.Wedge32, section, psk.wedges)
+                    elif section.data_size == ctypes.sizeof(Psk.Wedge32):
-                else:
+                        _read_types(fp, Psk.Wedge32, section, psk.wedges)
-                    raise RuntimeError('Unrecognized wedge format')
+                    else:
-            elif section.name == b'FACE0000':
+                        raise RuntimeError('Unrecognized wedge format')
-                _read_types(fp, Psk.Face, section, psk.faces)
+                case b'FACE0000':
-            elif section.name == b'MATT0000':
+                    _read_types(fp, Psk.Face, section, psk.faces)
-                _read_types(fp, Psk.Material, section, psk.materials)
+                case b'MATT0000':
-            elif section.name == b'REFSKELT':
+                    _read_types(fp, Psk.Material, section, psk.materials)
-                _read_types(fp, Psk.Bone, section, psk.bones)
+                case b'REFSKELT':
-            elif section.name == b'RAWWEIGHTS':
+                    _read_types(fp, Psk.Bone, section, psk.bones)
-                _read_types(fp, Psk.Weight, section, psk.weights)
+                case b'RAWWEIGHTS':
-            elif section.name == b'FACE3200':
+                    _read_types(fp, Psk.Weight, section, psk.weights)
-                _read_types(fp, Psk.Face32, section, psk.faces)
+                case b'FACE3200':
-            elif section.name == b'VERTEXCOLOR':
+                    _read_types(fp, Psk.Face32, section, psk.faces)
-                _read_types(fp, Color, section, psk.vertex_colors)
+                case b'VERTEXCOLOR':
-            elif section.name.startswith(b'EXTRAUVS'):
+                    _read_types(fp, Color, section, psk.vertex_colors)
-                _read_types(fp, Vector2, section, psk.extra_uvs)
+                case b'VTXNORMS':
-            elif section.name == b'VTXNORMS':
+                    _read_types(fp, Vector3, section, psk.vertex_normals)
-                _read_types(fp, Vector3, section, psk.vertex_normals)
+                case b'MRPHINFO':
-            elif section.name == b'MRPHINFO':
+                    _read_types(fp, Psk.MorphInfo, section, psk.morph_infos)
-                _read_types(fp, Psk.MorphInfo, section, psk.morph_infos)
+                case b'MRPHDATA':
-            elif section.name == b'MRPHDATA':
+                    _read_types(fp, Psk.MorphData, section, psk.morph_data)
-                _read_types(fp, Psk.MorphData, section, psk.morph_data)
+                case _:
-            else:
+                    if section.name.startswith(b'EXTRAUVS'):
-                # Section is not handled, skip it.
+                        _read_types(fp, Vector2, section, psk.extra_uvs)
-                fp.seek(section.data_size * section.data_count, os.SEEK_CUR)
+                    else:
-                print(f'Unrecognized section "{section.name} at position {fp.tell():15}"')
+                        # Section is not handled, skip it.
+                        fp.seek(section.data_size * section.data_count, os.SEEK_CUR)
+                        warnings.warn(f'Unrecognized section "{section.name} at position {fp.tell():15}"')
+
+    '''
+    UEViewer exports a sidecar file (*.props.txt) with fully-qualified reference paths for each material
+    (e.g., Texture'Package.Group.Object').
+    '''
+    psk.material_references = _read_material_references(path)
+
+    '''
+    Tools like UEViewer and CUE4Parse write the point index as a 32-bit integer, exploiting the fact that due to struct
+    alignment, there were 16-bits of padding following the original 16-bit point index in the wedge struct.
+    However, this breaks compatibility with PSK files that were created with older tools that treated the
+    point index as a 16-bit integer and might have junk data written to the padding bits.
+    To work around this, we check if each point is still addressable using a 16-bit index, and if it is, assume the
+    point index is a 16-bit integer and truncate the high bits.
+    '''
+    if len(psk.points) <= 65536:
+        for wedge in psk.wedges:
+            wedge.point_index &= 0xFFFF
+
     return psk

io_scene_psk_psa/psk/ui.py

@@ -0,0 +1,28 @@
+from bpy.types import Panel
+
+
+class PSK_PT_material(Panel):
+    bl_label = 'PSK Material'
+    bl_idname = 'PSK_PT_material'
+    bl_space_type = 'PROPERTIES'
+    bl_region_type = 'WINDOW'
+    bl_context = 'material'
+    bl_options = {'DEFAULT_CLOSED'}
+
+    @classmethod
+    def poll(cls, context):
+        return context.material is not None
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False
+        material = context.material
+        layout.prop(material.psk, 'mesh_triangle_type')
+        col = layout.column()
+        col.prop(material.psk, 'mesh_triangle_bit_flags', expand=True, text='Flags')
+
+
+classes = (
+    PSK_PT_material,
+)

io_scene_psk_psa/psk/writer.py

@@ -0,0 +1,58 @@
+import os
+from ctypes import Structure, sizeof
+from typing import Type
+
+from .data import Psk
+from ..shared.data import Section, Vector3
+
+MAX_WEDGE_COUNT = 65536
+MAX_POINT_COUNT = 4294967296
+MAX_BONE_COUNT = 2147483647
+MAX_MATERIAL_COUNT = 256
+
+
+def _write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
+    section = Section()
+    section.name = name
+    if data_type is not None and data is not None:
+        section.data_size = sizeof(data_type)
+        section.data_count = len(data)
+    fp.write(section)
+    if data is not None:
+        for datum in data:
+            fp.write(datum)
+
+
+def write_psk(psk: Psk, path: str):
+    if len(psk.wedges) > MAX_WEDGE_COUNT:
+        raise RuntimeError(f'Number of wedges ({len(psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
+    if len(psk.points) > MAX_POINT_COUNT:
+        raise RuntimeError(f'Numbers of vertices ({len(psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
+    if len(psk.materials) > MAX_MATERIAL_COUNT:
+        raise RuntimeError(f'Number of materials ({len(psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
+    if len(psk.bones) > MAX_BONE_COUNT:
+        raise RuntimeError(f'Number of bones ({len(psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
+    elif len(psk.bones) == 0:
+        raise RuntimeError(f'At least one bone must be marked for export')
+
+    # Make the directory for the file if it doesn't exist.
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
+    with open(path, 'wb') as fp:
+        _write_section(fp, b'ACTRHEAD')
+        _write_section(fp, b'PNTS0000', Vector3, psk.points)
+
+        wedges = []
+        for index, w in enumerate(psk.wedges):
+            wedge = Psk.Wedge16()
+            wedge.material_index = w.material_index
+            wedge.u = w.u
+            wedge.v = w.v
+            wedge.point_index = w.point_index
+            wedges.append(wedge)
+
+        _write_section(fp, b'VTXW0000', Psk.Wedge16, wedges)
+        _write_section(fp, b'FACE0000', Psk.Face, psk.faces)
+        _write_section(fp, b'MATT0000', Psk.Material, psk.materials)
+        _write_section(fp, b'REFSKELT', Psk.Bone, psk.bones)
+        _write_section(fp, b'RAWWEIGHTS', Psk.Weight, psk.weights)

io_scene_psk_psa/shared/data.py

@@ -93,3 +93,9 @@ class Section(Structure):
     def __init__(self, *args, **kw):
         super().__init__(*args, **kw)
         self.type_flags = 1999801
+
+
+bone_filter_mode_items = (
+    ('ALL', 'All', 'All bones will be exported'),
+    ('BONE_COLLECTIONS', 'Bone Collections', 'Only bones belonging to the selected bone collections and their ancestors will be exported')
+)

io_scene_psk_psa/shared/dfs.py

@@ -0,0 +1,155 @@
+'''
+Depth-first object iterator functions for Blender collections and view layers.
+
+These functions are used to iterate over objects in a collection or view layer in a depth-first manner, including
+instances. This is useful for exporters that need to traverse the object hierarchy in a predictable order.
+'''
+
+from typing import Optional, Set, Iterable, List
+
+from bpy.types import Collection, Object, ViewLayer, LayerCollection
+from mathutils import Matrix
+
+
+class DfsObject:
+    '''
+    Represents an object in a depth-first search.
+    '''
+    def __init__(self, obj: Object, instance_objects: List[Object], matrix_world: Matrix):
+        self.obj = obj
+        self.instance_objects = instance_objects
+        self.matrix_world = matrix_world
+
+    @property
+    def is_visible(self) -> bool:
+        '''
+        Check if the object is visible.
+        @return: True if the object is visible, False otherwise.
+        '''
+        if self.instance_objects:
+            return self.instance_objects[-1].visible_get()
+        return self.obj.visible_get()
+
+    @property
+    def is_selected(self) -> bool:
+        '''
+        Check if the object is selected.
+        @return: True if the object is selected, False otherwise.
+        '''
+        if self.instance_objects:
+            return self.instance_objects[-1].select_get()
+        return self.obj.select_get()
+
+
+
+def _dfs_object_children(obj: Object, collection: Collection) -> Iterable[Object]:
+    '''
+    Construct a list of objects in hierarchy order from `collection.objects`, only keeping those that are in the
+    collection.
+    @param obj: The object to start the search from.
+    @param collection:  The collection to search in.
+    @return: An iterable of objects in hierarchy order.
+    '''
+    yield obj
+    for child in obj.children:
+        if child.name in collection.objects:
+            yield from _dfs_object_children(child, collection)
+
+
+def dfs_objects_in_collection(collection: Collection) -> Iterable[Object]:
+    '''
+    Returns a depth-first iterator over all objects in a collection, only keeping those that are directly in the
+    collection.
+    @param collection: The collection to search in.
+    @return: An iterable of objects in hierarchy order.
+    '''
+    objects_hierarchy = []
+    for obj in collection.objects:
+        if obj.parent is None or obj.parent not in set(collection.objects):
+            objects_hierarchy.append(obj)
+    for obj in objects_hierarchy:
+        yield from _dfs_object_children(obj, collection)
+
+
+def dfs_collection_objects(collection: Collection, visible_only: bool = False) -> Iterable[DfsObject]:
+    '''
+    Depth-first search of objects in a collection, including recursing into instances.
+    @param collection: The collection to search in.
+    @return: An iterable of tuples containing the object, the instance objects, and the world matrix.
+    '''
+    yield from _dfs_collection_objects_recursive(collection)
+
+
+def _dfs_collection_objects_recursive(
+        collection: Collection,
+        instance_objects: Optional[List[Object]] = None,
+        matrix_world: Matrix = Matrix.Identity(4),
+        visited: Optional[Set[Object]]=None
+) -> Iterable[DfsObject]:
+    '''
+    Depth-first search of objects in a collection, including recursing into instances.
+    This is a recursive function.
+    @param collection: The collection to search in.
+    @param instance_objects: The running hierarchy of instance objects.
+    @param matrix_world: The world matrix of the current object.
+    @param visited: A set of visited object-instance pairs.
+    @return: An iterable of tuples containing the object, the instance objects, and the world matrix.
+    '''
+
+    # We want to also yield the top-level instance object so that callers can inspect the selection status etc.
+    if visited is None:
+        visited = set()
+
+    if instance_objects is None:
+        instance_objects = list()
+
+    # First, yield all objects in child collections.
+    for child in collection.children:
+        yield from _dfs_collection_objects_recursive(child, instance_objects, matrix_world.copy(), visited)
+
+    # Then, evaluate all objects in this collection.
+    for obj in dfs_objects_in_collection(collection):
+        visited_pair = (obj, instance_objects[-1] if instance_objects else None)
+        if visited_pair in visited:
+            continue
+        # If this an instance, we need to recurse into it.
+        if obj.instance_collection is not None:
+            # Calculate the instance transform.
+            instance_offset_matrix = Matrix.Translation(-obj.instance_collection.instance_offset)
+            # Recurse into the instance collection.
+            yield from _dfs_collection_objects_recursive(obj.instance_collection,
+                                                         instance_objects + [obj],
+                                                         matrix_world @ (obj.matrix_world @ instance_offset_matrix),
+                                                         visited)
+        else:
+            # Object is not an instance, yield it.
+            yield DfsObject(obj, instance_objects, matrix_world @ obj.matrix_world)
+            visited.add(visited_pair)
+
+
+def dfs_view_layer_objects(view_layer: ViewLayer) -> Iterable[DfsObject]:
+    '''
+    Depth-first iterator over all objects in a view layer, including recursing into instances.
+    @param view_layer: The view layer to inspect.
+    @return: An iterable of tuples containing the object, the instance objects, and the world matrix.
+    '''
+    visited = set()
+    def layer_collection_objects_recursive(layer_collection: LayerCollection):
+        for child in layer_collection.children:
+            yield from layer_collection_objects_recursive(child)
+        # Iterate only the top-level objects in this collection first.
+        yield from _dfs_collection_objects_recursive(layer_collection.collection, visited=visited)
+
+    yield from layer_collection_objects_recursive(view_layer.layer_collection)
+
+
+def _is_dfs_object_visible(obj: Object, instance_objects: List[Object]) -> bool:
+    '''
+    Check if a DFS object is visible.
+    @param obj: The object.
+    @param instance_objects: The instance objects.
+    @return: True if the object is visible, False otherwise.
+    '''
+    if instance_objects:
+        return instance_objects[-1].visible_get()
+    return obj.visible_get()

io_scene_psk_psa/shared/helpers.py

@@ -1,41 +1,21 @@
-import datetime
+from typing import List, Iterable, cast
-import re
-from collections import Counter
-from typing import List, Iterable
 
-import bpy.types
+import bpy
-from bpy.types import NlaStrip, Object
+from bpy.props import CollectionProperty
+from bpy.types import AnimData, Object
+from bpy.types import Armature
 
 
-class Timer:
+def rgb_to_srgb(c: float):
-    def __enter__(self):
-        self.start = datetime.datetime.now()
-        self.interval = None
-        return self
-
-    def __exit__(self, *args):
-        self.end = datetime.datetime.now()
-        self.interval = self.end - self.start
-
-    @property
-    def duration(self):
-        if self.interval is not None:
-            return self.interval
-        else:
-            return datetime.datetime.now() - self.start
-
-
-def rgb_to_srgb(c):
     if c > 0.0031308:
         return 1.055 * (pow(c, (1.0 / 2.4))) - 0.055
     else:
         return 12.92 * c
 
 
-def get_nla_strips_in_timeframe(animation_data, frame_min, frame_max) -> List[NlaStrip]:
+def get_nla_strips_in_frame_range(animation_data: AnimData, frame_min: float, frame_max: float):
     if animation_data is None:
-        return []
+        return
-    strips = []
     for nla_track in animation_data.nla_tracks:
         if nla_track.mute:
             continue
@@ -43,89 +23,85 @@ def get_nla_strips_in_timeframe(animation_data, frame_min, frame_max) -> List[Nl
             if (strip.frame_start < frame_min and strip.frame_end > frame_max) or \
                     (frame_min <= strip.frame_start < frame_max) or \
                     (frame_min < strip.frame_end <= frame_max):
-                strips.append(strip)
+                yield strip
-    return strips
 
 
-def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.props.CollectionProperty) -> None:
+def populate_bone_collection_list(armature_object: Object, bone_collection_list: CollectionProperty) -> None:
     """
-    Updates the bone group collection.
+    Updates the bone collections collection.
 
-    Bone group selections are preserved between updates unless none of the groups were previously selected;
+    Bone collection selections are preserved between updates unless none of the groups were previously selected;
-    otherwise, all groups are selected by default.
+    otherwise, all collections are selected by default.
     """
-    has_selected_groups = any([g.is_selected for g in bone_group_list])
+    has_selected_collections = any([g.is_selected for g in bone_collection_list])
-    unassigned_group_is_selected, selected_assigned_group_names = True, []
+    unassigned_collection_is_selected, selected_assigned_collection_names = True, []
 
-    if has_selected_groups:
+    if armature_object is None:
+        return
+
+    if has_selected_collections:
         # Preserve group selections before clearing the list.
         # We handle selections for the unassigned group separately to cover the edge case
         # where there might be an actual group with 'Unassigned' as its name.
-        unassigned_group_idx, unassigned_group_is_selected = next(iter([
+        unassigned_collection_idx, unassigned_collection_is_selected = next(iter([
-            (i, g.is_selected) for i, g in enumerate(bone_group_list) if g.index == -1]), (-1, False))
+            (i, g.is_selected) for i, g in enumerate(bone_collection_list) if g.index == -1]), (-1, False))
 
-        selected_assigned_group_names = [
+        selected_assigned_collection_names = [
-            g.name for i, g in enumerate(bone_group_list) if i != unassigned_group_idx and g.is_selected]
+            g.name for i, g in enumerate(bone_collection_list) if i != unassigned_collection_idx and g.is_selected]
 
-    bone_group_list.clear()
+    bone_collection_list.clear()
 
-    if armature_object and armature_object.pose:
+    armature = cast(Armature, armature_object.data)
-        bone_group_counts = Counter(map(lambda x: x.bone_group, armature_object.pose.bones))
 
-        item = bone_group_list.add()
+    if armature is None:
-        item.name = 'Unassigned'
+        return
-        item.index = -1
-        item.count = 0 if None not in bone_group_counts else bone_group_counts[None]
-        item.is_selected = unassigned_group_is_selected
 
-        for bone_group_index, bone_group in enumerate(armature_object.pose.bone_groups):
+    item = bone_collection_list.add()
-            item = bone_group_list.add()
+    item.name = 'Unassigned'
-            item.name = bone_group.name
+    item.index = -1
-            item.index = bone_group_index
+    # Count the number of bones without an assigned bone collection
-            item.count = 0 if bone_group not in bone_group_counts else bone_group_counts[bone_group]
+    item.count = sum(map(lambda bone: 1 if len(bone.collections) == 0 else 0, armature.bones))
-            item.is_selected = bone_group.name in selected_assigned_group_names if has_selected_groups else True
+    item.is_selected = unassigned_collection_is_selected
+
+    for bone_collection_index, bone_collection in enumerate(armature.collections):
+        item = bone_collection_list.add()
+        item.name = bone_collection.name
+        item.index = bone_collection_index
+        item.count = len(bone_collection.bones)
+        item.is_selected = bone_collection.name in selected_assigned_collection_names if has_selected_collections else True
 
 
-def get_psa_sequence_name(action, should_use_original_sequence_name):
+def get_export_bone_names(armature_object: Object, bone_filter_mode: str, bone_collection_indices: Iterable[int]) -> List[str]:
-    if should_use_original_sequence_name and 'psa_sequence_name' in action:
-        return action['psa_sequence_name']
-    else:
-        return action.name
-
-
-def check_bone_names(bone_names: Iterable[str]):
-    pattern = re.compile(r'^[a-zA-Z\d_\- ]+$')
-    invalid_bone_names = [x for x in bone_names if pattern.match(x) is None]
-    if len(invalid_bone_names) > 0:
-        raise RuntimeError(f'The following bone names are invalid: {invalid_bone_names}.\n'
-                           f'Bone names must only contain letters, numbers, spaces, hyphens and underscores.')
-
-
-def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices: List[int]) -> List[str]:
     """
-    Returns a sorted list of bone indices that should be exported for the given bone filter mode and bone groups.
+    Returns a sorted list of bone indices that should be exported for the given bone filter mode and bone collections.
 
-    Note that the ancestors of bones within the bone groups will also be present in the returned list.
+    Note that the ancestors of bones within the bone collections will also be present in the returned list.
 
     :param armature_object: Blender object with type 'ARMATURE'
-    :param bone_filter_mode: One of ['ALL', 'BONE_GROUPS']
+    :param bone_filter_mode: One of ['ALL', 'BONE_COLLECTIONS']
-    :param bone_group_indices: List of bone group indices to be exported.
+    :param bone_collection_indices: A list of bone collection indices to export.
     :return: A sorted list of bone indices that should be exported.
     """
     if armature_object is None or armature_object.type != 'ARMATURE':
         raise ValueError('An armature object must be supplied')
 
-    bones = armature_object.data.bones
+    armature_data = cast(Armature, armature_object.data)
-    pose_bones = armature_object.pose.bones
+    bones = armature_data.bones
     bone_names = [x.name for x in bones]
 
     # Get a list of the bone indices that we are explicitly including.
     bone_index_stack = []
-    is_exporting_none_bone_groups = -1 in bone_group_indices
+    is_exporting_unassigned_bone_collections = -1 in bone_collection_indices
-    for bone_index, pose_bone in enumerate(pose_bones):
+    bone_collections = list(armature_data.collections)
+
+    for bone_index, bone in enumerate(bones):
+        # Check if this bone is in any of the collections in the bone collection indices list.
+        this_bone_collection_indices = set(bone_collections.index(x) for x in bone.collections)
+        is_in_exported_bone_collections = len(set(bone_collection_indices).intersection(this_bone_collection_indices)) > 0
+
         if bone_filter_mode == 'ALL' or \
-                (pose_bone.bone_group is None and is_exporting_none_bone_groups) or \
+                (len(bone.collections) == 0 and is_exporting_unassigned_bone_collections) or \
-                (pose_bone.bone_group is not None and pose_bone.bone_group_index in bone_group_indices):
+                is_in_exported_bone_collections:
             bone_index_stack.append((bone_index, None))
 
     # For each bone that is explicitly being added, recursively walk up the hierarchy and ensure that all of
@@ -146,7 +122,7 @@ def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices:
 
     # Split out the bone indices and the instigator bone names into separate lists.
     # We use the bone names for the return values because the bone name is a more universal way of referencing them.
-    # For example, users of this function may modify bone lists, which would invalidate the indices and require a
+    # For example, users of this function may modify bone lists, which would invalidate the indices and require an
     # index mapping scheme to resolve it. Using strings is more comfy and results in less code downstream.
     instigator_bone_names = [bones[x[1]].name if x[1] is not None else None for x in bone_indices]
     bone_names = [bones[x[0]].name for x in bone_indices]
@@ -174,3 +150,7 @@ def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices:
                            f'Additional debugging information has been written to the console.')
 
     return bone_names
+
+
+def is_bdk_addon_loaded() -> bool:
+    return 'bdk' in dir(bpy.ops)

io_scene_psk_psa/shared/types.py

@@ -0,0 +1,55 @@
+from bpy.props import StringProperty, IntProperty, BoolProperty, FloatProperty
+from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType, Panel
+
+
+class PSX_UL_bone_collection_list(UIList):
+
+    def draw_item(self, context: Context, layout: UILayout, data: AnyType, item: AnyType, icon: int,
+                  active_data: AnyType, active_property: str, index: int = 0, flt_flag: int = 0):
+        row = layout.row()
+        row.prop(item, 'is_selected', text=getattr(item, 'name'))
+        row.label(text=str(getattr(item, 'count')), icon='BONE_DATA')
+
+
+class PSX_PG_bone_collection_list_item(PropertyGroup):
+    name: StringProperty()
+    index: IntProperty()
+    count: IntProperty()
+    is_selected: BoolProperty(default=False)
+
+
+class PSX_PG_action_export(PropertyGroup):
+    compression_ratio: FloatProperty(name='Compression Ratio', default=1.0, min=0.0, max=1.0, subtype='FACTOR', description='The key sampling ratio of the exported sequence.\n\nA compression ratio of 1.0 will export all frames, while a compression ratio of 0.5 will export half of the frames')
+    key_quota: IntProperty(name='Key Quota', default=0, min=1, description='The minimum number of frames to be exported')
+    fps: FloatProperty(name='FPS', default=30.0, min=0.0, description='The frame rate of the exported sequence')
+
+
+class PSX_PT_action(Panel):
+    bl_idname = 'PSX_PT_action'
+    bl_label = 'PSA Export'
+    bl_space_type = 'DOPESHEET_EDITOR'
+    bl_region_type = 'UI'
+    bl_context = 'action'
+    bl_category = 'Action'
+
+    @classmethod
+    def poll(cls, context: 'Context'):
+        return context.active_object and context.active_object.type == 'ARMATURE' and context.active_action is not None
+
+    def draw(self, context: 'Context'):
+        action = context.active_action
+        layout = self.layout
+        flow = layout.grid_flow(columns=1)
+        flow.use_property_split = True
+        flow.use_property_decorate = False
+        flow.prop(action.psa_export, 'compression_ratio')
+        flow.prop(action.psa_export, 'key_quota')
+        flow.prop(action.psa_export, 'fps')
+
+
+classes = (
+    PSX_PG_action_export,
+    PSX_PG_bone_collection_list_item,
+    PSX_UL_bone_collection_list,
+    PSX_PT_action,
+)

io_scene_psk_psa/shared/ui.py

@@ -0,0 +1,18 @@
+from bpy.types import UILayout
+
+from .data import bone_filter_mode_items
+
+
+def is_bone_filter_mode_item_available(pg, identifier):
+    if identifier == 'BONE_COLLECTIONS' and len(pg.bone_collection_list) == 0:
+        return False
+    return True
+
+
+def draw_bone_filter_mode(layout: UILayout, pg):
+    row = layout.row(align=True)
+    for item_identifier, _, _ in bone_filter_mode_items:
+        identifier = item_identifier
+        item_layout = row.row(align=True)
+        item_layout.prop_enum(pg, 'bone_filter_mode', item_identifier)
+        item_layout.enabled = is_bone_filter_mode_item_available(pg, identifier)

io_scene_psk_psa/types.py

@@ -1,24 +0,0 @@
-from bpy.props import StringProperty, IntProperty, BoolProperty
-from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType
-
-
-class PSX_UL_BoneGroupList(UIList):
-
-    def draw_item(self, context: Context, layout: UILayout, data: AnyType, item: AnyType, icon: int,
-                  active_data: AnyType, active_property: str, index: int = 0, flt_flag: int = 0):
-        row = layout.row()
-        row.prop(item, 'is_selected', text=getattr(item, 'name'))
-        row.label(text=str(getattr(item, 'count')), icon='BONE_DATA')
-
-
-class BoneGroupListItem(PropertyGroup):
-    name: StringProperty()
-    index: IntProperty()
-    count: IntProperty()
-    is_selected: BoolProperty(default=False)
-
-
-classes = (
-    BoneGroupListItem,
-    PSX_UL_BoneGroupList,
-)