IDX files

Newbie Spellweaver
Joined
Feb 9, 2019
Messages
32
Reaction score
23
Hello,
I want to extract IDX files, but I absolutely don't know how to do it or what tools could help me. I need them for my next work with TTX files. If anyone has any ideas, I would be grateful. Thank you, community.
 
TCML Project ??

What is inside IDX files ??
IDX :
1738851123738 - IDX files - RaGEZONE Forums

I think that index file TClientS contain information about textures.
IDX :
I think that index file TClientS contain information about textures.
I made program that decompile 4S textures from TTX files, but its not 100% and i need to make function that allow me to change texture and save.
1738851896819 - IDX files - RaGEZONE Forums


Python:
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageTk
import os
import zlib
import io
import threading

class TTXTextureExtractorApp:
    def __init__(self, master):
        self.master = master
        master.title("TTX Texture Extractor")
        master.geometry("800x600")
        master.minsize(600, 400)
        master.configure(bg="#2E2E2E")
        self.ttx_file_path = None
        self.extracted_images = []
        self.current_image_index = 0
        self.create_widgets()
        
        # Keyboard shortcuts for image navigation
        self.master.bind("<Up>", self.show_previous_image)
        self.master.bind("<Down>", self.show_next_image)

    def create_widgets(self):
        # Open TTX file button
        btn_open = ttk.Button(self.master, text="Open TTX", command=self.open_file)
        btn_open.grid(row=0, column=0, pady=10, padx=10, sticky="ew")

        # Frame and Listbox for texture list
        list_frame = ttk.Frame(self.master)
        list_frame.grid(row=1, column=0, padx=10, pady=10, sticky="nsew")
        
        self.listbox = tk.Listbox(list_frame, width=50, height=15, selectmode=tk.SINGLE, bg="#3E3E3E", fg="white")
        self.listbox.grid(row=0, column=0, padx=5, pady=5)
        self.listbox.bind("<<ListboxSelect>>", self.show_selected_image)

        scroll = ttk.Scrollbar(list_frame, orient="vertical", command=self.listbox.yview)
        scroll.grid(row=0, column=1, sticky="ns")
        self.listbox.config(yscrollcommand=scroll.set)

        # Canvas for image display
        self.canvas = tk.Canvas(self.master, width=400, height=400, bg="#1E1E1E")
        self.canvas.grid(row=1, column=1, padx=10, pady=10)

        # Button panel
        btn_frame = tk.Frame(self.master, bg="#333333")
        btn_frame.grid(row=2, column=0, columnspan=2, pady=10, padx=10, sticky="ew")

        btn_replace = ttk.Button(btn_frame, text="Replace Image", command=self.replace_selected_image, style="TButton")
        btn_replace.grid(row=0, column=0, padx=5)

        btn_save_all = ttk.Button(btn_frame, text="Save All Images", command=self.save_all_images, style="TButton")
        btn_save_all.grid(row=0, column=1, padx=5)

        btn_save = ttk.Button(btn_frame, text="Save TTX", command=self.save_to_ttx, style="TButton")
        btn_save.grid(row=0, column=2, padx=5)

        # Layout configuration
        self.master.grid_rowconfigure(1, weight=1)
        self.master.grid_columnconfigure(0, weight=1)
        self.master.grid_columnconfigure(1, weight=1)

        # Button styling
        style = ttk.Style()
        style.configure("TButton",
                        background="#444444",
                        foreground="black",
                        font=("Helvetica", 10),
                        padding=5)
        style.map("TButton",
                  background=[('active', '#555555')],
                  relief=[('pressed', 'sunken'), ('!pressed', 'raised')])

    def extract_textures(self, ttx_file):
        try:
            with open(ttx_file, "rb") as file:
                data = file.read()
        except Exception as e:
            messagebox.showerror("Error", f"File read error: {e}")
            return []

        offsets = []
        i = 0
        while i < len(data) - 1:
            if data[i] == 0x78 and data[i + 1] == 0xDA:
                offsets.append(i)
                i += 2
            else:
                i += 1

        extracted = []
        for count, offset in enumerate(offsets):
            try:
                decomp = zlib.decompressobj()
                decompressed = decomp.decompress(data[offset:])
                decompressed += decomp.flush()
                
                if len(decompressed) < 128 or decompressed[0:4] != b'DDS ':
                    continue

                header_size = int.from_bytes(decompressed[4:8], byteorder='little')
                if header_size != 124:
                    continue

                orig_comp_length = len(data[offset:]) - len(decomp.unused_data)
                extracted.append({
                    "name": f"texture_{count}.dds",
                    "raw_data": decompressed,
                    "offset": offset,
                    "decompressed_length": len(decompressed),
                    "original_compressed_length": orig_comp_length,
                    "compressed_data": data[offset:offset+orig_comp_length],
                    "modified": False
                })
            except Exception as e:
                print(f"Error processing offset {offset}: {e}")
                continue

        return extracted

    def open_file(self):
        file_path = filedialog.askopenfilename(filetypes=[("TTX Files", "*.ttx")])
        if file_path:
            self.ttx_file_path = file_path
            
            self.progress_window = tk.Toplevel(self.master)
            self.progress_window.title("Loading")
            tk.Label(self.progress_window, text="Extracting textures...").pack(pady=5)
            self.progress_bar = ttk.Progressbar(self.progress_window, mode='indeterminate')
            self.progress_bar.pack(pady=5, padx=10)
            self.progress_bar.start()
            self.progress_window.grab_set()

            def extract_thread():
                try:
                    extracted = self.extract_textures(file_path)
                    self.master.after(0, lambda: self.on_extraction_done(extracted))
                except Exception as e:
                    self.master.after(0, lambda: self.on_extraction_error(e))

            threading.Thread(target=extract_thread, daemon=True).start()

    def on_extraction_done(self, extracted):
        self.progress_window.destroy()
        self.extracted_images = extracted
        if self.extracted_images:
            messagebox.showinfo("Success", f"Extracted {len(self.extracted_images)} images")
            self.update_listbox()
        else:
            messagebox.showerror("Error", "No images could be extracted.")

    def on_extraction_error(self, error):
        self.progress_window.destroy()
        messagebox.showerror("Error", f"Extraction error: {str(error)}")

    def update_listbox(self):
        self.listbox.delete(0, tk.END)
        for img in self.extracted_images:
            display_text = f"{img['name']} @ offset {img['offset']}"
            self.listbox.insert(tk.END, display_text)

    def show_selected_image(self, event):
        selected_indices = self.listbox.curselection()
        if not selected_indices:
            return
        index = selected_indices[0]
        img_data = self.extracted_images[index]['raw_data']

        try:
            img = Image.open(io.BytesIO(img_data))
            img.thumbnail((400, 400))
            img_tk = ImageTk.PhotoImage(img)
            self.canvas.delete("all")
            self.canvas.create_image(200, 200, image=img_tk)
            self.canvas.image = img_tk
        except Exception as e:
            messagebox.showerror("Error", f"Failed to display image: {e}")

    def show_previous_image(self, event):
        if self.extracted_images:
            self.current_image_index = (self.current_image_index - 1) % len(self.extracted_images)
            self.listbox.selection_clear(0, tk.END)
            self.listbox.selection_set(self.current_image_index)
            self.show_selected_image(None)

    def show_next_image(self, event):
        if self.extracted_images:
            self.current_image_index = (self.current_image_index + 1) % len(self.extracted_images)
            self.listbox.selection_clear(0, tk.END)
            self.listbox.selection_set(self.current_image_index)
            self.show_selected_image(None)

    def replace_selected_image(self):
        selected_indices = self.listbox.curselection()
        if not selected_indices:
            messagebox.showwarning("Warning", "Please select an image to replace.")
            return
        index = selected_indices[0]
        current_entry = self.extracted_images[index]

        new_image_path = filedialog.askopenfilename(filetypes=[("Image Files", "*.dds")])
        if new_image_path:
            try:
                with open(new_image_path, "rb") as f:
                    new_data = f.read()
                
                if not new_data.startswith(b"DDS "):
                    messagebox.showerror("Error", "Invalid DDS file!")
                    return

                new_compressed = zlib.compress(new_data, level=9)
                
                current_entry['raw_data'] = new_data
                current_entry['compressed_data'] = new_compressed
                current_entry['decompressed_length'] = len(new_data)
                current_entry['original_compressed_length'] = len(new_compressed)
                current_entry['modified'] = True
                
                messagebox.showinfo("Success", "Image replaced successfully.")
                self.update_listbox()
            except Exception as e:
                messagebox.showerror("Error", f"Processing error: {e}")

    def save_all_images(self):
        if not self.extracted_images:
            messagebox.showwarning("Warning", "No images to save.")
            return
        dir_path = filedialog.askdirectory()
        if dir_path:
            self.progress_window = tk.Toplevel(self.master)
            self.progress_window.title("Saving")
            tk.Label(self.progress_window, text="Saving images...").pack(pady=5)
            self.progress_bar = ttk.Progressbar(
                self.progress_window,
                mode='determinate',
                maximum=len(self.extracted_images)
            )
            self.progress_bar.pack(pady=5, padx=10)
            self.progress_window.grab_set()

            def save_thread():
                total = len(self.extracted_images)
                for i, img in enumerate(self.extracted_images):
                    path = os.path.join(dir_path, img['name'])
                    try:
                        with open(path, "wb") as f:
                            f.write(img['raw_data'])
                    except Exception as e:
                        print(f"Error saving {path}: {e}")
                    self.master.after(0, lambda v=i+1: self.progress_bar.configure(value=v))
                self.master.after(0, self.on_save_images_done)

            threading.Thread(target=save_thread, daemon=True).start()

    def on_save_images_done(self):
        self.progress_window.destroy()
        messagebox.showinfo("Success", f"Saved {len(self.extracted_images)} images.")

    def save_to_ttx(self):
        if not self.ttx_file_path:
            messagebox.showerror("Error", "No TTX file open")
            return

        modified_images = [img for img in self.extracted_images if img['modified']]
        if not modified_images:
            messagebox.showinfo("Info", "No changes to save.")
            return

        self.progress_window = tk.Toplevel(self.master)
        self.progress_window.title("Saving")
        tk.Label(self.progress_window, text="Saving TTX file...").pack(pady=5)
        self.progress_bar = ttk.Progressbar(
            self.progress_window,
            mode='indeterminate'
        )
        self.progress_bar.pack(pady=5, padx=10)
        self.progress_bar.start()
        self.progress_window.grab_set()

        def save_thread():
            new_data = bytearray()
            with open(self.ttx_file_path, "rb") as f:
                original_data = f.read()

            sorted_images = sorted(modified_images, key=lambda x: x['offset'])
            for img in sorted_images:
                start_offset = img['offset']
                new_data[start_offset:start_offset+len(img['compressed_data'])] = img['compressed_data']

            try:
                with open(self.ttx_file_path, "wb") as f:
                    f.write(new_data)
                self.master.after(0, lambda: self.on_save_ttx_done())
            except Exception as e:
                self.master.after(0, lambda: self.on_save_ttx_error(e))

        threading.Thread(target=save_thread, daemon=True).start()

    def on_save_ttx_done(self):
        self.progress_window.destroy()
        messagebox.showinfo("Success", "TTX file saved successfully.")

    def on_save_ttx_error(self, error):
        self.progress_window.destroy()
        messagebox.showerror("Error", f"TTX save error: {error}")

# Create and run the application
root = tk.Tk()
app = TTXTextureExtractorApp(root)
root.mainloop()
 
Upvote 0
IDX are Index files, if im correct dwPOS in TTX is linked in Index, you have to update italways when you change something in textures.
🫡
 
Last edited:
Upvote 0
You need make a tool what will automaticly update aswell .IDX file, something like is mine tool,

I can edit TIS/TIM/TTX


View attachment 277679
Great work! I know you put a lot of effort into this. Are you able to share it or at least provide the key functions as code so we can adopt it as well? :-) Add me on discord if you got time to talk about it: icastillo5938
 
Last edited:
Upvote 0
Great work! I know you put a lot of effort into this. Are you able to share it or at least provide the key functions as code so we can adopt it as well? :-) Add me on discord if you got time to talk about it: icastillo5938
He spent like zero time and effort; it's a tool from the owner of 4Hell, which shouldn't be available to him at all. But yeah, 4Story. I also have the source of this tool, and I could post photos of it like he did, but what's the point? And for sure, I won't claim this tool as mine like he did.
 
Upvote 0
Back