knuxfan24 / knuxlib Goto Github PK

• Read the bounding volume hierarchy for the meshes
• Figure out the unknown values
• Implement saving
• Write an exporter
• Write an importer

• Saving support
• Figure out the unknown chunk of data
• Accurate OBJ exporting
• OBJ Importing
• Figure out what these splines are actually used for? Seems to be something to do with entities? (or at least the camera in some stages?)

• Figure out what SPEC means in the context of a Nu2 Scene.
• Figure out what ALIB means in the context of a Nu2 Scene.
• Figure out what IABL means in the context of a Nu2 Scene.
• Reverse engineer the ALIB chunk.
• Reverse engineer the Xbox Texture Set.
• Reverse engineer the Xbox Geometry Set.
• Reverse engineer the PlayStation 2 Texture Set.
• Reverse engineer the PlayStation 2 Material Set.
• Reverse engineer the PlayStation 2 Geometry Set.
• Reverse engineer the PlayStation 2 SPEC Set.
• Reverse engineer the IABL chunk exclusive to the PlayStation 2 version.
• Implement a way to decompress and recompress the PlayStation 2 version's Rob Northen Compression scheme (https://segaretro.org/Rob_Northen_compression).
• Implement a way to save this format.
• Implement a way to export this format's model and texture data.
• Implement a way to import a model to this format.

• Finish reading.
• Implement saving.
• Add an importer.
• Understand what different values control.
• Export by collision properties (once those are understood).

• Figure out unknown values.
• Understand how the values in the Subspace chunk piece the models together.
• Check PlayStation 2 and Xbox versions of the format to see if any values that are currently being skipped without a value test are different.
• Clean up and document the code.
• Implement a way to save this format.
• Implement a way to export this format's model data (is technically already possible, but exports to OBJ without most of the information needed from the Subspace chunk).
• Implement a way to import a model to this format.

• Reverse Engineer the rest of the data found in the Seven Sirens version of the format (currently just reading from a specific point to the end of the file and storing every value as a ulong).
• Better export solution? Writing OBJs might not be the best option?
• Import solution.
• See if this code can be adapted to Half-Genie Hero's clb files too.

• Sort out the unknowns.
• Implement a way to save this format.
• Implement a way to properly export this format.
• Implement a way to import a spline (from something like an OBJ or FBX) to this format.
• Clean up and document the code.

• Implement a way to save this format.

• Sort out the unknown values.

• Figure out the unknown floating point value (which might be a CRC32 hash?)
• Fix saving once the above is figured out
• Test if these archives require a strict order to their files like the Sonic World Adventure Wii Engine ONE Archives seem to (X7's stage01_01_cmn.arc file didn't seem to have a problem with it, but others might, as that's all I tested)
• Consider supporting other versions of the .arc format (V9 reading added in 83ccd53 and saving added in 656bb35 )
• KnuxTools directory importing

• Read the unknown data in the environment chunks
• Find out how the vertex data in the environment chunks are pieced together to form faces
• Find out why one specific environment file's chunks are completely different to every other one
• Fix the palettes of textures being incorrect
• Reverse engineer the other texture type
• Do any reverse engineering at all of the skinned model chunks
• Saving support
• Import support
• Export support

• Figure out the unknown value that almost feels like a hash of some sort? Changing the value even slightly makes the game reject it.
• Figure out the second unknown value, haven't messed with it at all yet.

• Clean up and document the code.
• Figure out proper data types.
• Figure out what the data actually does.
• Properly name the different pieces of data.
• Check for differences (besides 32-bit offsets) in the Lost World version of the format.
• Check for differences in the Frontiers version of the format.

The fact that so many files end up with a .json extension is causing this thing to become rather messy rather quickly.
Marathon.CLI keeps the original extension when serialising to JSON and uses it to determine the type, try and replicate that.

• Reverse engineer the unknown chunk of data in the Bone Name node.
• Reverse engineer the two unknown chunks of data in the Group node.
• Reverse engineer the two unknown chunks of data in the Object Data node.
• Figure out what the two unknown nodes actually are (Unknown 2 only appears in a single file).
• Implement a way to save this format.
• Implement a solution for exporting models from this format.
• Implement a solution for importing models to this format.
• Implement a way to decompress the texture data in this format.
• Implement a way to compress textures into the data format found in these mesh files.

• Sort out the unknowns.
• Implement a way to properly export this format.
• Implement a way to import a spline (from something like an OBJ or FBX) to this format.

• Format saving.
• File importing.

• Fix encoding errors (really just need to find the right encoder/decoder).
• Figure out what the deal is with the extra offsets (if things work fine with or without them, then this isn't critical)

• LITERALLY EVERYTHING

• Figure out object parameters.
• Check object parameters on the PlayStation 2 version.
• Get a HSON Importer working, can currently export but haven't tried importing a created HSON back in.

• Read and understand the sequence of bytes near the start that crash the game if I null them out.
• Understand what each file's unknown value is for, as nulling them also crashes the game. Write currently just shoves a UKNW placeholder value there.
• Not really required for my purposes, but it would be nice to get this working for other Engine Black games.

• Figure out object parameters.
• Implement a way to save this format.
• Get a HSON Importer working, can currently export but haven't tried importing a created HSON back in.

Currently, KnuxTools has to be compiled from source in order to be used, this should probably be taken care of by a GitHub Action to automatically build an artifact with each commit, but I haven't had any luck trying to understand that.

The extension and version parameters also currently have no standardised setups, I should pick a consistent value for each one (currently some have multiple for the same option which feels very messy) and list it with the file types.

• GOG Reading Support
• Saving Support
• Recompress files for the 3DS