Leaderboard

I have released an early version of the tool that can do just meshes with their material names/skeleton:

So I was wrong, Conker's Eyes don't rely on a shader to make them look correct, the eyes have 3 UV channels for the Pupil, Highlight, and the Eye Lids. I just recently implemented the Multi UV Channel support

Those BSTEX files are just containers for PS Vita GXT image files. Here's a file format https://rewiki.miraheze.org/wiki/GXT_Image If you remove manually 32 bytes from BSTEX file in hex editor and change file extension from BSTEX to GXT, you will be able to open them in Scarlet. Unfortunately PVRTII4BPP is not supported by Scarlet, so you will be able to convert only BC/DXT textures this way. While doing research on your samples, I discovered that ImageHeat had a bug while unswizzling 4bpp PS Vita textures. I fixed this bug in v0.26.3, so you can use this version (or newer) to properly view PVRTII4BPP textures:

N64 logo and Rareware logo work aswell, forgot to test them

I got meshes with multiple materials to properly import their materials, aswell as finally implementing vertex normals for example Neo Conker has two materials for his body mesh, the hands and jacket, originally it was only importing the jacket texture for the full mesh

Format: .avi Codec: MV30 Coding program: VirtualDub build 13719/release You can decode it using ffmpeg. Standard videos of the old format.

There might be a way to find the password using Cheat Engine. Install Cheat Engine, load the game and open the games process. Click on Memory View, go to Search, Find memory and search for this text - jPGbPK6KENwG9ey If found, the password should be very close to this, 44 char long - M2Q6Dj6a*7NxX|gYHe8UH8o9]3CWDjPGbPK6KENwG9ey

Okay I figured out all of the .mdl's thanks to Shak's original response. All of them can be previewed and exported using the Fable 2 Asset Browser now, which is what I was kind of aiming for. I can get the skeletons out, idk if they're necessarily correct or not, but they works so I can only assume it's fine. So I'm going to turn my attention to the .tex file compression and animations. Obviously looks better in blender but yeah. I'm sure everyone gets the point.

I looked at file HAT_1_10001. That one has 16 tiles. The palette is at 0x1a0 in RGBA32 format, and the 8-bit image data starts at 0x5a0 (PS2 swizzled). Each tile is 128 x 64, and the image is made up of 2 x 8 tiles as follows - an example of the individual tiles, only the first 8 in order:

As above, the first two values are dec size and comp size. It seems to use "BPE" compression in QuickBMS. Then I can get something like this, not sure if it's 100% exact:

Thank you both for all of your help! ( ◠‿◠ )

OK! Thanks for your help man!

It's a program for viewing/editing data from binary files. Some example hex editors are "Hex Workshop", "HxD", "010 Editor" etc. Sorry, but sharing raw game assets is against forum rules (rule 11) https://reshax.com/topic/5-site-rules/ You can't. It was not released yet. But you can build it from the source. There is instruction in readme file on github. Or just wait until new version release.

i found a bunch of information here

UPDATE: I finally managed to fix the holes!!! What was the solution? Clone the mesh-reading code and change it to make it read the meshes under the "00 C0 2D 30" headers, change the "elif change_pad" byte from 12 to 11 (0B instead of 0C), and change the triangle output of the cloned code from noesis.RPGEO_TRIANGLE_STRIP to noesis.RPGEO_TRIANGLE. So the models seem to use a mix of tristrip triangles for most of the mesh, and regular triangles for the holes, and now the end result looks great! I was also able to fully restore one of these models used for this demonstration in Blender!

I made a maxscript for this game a couple of years ago. If memory serves everything works. https://github.com/sleepyzay/Maxscript-Projects/tree/main/Fable 2

No, i dont use bt Tool posted:

Is there a specific file you're having trouble with inside that archive? These appear quite similar. e.g. 0000000000000000_unpack.seg is uncompressed 8-bpp indexed pixels 512x1024 starting at 1600h and a palette at 200h. (you'll have to tell me if the red and blue channels are reversed, since you've played the game)

I am updating the Noesis script from this post to handle more versions of the 3D model rsf format. Soon I will release an update to the script. Meanwhile, as a sample, I want to show some extracted models that we were not able to extract with the old script. On the top left corner we find the Orange Bowl stadium from NCAA 08. On the top right corner we see the hologram (a ficticious one) stadium from Madden 13. The low left corner shows the LA Memorial Coliseum and finally on the low right corner we find the Louisiana Tech stadium from NCAA 12. All these rsf files come from the PS3 versions of the games with data in big endian.The script can handle data in little endian too, for example rsf files coming from PS Vita games. I am almost 100% sure that the updated script will be able to handle rsf files from NCAA 08 to NCAA 14 and Madden 07 to Madden 17 with no issues. The updated script will probably handle rsf files from other EA games released between 2006 and 2016.

Hello guys, I need help to the correct read UV`s and Textures, from the Reckless Racing game. Earlier, durik256 helped me read the mesh format and some UV data from the *.sggr format, but to this day I haven’t been able to figure out the UV scaling and materials. Here’s the link to the discussion: https://reshax.com/topic/1067-reckless-racing-ios-vfs-files/ Below is the Noesis script for reading the mesh data. Script have two problems: - Sometimes the script reads the LOD versions of the mesh models. - It also doesn’t read the UV scale, and the mesh isn’t split by materials. I’m asking for your help in updating this script. from inc_noesis import * def registerNoesisTypes(): handle = noesis.register("Reckless Racing", ".sggr") noesis.setHandlerTypeCheck(handle, noepyCheckType) noesis.setHandlerLoadModel(handle, noepyLoadModel) return 1 def noepyCheckType(data): if data[:4] != b'\x4D\x3C\x2B\x1A': return 0 return 1 def noepyLoadModel(data, mdlList): bs = NoeBitStream(data) ctx = rapi.rpgCreateContext() ofs_res = data.find(b'#RES') if ofs_res != -1: bs.seek(ofs_res + 44) unk, vnum, zero = bs.read('3I') skip = 12 if unk == 4368 else 0 vbuf = b'' vbuf, uvbuf = b'', b''#bs.read(vnum*24) for x in range(vnum): bs.seek(2,1) vbuf += bs.read(2) bs.seek(2,1) vbuf += bs.read(2) bs.seek(2,1) vbuf += bs.read(2) bs.seek(5,1)#4 uvbuf += bs.read(2) bs.seek(2,1) uvbuf += bs.read(2) bs.seek(1,1)#2 bs.seek(skip,1)#12+ rapi.rpgBindPositionBuffer(vbuf, noesis.RPGEODATA_SHORT, 6) rapi.rpgBindUV1Buffer(uvbuf, noesis.RPGEODATA_USHORT, 4) u0, inum, u1 = bs.read('3I') ibuf = bs.read(inum * 2) rapi.rpgCommitTriangles(ibuf, noesis.RPGEODATA_USHORT, inum, noesis.RPGEO_TRIANGLE) try: mdlList.append(rapi.rpgConstructModel()) except: mdlList.append(NoeModel()) return 1

Hello, you really should put more effort in your request. People who could help don't have all the time in the world, to unpack a vfs, search for the sggr in question, which samples have the "lod problem", etc, etc. WHY not simply upload the samples in question plus a description what EXACTLY you've done so far to get uvs. Your post here is not very insightful, imho.

import struct import os import sys from PIL import Image # Constants for offsets FILE_COUNT_OFFSET = 0x28 FILENAME_TABLE_OFFSET = 0x2C DATA_INDEX_OFFSET = 0x178C # A SINGLE, CORRECT LOOKUP TABLE FOR IMAGE DIMENSIONS BASED ON FILE SIZE. # All files are grayscale (1 byte/pixel). SIZE_TO_DIMENSIONS = { 262144: (512, 512), 524288: (1024, 512), 1048576: (1024, 1024) # Add more entries here if new sizes appear } def extract_grayscale_images(file_path, output_dir): """ Extracts all image files from a given .dat archive, assuming they are raw grayscale pixel data. """ with open(file_path, 'rb') as f: # Read the total number of files in the archive f.seek(FILE_COUNT_OFFSET) file_count = struct.unpack('<I', f.read(4))[0] # Read the filename table f.seek(FILENAME_TABLE_OFFSET) filenames = [] for _ in range(file_count): try: name_len = struct.unpack('<I', f.read(4))[0] filenames.append(f.read(name_len).decode('ascii', errors='replace')) except (struct.error, IndexError): # Stop if the file ends unexpectedly break # Move to the data index table f.seek(DATA_INDEX_OFFSET) print(f"Starting extraction of {len(filenames)} files (all as grayscale)...\n") success_count, skipped_count = 0, 0 for i, filename in enumerate(filenames): try: # Read the offset and size for the current file entry_data = f.read(8) if len(entry_data) < 8: break # Reached end of index offset, size = struct.unpack('<II', entry_data) # Check if we know the dimensions for this file size if size not in SIZE_TO_DIMENSIONS: print(f"[{i+1}/{file_count}] {filename} -> UNKNOWN SIZE ({size} B). Skipping.") skipped_count += 1 continue width, height = SIZE_TO_DIMENSIONS[size] # Read the pixel data current_pos = f.tell() # Save current position in the index f.seek(offset) pixel_data = f.read(size) f.seek(current_pos) # Return to the index # Prepare the output path, preserving directory structure safe_name = filename.replace('.dds', '.png').replace('\\', os.path.sep).strip(os.path.sep) out_path = os.path.join(output_dir, safe_name) os.makedirs(os.path.dirname(out_path), exist_ok=True) # ALWAYS convert as 'L' (grayscale) img = Image.frombytes('L', (width, height), pixel_data) img.save(out_path, 'PNG') print(f"[{i+1}/{file_count}] {filename} -> {out_path} ({width}x{height}, Grayscale)") success_count += 1 except Exception as e: print(f"[{i+1}/{file_count}] {filename} -> CRITICAL ERROR: {e}") skipped_count += 1 print(f"\nFinished! Converted: {success_count}, Skipped: {skipped_count}.") if __name__ == "__main__": if len(sys.argv) < 2: print(f"Usage: python {os.path.basename(__file__)} <file.dat>") sys.exit(1) input_file = sys.argv[1] # Create a more standard output directory name output_dir = os.path.splitext(input_file)[0] + "_extracted_images" print(f"Input file: {input_file}") print(f"Output directory: {output_dir}\n") extract_grayscale_images(input_file, output_dir) This script unpack texture. The file names are given with the .dds extension, but these are not DDS files. There are two types of files: those with [e] in the name build correctly, and those without [e] are strange. That's all I can help with. Script usage: python <scriptname>.py <path to file> e.g., python unpack.py sky.t000 - if it's in the same directory as the script.

It seems like at 0x24 is vert count(4F8=1272), then at 0x40 is a pointer to vertices(0x70780). After that a line of zeros and then other block of vertices, maybe other facel?(I don't know why are 2 faces). But vert count is taking that line of zeros. I tried to ignore that line and then including that line but is the same result. The only differenece is that large triangle that goes to the floor. So it both cases is a mess, lol. Oh, probably after pointer to vertices, are pointers to Normals(0x44), Uvs(0x48) and vertex colors(0x4C). I don't understand, this is so werird...

Oh man, I'm interested in this. I hack the N64 AKI Wrestling games, and wondered if there was anything for Def Jam Vendetta. Where can I find this Byte Map tool?

Hello! I was working on a Python script that replace Sprites data with another for Unity games but Unity has another trick in its sleeve. For those who use AssetStudio, you will extract sprites like this (from Dungeon Clawler 2024 Demo): But with a tweak, I found out Unity uses more data to store RGBA32 sprites! Unity uses an Anisotropic filter to enhance the quality. Something that is difficult to replicate with Python and every sprites doesn't follow the same rule! We have to follow them individually. Another example with Clawcula. Interestingly enough, a partial replacement works and those which lack shearing, like the Logo, are easier to replace. Not every sprites use all "layers" which should make things easier. What I replaced with: And here is the original one: Despise the flaw, it's sufficient replacement. I was close to replace the sprites with Animal Crossing cub villagers without using Unity (after the Unity controversy, which lead me to mod Unity games with Python). Video Example: https://drive.google.com/file/d/18L1NBMWRQjwmCnFElAzJ2ww6KMtV2YE9/view?usp=drive_link If you have information on reproducing correctly their Anisotropic effect, feel free to share! Python Scripts: Unity Image Extractor: This extract all sprite data from resource files. Work on RGBA32 and RGB24. Don't forget to create a new folder, I don't know how to make the script allow you to choose one. Unity Image Extractor Script FINAL.py Unity Image Replacer: This replace all sprites with those from the batch. Although it works for RGBA32 and RGB24, it works better for the latter. Unity Image Replacer Script FINAL.py Unity Ano Simulate (Work in Progress): An attempt to simulate the Anisotropic effect for a bulk. Work best for no shear one. Unity Ano Simulate Script (Bulk) with Shear.py

But hard to find pointers. I can only use findloc function to get them. No proper solution. EDiT: Send more samples please...

I just did it manually using ImageHeat. There's some header data, presumably info for each tile, but it's not 100% clear what all the values mean. So it's not really a proper solution yet for all files that might have different size headers.

You can use my latest Fmod Bank Tools - https://www.nexusmods.com/rugbyleaguelive3/mods/2 https://github.com/Wouldubeinta/Fmod-Bank-Tools Just PM me for the bank password.

The initial table at the start is offsets and sizes, as you've guessed. The attached initial QuickBMS script should extract all of the raw files for further analysis. There are no filenames other than what might be in some of the files. However, there are also many compressed files in the extracted "CARC" archives, which I haven't done anything about in my script. The .fsb files are audio banks and can be played directly with Foobar/vgmstream. b10.zip

From a quick look, the files have a variable-sized header, depending on how many parts there seem to be (for example, the "cube" one has 6 parts). This header is followed by decompressed size, then compressed size, and then the compressed data using XMEMLZX compression. Haven't delved into it much more than that, but that should be enough to investigate further.

pack_00.itk is compressed. The small one doesn't. char Sign[4]; uint32 DataBaseOffset; uint32 ResourceCount; uint32 TotalFileSize; struct { char Name[64]; uint32 CompFlag; uint32 CompressedSize; uint32 Offset; uint32 DecompressedSize; }Table[ResourceCount]; Seems like compression is LZSS0. Here is decompressed image. Here's bms. You can also use it on unpacked itk files. They have same struct. #################################### # Dino Crisis 3 og xbox *.itk dump # #################################### get BaseFileName basename comType lzss0 idstring "ITK1" get DataBaseOffset uint32 get ResourceCount uint32 get TotalFileSize uint32 for i = 0 < ResourceCount getdstring ResourceName 0x40 get CompFlag uint32 get ZSize uint32 get Offset uint32 get Size uint32 string FileName p= "%s/%s" BaseFileName ResourceName if CompFlag == 0 log FileName Offset Size else clog FileName Offset ZSize Size endif next i

For XNB you can use tools like xnbcli https://github.com/LeonBlade/xnbcli For TTF you can use tools like High-Logic FontCreator https://www.high-logic.com/font-editor/fontcreator For other files it's hard to tell because you didn't upload any samples.

The face indices start at 0xae48, in 12 bytes blocks, where the last 6 bytes need to be skipped (so reading 3 FIs per block).

I got something but it looks weird.. I read that PS Vita textures are GXT but I don't know much about that format. Here is my result using "Image Heat" I also used ScarletConvert and GXTConvert but those tools don't work with these textures...

I know this is from April but I want to give my two cents on this because I just figured out how to do this myself and I hope this can help other people as well. I'll try and simplify this in a step-by-step format as best as I can. Preliminary requirements Programs you will need include: Ryujinx (or any application that can extract NSP files) RevilLib (for file conversions) Kuriimu2 (for .arc file viewing & exporting) (Optional) Notepad++ or VS Code, I prefer these to create and format .json files in. 1. Getting the extracted files Using Ryujinx is the easiest way to convert the switch rom format (NSP) into something that will be readable by other programs. Right click on the game in the game list>Extract Data>RomFS. It will ask you where you want to output the files, I recommend somewhere you'll easily remember. This will take a few minutes. 2. Locating the desired files After you're done exporting the NSP, open Kuriimu and find the .arc file that you want to open. I haven't (for now) put together a library of monster IDs, but know that large monsters start with "em_xxx" in their file IDs, and small monsters are "ems_xxx". This is where the model and texture files for whatever monster you have selected will be (generally). The "mot" folder has the .lmt files in it though, so I would recommend exporting those into the same folder as the model and texture files. 3. Converting the .mod file(s) This is by far the easiest step. You can simply drag and drop the .mod file onto the mod_to_gltf batch file in RevilLib's folder and it should automatically convert the .mod file to .glb in the same location where the .mod file is stored. 4. Converting the .lmt files After exporting your .lmt files, make sure that your .mod file is in the same location. This will speed up the rest of this process, and is also necessary for the spike batching we're about to do. In the same folder as the .lmt and .mod files, create a .json file (I usually just name it "batch.json). Open it up in your text editor of choice, and now I will quickly explain how the spike batching works. 4.1. Spike Batching Here is an example of my code (which exports the Rathian animations): [ [ "em001_00.glb", "em001_00_0.lmt", "em001_00_1.lmt", "em001_00_2.lmt", "em001_00_3.lmt", "em001_00_4.lmt" ] ] The .json file reads from its root directory, so there is no need to link to individual file paths. Thankfully, this program will also automatically group all the animations together, so when you view them in Blender (using the action viewer, in the dope sheet), it is nice and consolidated. What this does is pretty obvious, but we are just telling the program that the .glb file is the model we want to use with the animations, and the .lmt files are the animations that we are assigning to the model. When you are done with this file, drag and drop it onto the lmt_to_gltf batch file (located in the RevilLib folder, same as mod_to_gltf), and you should have the .glb file containing the animations in your root folder. It will have "out" at the end of the filename, if it isn't clear to you which one it is. 5. Importing to Blender Because I use Blender, that is the program that I will refer to in this step. It's really simple to do this because Blender, thankfully, has .gltf and .glb file-reading built-in, so import the xxx_out.glb file that we just got and everything should import correctly, animations and all. The textures are another beast, but I'm willing to explain those as well if needed.

Sure, here are decompressed CRPs, and here is CRP2DRP which is a very old tool. decompressedcrps.zip crp2drp.zip

Interesting, that was a great idea. Congrats!

I wrote a couple maxscripts for this a few years ago. There are two versions, one for animations which doesn't work and the other for meshes. I never added support for non skinned meshes so most if not all weapons won't load. Maybe you can use this for your studies on how to properly rip the format or you can just use it with max to rip the models. I only wanted Vandal's model so I never really tested it beyond that and a couple other models. https://github.com/sleepyzay/Maxscript-Projects/tree/main/Dead Space Mobile

Similar to "d_unit_sdat" and "d_layunittex.bin" how to extract and convert from it to png or jpg? The file format seems to be segs, I do not know how to convert this file d_laybg.zip

You can view them with ImageHeat https://github.com/bartlomiejduda/ImageHeat

Lots of small point clouds where a mesh is hard to build: Feet:

https://github.com/adarec1994/FABLE2 I've already started putting a tool together. Most models can be converted. I've got the skeletons, too. Static meshes don't work right now, I know what the issue but I think I got the flu, so I'm not really working on it until I feel better. All that's missing now are textures, weights/ skinning/ animations. I attached my script and a few models, if anyone would be willing to help finding the weights. an example of some output: File: Hobbe_Caster.mdl | 442185 bytes | BE | Stride: 28 Found 111 bones, 111 transforms MeshCount: 2 Mesh 0: art\creatures\combatant\hobbe_grunt\pictures\_sharedtextures\hobbe_caster_polished.tex Mesh 1: art\creatures\combatant\hobbe_grunt\pictures\_sharedtextures\hobbe_eye_03.tex Buffer 0 @0x00002193 (preface 😎 initial 13 bytes: 00 00 00 00 00 00 00 00 00 00 16 38 00 vertex: offset=0x000021D4 count=4391 stride=28 faces: offset=0x00020218 count=9407 mode=triangle strips (built 5688 tris) Buffer 1 @0x00035E06 (preface 17) initial 13 bytes: 00 00 00 00 00 00 00 00 01 00 00 00 01 vertex: offset=0x00035E50 count=24 stride=28 faces: offset=0x000360F0 count=31 mode=triangle strips (built 20 tris) Reached MeshCount (2) ✓ Exported: 2 meshes, 3 materials, 111 bones → Hobbe_Caster.glb UV's are also working. I made a post in another part of the forum for help with textures, as far as I'm aware they're compressed and have some sort of encryption. It's beyond my admittedly amateur skillset. mdl_glb_conv.py New WinRAR archive.rar

Please use this updated script to repackage the data file. If you have any questions, please let me know so that other capable people or you can continue to process these .pxc files yourself # Update the decompression of pxc file（script 0.2） get FILE_SIZE asize xmath TOC_PTR "FILE_SIZE - 8" goto TOC_PTR get TOC_OFFSET long goto TOC_OFFSET get FILE_COUNT long for i = 0 < FILE_COUNT get OFFSET long get SIZE long get COMP_FLAG byte get NAME_LEN short getdstring NAME NAME_LEN get UNK long savepos TOC_ENTRY_POS if COMP_FLAG == 0 goto OFFSET getdstring MAGIC 4 if MAGIC == "PxZP" comtype zlib get UNCOMP_SIZE long get COMP_SIZE long savepos DATA_START clog NAME DATA_START COMP_SIZE UNCOMP_SIZE else log NAME OFFSET SIZE endif else goto OFFSET get MAGIC long get UNCOMP_SIZE long get COMP_SIZE long savepos COMP_START clog NAME COMP_START COMP_SIZE UNCOMP_SIZE endif goto TOC_ENTRY_POS next i pxc.zip

public static Byte[] iDecrypt(Byte[] lpBuffer) { Byte bTemp = lpBuffer[lpBuffer.Length - 1]; for (Int32 i = 0; i < lpBuffer.Length; i++) { bTemp = (Byte)(lpBuffer[i] ^ (87 * i + 85)); lpBuffer[i] = (Byte)(bTemp ^ 0xAA); } return lpBuffer; } Just drag and drop those dat files🙂 IKV.DatDecryptor.zip

I checked jmox files but mesh needs transformation... Here's quick sum up content of *.pack archives. main = ? > mixed mdc = jmox > models cars mde = jmox > models environment so = xvs > sounds lm = jtex > textures prb = jtex > textures gin = jtex > textures

d_laybg_tex.zip This is the file I continue to extract. I would like to know how to get the information of the dds file from this file

this one is for decipher Coalesced.*