From def94e02d3720f3f62ecfee13dad7dbb8e12156b Mon Sep 17 00:00:00 2001
From: Martin Gerhardy <martin.gerhardy@gmail.com>
Date: Tue, 7 Jul 2026 14:58:56 +0200
Subject: [PATCH 1/2] TWINE: add extract and translation tools

Assisted-by: Cursor:auto
---
 .gitignore                                 |   5 +
 Makefile.common                            |  18 +
 dists/win32/ScummVM Tools.iss              |   1 +
 engines/twine/create_twine_translation.cpp | 600 ++++++++++++++++
 engines/twine/extract_twine.cpp            | 549 ++++++++++++++
 engines/twine/extract_twine_convert.cpp    | 792 +++++++++++++++++++++
 engines/twine/extract_twine_convert.h      |  94 +++
 engines/twine/extract_twine_font.cpp       | 400 +++++++++++
 engines/twine/extract_twine_island.cpp     | 525 ++++++++++++++
 engines/twine/extract_twine_obj.cpp        | 237 ++++++
 engines/twine/hqr.cpp                      | 127 +++-
 engines/twine/hqr.h                        |  10 +
 engines/twine/parser/body.cpp              | 548 ++++++++++++++
 engines/twine/parser/body.h                |  86 +++
 engines/twine/parser/bodytypes.h           | 117 +++
 15 files changed, 4096 insertions(+), 13 deletions(-)
 create mode 100644 engines/twine/create_twine_translation.cpp
 create mode 100644 engines/twine/extract_twine.cpp
 create mode 100644 engines/twine/extract_twine_convert.cpp
 create mode 100644 engines/twine/extract_twine_convert.h
 create mode 100644 engines/twine/extract_twine_font.cpp
 create mode 100644 engines/twine/extract_twine_island.cpp
 create mode 100644 engines/twine/extract_twine_obj.cpp
 create mode 100644 engines/twine/parser/body.cpp
 create mode 100644 engines/twine/parser/body.h
 create mode 100644 engines/twine/parser/bodytypes.h

diff --git a/.gitignore b/.gitignore
index ab28e83b..2d704fd6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,16 +7,21 @@
 
 /.gdb_history
 /construct_mohawk
+/create_macs2_translation
 /create_sjisfnt
+/create_twine_translation
 /decine
 /decompile
 /degob
 /dekyra
+/demacs2
 /deprince
 /descumm
 /desword2
 /detwine
+/extract_twine
 /extract_hadesch_img
+/extract_macs2
 /extract_mohawk
 /extract_mps
 /extract_gob_cdi
diff --git a/Makefile.common b/Makefile.common
index 9fa390f1..84064c65 100644
--- a/Makefile.common
+++ b/Makefile.common
@@ -31,11 +31,13 @@ PROGRAMS = \
 	descumm \
 	desword2 \
 	detwine \
+	extract_twine \
 	gob_loadcalc \
 	extract_gob_cdi \
 	extract_mohawk \
 	extract_macs2 \
 	create_macs2_translation \
+	create_twine_translation \
 	extract_ngi \
 	construct_mohawk \
 	msn_convert_mod \
@@ -149,6 +151,11 @@ extract_macs2_OBJS := \
 create_macs2_translation_OBJS := \
 	engines/macs2/create_macs2_translation.o
 
+create_twine_translation_OBJS := \
+	engines/twine/create_twine_translation.o \
+	engines/twine/hqr.o \
+	$(UTILS)
+
 extract_hadesch_OBJS := \
 	engines/hadesch/extract_hadesch.o \
 	$(UTILS)
@@ -232,6 +239,17 @@ detwine_OBJS := \
 	version.o \
 	$(UTILS)
 
+extract_twine_OBJS := \
+	engines/twine/extract_twine.o \
+	engines/twine/extract_twine_convert.o \
+	engines/twine/extract_twine_font.o \
+	engines/twine/extract_twine_island.o \
+	engines/twine/extract_twine_obj.o \
+	engines/twine/parser/body.o \
+	engines/twine/hqr.o \
+	$(UTILS)
+extract_twine_LIBS := $(LIBS)
+
 gob_loadcalc_OBJS := \
 	engines/gob/gob_loadcalc.o
 
diff --git a/dists/win32/ScummVM Tools.iss b/dists/win32/ScummVM Tools.iss
index cfdf029e..2aa0dd3a 100755
--- a/dists/win32/ScummVM Tools.iss	
+++ b/dists/win32/ScummVM Tools.iss	
@@ -35,6 +35,7 @@ Source: "deprince.exe"; DestDir: "{app}"; Flags: ignoreversion
 Source: "descumm.exe"; DestDir: "{app}"; Flags: ignoreversion 
 Source: "desword2.exe"; DestDir: "{app}"; Flags: ignoreversion 
 Source: "detwine.exe"; DestDir: "{app}"; Flags: ignoreversion
+Source: "extract_twine.exe"; DestDir: "{app}"; Flags: ignoreversion
 Source: "extract_gob_cdi.exe"; DestDir: "{app}"; Flags: ignoreversion
 Source: "extract_hadesch.exe"; DestDir: "{app}"; Flags: ignoreversion
 Source: "extract_hadesch_img.exe"; DestDir: "{app}"; Flags: ignoreversion
diff --git a/engines/twine/create_twine_translation.cpp b/engines/twine/create_twine_translation.cpp
new file mode 100644
index 00000000..1ba579bd
--- /dev/null
+++ b/engines/twine/create_twine_translation.cpp
@@ -0,0 +1,600 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * LBA (TwinE) TEXT.HQR translation tool
+ *
+ * Workflow:
+ *   1. Extract: create_twine_translation extract <TEXT.HQR> <output.pot> [--lang N] [--lba1|--lba2]
+ *   2. Translate the .po file (Poedit, Weblate, etc.)
+ *   3. Pack:    create_twine_translation pack <translated.po> <template TEXT.HQR> <output TEXT.HQR> [--lang N]
+ *
+ * PO format:
+ *   msgctxt "bank:2:slot:0:textId:123"
+ *   msgid "Original dialog line"
+ *   msgstr "Translated dialog line"
+ */
+
+#include "common/file.h"
+#include "common/memstream.h"
+#include "engines/twine/hqr.h"
+
+#include <map>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <vector>
+
+namespace {
+
+static const char *const kBankNames[] = {
+	"Options_and_menus",
+	"Credits",
+	"Inventory_Intro_and_Holomap",
+	"Citadel_Island",
+	"Principal_Island",
+	"White_Leaf_Desert",
+	"Proxima_Island",
+	"Rebellion_Island",
+	"Hamalayi_mountains_southern_range",
+	"Hamalayi_mountains_northern_range",
+	"Tippet_Island",
+	"Brundle_Island",
+	"Fortress_Island",
+	"Polar_Island",
+	"Extra_Bank",
+	nullptr
+};
+
+struct GameTextInfo {
+	bool lba1;
+	int entryCount;
+	int numBanks;
+	int numLanguages;
+};
+
+struct TextLine {
+	int slot;
+	int16_t textId;
+	std::string text;
+};
+
+static void printUsage(const char *bin) {
+	printf("LBA TEXT.HQR translation tool\n\n");
+	printf("Usage:\n");
+	printf("  %s extract <TEXT.HQR> <output.pot> [--lang N] [--lba1|--lba2]\n", bin);
+	printf("  %s pack <translated.po> <template TEXT.HQR> <output TEXT.HQR> [--lang N]\n\n", bin);
+	printf("Options:\n");
+	printf("  --lang N   Language index to extract or replace (default: 0)\n");
+	printf("  --lba1     Force LBA 1 layout (28 entries per language, 14 banks)\n");
+	printf("  --lba2     Force LBA 2 layout (30 entries per language, 15 banks)\n");
+}
+
+static bool detectGameTextInfo(const Common::Filename &filename, bool forceLba1, bool forceLba2, GameTextInfo &info) {
+	const int32 numEntries = TwinE::HQR::numEntries(filename);
+	if (numEntries <= 0)
+		return false;
+
+	if (forceLba1) {
+		info.lba1 = true;
+		info.entryCount = 28;
+	} else if (forceLba2) {
+		info.lba1 = false;
+		info.entryCount = 30;
+	} else if (numEntries == 140) {
+		info.lba1 = true;
+		info.entryCount = 28;
+	} else if (numEntries == 180) {
+		info.lba1 = false;
+		info.entryCount = 30;
+	} else {
+		fprintf(stderr, "Unknown TEXT.HQR size (%d entries). Use --lba1 or --lba2.\n", numEntries);
+		return false;
+	}
+
+	info.numBanks = info.entryCount / 2;
+	info.numLanguages = numEntries / info.entryCount;
+	if (info.numLanguages <= 0 || info.numBanks <= 0) {
+		fprintf(stderr, "Invalid TEXT.HQR layout\n");
+		return false;
+	}
+	return true;
+}
+
+static std::string cp850ToUtf8(const std::string &s) {
+	static const uint16_t cp850map[128] = {
+		0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+		0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, 0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
+		0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+		0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0, 0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
+		0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+		0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE, 0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
+		0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE, 0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
+		0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8, 0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
+	};
+
+	std::string out;
+	for (unsigned char c : s) {
+		if (c < 0x80) {
+			out += (char)c;
+		} else {
+			uint16_t u = cp850map[c - 0x80];
+			if (u < 0x80) {
+				out += (char)u;
+			} else if (u < 0x800) {
+				out += (char)(0xC0 | (u >> 6));
+				out += (char)(0x80 | (u & 0x3F));
+			} else {
+				out += (char)(0xE0 | (u >> 12));
+				out += (char)(0x80 | ((u >> 6) & 0x3F));
+				out += (char)(0x80 | (u & 0x3F));
+			}
+		}
+	}
+	return out;
+}
+
+static std::string utf8ToCp850(const std::string &s) {
+	static std::map<uint32_t, uint8_t> reverseMap;
+	if (reverseMap.empty()) {
+		static const uint16_t cp850map[128] = {
+			0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+			0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, 0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
+			0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+			0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0, 0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
+			0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+			0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE, 0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
+			0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE, 0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
+			0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8, 0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
+		};
+		for (int i = 0; i < 128; i++)
+			reverseMap[cp850map[i]] = (uint8_t)(0x80 + i);
+	}
+
+	std::string out;
+	for (size_t i = 0; i < s.size();) {
+		unsigned char c = s[i];
+		if (c < 0x80) {
+			out += (char)c;
+			i++;
+			continue;
+		}
+
+		uint32_t codepoint = 0;
+		if ((c & 0xE0) == 0xC0 && i + 1 < s.size()) {
+			codepoint = ((c & 0x1F) << 6) | (s[i + 1] & 0x3F);
+			i += 2;
+		} else if ((c & 0xF0) == 0xE0 && i + 2 < s.size()) {
+			codepoint = ((c & 0x0F) << 12) | ((s[i + 1] & 0x3F) << 6) | (s[i + 2] & 0x3F);
+			i += 3;
+		} else {
+			out += '?';
+			i++;
+			continue;
+		}
+
+		auto it = reverseMap.find(codepoint);
+		if (it != reverseMap.end())
+			out += (char)it->second;
+		else if (codepoint < 0x80)
+			out += (char)codepoint;
+		else
+			out += '?';
+	}
+	return out;
+}
+
+static std::string poEscape(const std::string &s) {
+	std::string out;
+	for (char c : s) {
+		if (c == '\\')
+			out += "\\\\";
+		else if (c == '"')
+			out += "\\\"";
+		else if (c == '\n')
+			out += "\\n";
+		else if (c == '\r')
+			out += "\\r";
+		else if (c == '\t')
+			out += "\\t";
+		else
+			out += c;
+	}
+	return out;
+}
+
+static std::string poUnescape(const std::string &s) {
+	std::string out;
+	for (size_t i = 0; i < s.size(); i++) {
+		if (s[i] == '\\' && i + 1 < s.size()) {
+			if (s[i + 1] == 'n') {
+				out += '\n';
+				i++;
+			} else if (s[i + 1] == 'r') {
+				out += '\r';
+				i++;
+			} else if (s[i + 1] == 't') {
+				out += '\t';
+				i++;
+			} else if (s[i + 1] == '\\') {
+				out += '\\';
+				i++;
+			} else if (s[i + 1] == '"') {
+				out += '"';
+				i++;
+			} else {
+				out += s[i];
+			}
+		} else {
+			out += s[i];
+		}
+	}
+	return out;
+}
+
+static bool parseTextBank(const uint8 *ordData, int32 ordSize, const uint8 *lbtData, int32 lbtSize, bool lba1,
+		std::vector<TextLine> &lines) {
+	if (!ordData || !lbtData || ordSize < 2 || lbtSize < 4)
+		return false;
+
+	const int numIdxEntries = ordSize / 2;
+	Common::MemoryReadStream ordStream(ordData, ordSize);
+	Common::MemoryReadStream lbtStream(lbtData, lbtSize);
+
+	lines.clear();
+	lines.reserve(numIdxEntries);
+
+	for (int entry = 0; entry < numIdxEntries; ++entry) {
+		if (lbtStream.pos() + 4 > lbtSize)
+			break;
+
+		const int16_t textId = (int16_t)ordStream.readUint16LE();
+		uint16 start = lbtStream.readUint16LE();
+		const int32 offsetPos = lbtStream.pos();
+		const uint16 end = lbtStream.readUint16LE();
+
+		if (end >= (uint16)lbtSize)
+			break;
+
+		if (!lba1)
+			++start;
+
+		std::string result;
+		if (start < lbtSize && end > start) {
+			lbtStream.seek(start);
+			for (int32 i = start; i < (int32)end - 1 && i < lbtSize; ++i) {
+				const char c = (char)lbtStream.readByte();
+				if (c == '\0')
+					break;
+				result += c;
+			}
+		}
+
+		TextLine line;
+		line.slot = entry;
+		line.textId = textId;
+		line.text = result;
+		lines.push_back(line);
+
+		lbtStream.seek(offsetPos);
+	}
+
+	return !lines.empty();
+}
+
+static std::vector<uint8> buildLbtBlob(const std::vector<std::string> &strings, bool lba1) {
+	std::vector<uint16_t> offsets;
+	std::vector<uint8> stringData;
+
+	const uint16_t tableSize = (uint16_t)((strings.size() + 1) * 2);
+	uint16_t pos = tableSize;
+
+	for (size_t i = 0; i < strings.size(); i++) {
+		const uint16_t stored = lba1 ? pos : (uint16_t)(pos - 1);
+		offsets.push_back(stored);
+		for (unsigned char c : strings[i])
+			stringData.push_back(c);
+		stringData.push_back(0);
+		pos = (uint16_t)(tableSize + stringData.size());
+	}
+	offsets.push_back(pos);
+
+	std::vector<uint8> out;
+	out.reserve(tableSize + stringData.size());
+	for (uint16_t off : offsets) {
+		out.push_back((uint8)(off & 0xFF));
+		out.push_back((uint8)(off >> 8));
+	}
+	out.insert(out.end(), stringData.begin(), stringData.end());
+	return out;
+}
+
+static int langBaseIndex(int bank, int language, int entryCount) {
+	return bank * 2 + entryCount * language;
+}
+
+static const char *bankName(int bank) {
+	if (bank >= 0 && kBankNames[bank])
+		return kBankNames[bank];
+	return "unknown";
+}
+
+static int doExtract(const Common::Filename &textFile, const char *outPath, const GameTextInfo &info, int language) {
+	if (language < 0 || language >= info.numLanguages) {
+		fprintf(stderr, "Invalid language index %d (available: 0-%d)\n", language, info.numLanguages - 1);
+		return 1;
+	}
+
+	FILE *out = fopen(outPath, "w");
+	if (!out) {
+		fprintf(stderr, "Error: Cannot create '%s'\n", outPath);
+		return 1;
+	}
+
+	fprintf(out, "# Little Big Adventure TEXT.HQR translation file\n");
+	fprintf(out, "# Copyright (C) ScummVM Team\n");
+	fprintf(out, "#\n");
+	fprintf(out, "msgid \"\"\n");
+	fprintf(out, "msgstr \"\"\n");
+	fprintf(out, "\"Project-Id-Version: twine\\n\"\n");
+	fprintf(out, "\"Report-Msgid-Bugs-To: scummvm-devel@lists.scummvm.org\\n\"\n");
+	fprintf(out, "\"MIME-Version: 1.0\\n\"\n");
+	fprintf(out, "\"Content-Type: text/plain; charset=UTF-8\\n\"\n");
+	fprintf(out, "\"Content-Transfer-Encoding: 8bit\\n\"\n\n");
+
+	int totalEntries = 0;
+	for (int bank = 0; bank < info.numBanks; bank++) {
+		const int baseIndex = langBaseIndex(bank, language, info.entryCount);
+		const int lbtIndex = baseIndex;
+		const int ordIndex = baseIndex + 1;
+
+		TwinE::HQR::HqrPackEntry ordEntry;
+		TwinE::HQR::HqrPackEntry lbtEntry;
+		if (!TwinE::HQR::loadHqrEntry(textFile, ordIndex, ordEntry) || ordEntry.blank) {
+			fprintf(stderr, "Warning: missing ORD entry for bank %d (%s)\n", bank, bankName(bank));
+			continue;
+		}
+		if (!TwinE::HQR::loadHqrEntry(textFile, lbtIndex, lbtEntry) || lbtEntry.blank) {
+			fprintf(stderr, "Warning: missing LBT entry for bank %d (%s)\n", bank, bankName(bank));
+			continue;
+		}
+
+		std::vector<TextLine> lines;
+		if (!parseTextBank(ordEntry.data.data(), (int32)ordEntry.data.size(), lbtEntry.data.data(),
+					(int32)lbtEntry.data.size(), info.lba1, lines)) {
+			fprintf(stderr, "Warning: failed to parse bank %d (%s)\n", bank, bankName(bank));
+			continue;
+		}
+
+		fprintf(out, "#. bank: %d (%s)\n", bank, bankName(bank));
+		for (const TextLine &line : lines) {
+			if (line.text.empty())
+				continue;
+			fprintf(out, "msgctxt \"bank:%d:slot:%d:textId:%d\"\n", bank, line.slot, (int)line.textId);
+			fprintf(out, "msgid \"%s\"\n", poEscape(cp850ToUtf8(line.text)).c_str());
+			fprintf(out, "msgstr \"\"\n\n");
+			totalEntries++;
+		}
+	}
+
+	fclose(out);
+	printf("Extracted %d text entries (language %d) to %s\n", totalEntries, language, outPath);
+	return 0;
+}
+
+struct PoTranslation {
+	int bank;
+	int slot;
+	std::string text;
+};
+
+static int doPack(const char *poPath, const Common::Filename &templateFile, const char *outPath,
+		const GameTextInfo &info, int language) {
+	if (language < 0 || language >= info.numLanguages) {
+		fprintf(stderr, "Invalid language index %d (available: 0-%d)\n", language, info.numLanguages - 1);
+		return 1;
+	}
+
+	FILE *in = fopen(poPath, "r");
+	if (!in) {
+		fprintf(stderr, "Error: Cannot open '%s'\n", poPath);
+		return 1;
+	}
+
+	std::map<std::pair<int, int>, std::string> translations;
+	char buf[8192];
+	int currentBank = -1;
+	int currentSlot = -1;
+	bool inMsgstr = false;
+	std::string currentMsgstr;
+
+	auto flushEntry = [&]() {
+		if (currentBank >= 0 && currentSlot >= 0 && !currentMsgstr.empty()) {
+			translations[std::make_pair(currentBank, currentSlot)] = poUnescape(currentMsgstr);
+		}
+		currentBank = -1;
+		currentSlot = -1;
+		currentMsgstr.clear();
+		inMsgstr = false;
+	};
+
+	while (fgets(buf, sizeof(buf), in)) {
+		size_t len = strlen(buf);
+		while (len > 0 && (buf[len - 1] == '\n' || buf[len - 1] == '\r'))
+			buf[--len] = '\0';
+
+		if (strncmp(buf, "msgctxt \"", 9) == 0) {
+			flushEntry();
+			int bank = 0, slot = 0, textId = 0;
+			if (sscanf(buf + 9, "bank:%d:slot:%d:textId:%d", &bank, &slot, &textId) == 3) {
+				currentBank = bank;
+				currentSlot = slot;
+				(void)textId;
+			}
+			continue;
+		}
+		if (strncmp(buf, "msgstr ", 7) == 0) {
+			inMsgstr = true;
+			char *s = strchr(buf + 7, '"');
+			currentMsgstr.clear();
+			if (s) {
+				s++;
+				char *e = strrchr(s, '"');
+				if (e)
+					currentMsgstr = std::string(s, e - s);
+			}
+			continue;
+		}
+		if (buf[0] == '"' && inMsgstr) {
+			char *s = buf + 1;
+			char *e = strrchr(s, '"');
+			if (e)
+				currentMsgstr += std::string(s, e - s);
+			continue;
+		}
+		if (buf[0] == '\0')
+			flushEntry();
+	}
+	flushEntry();
+	fclose(in);
+
+	const int32 numEntries = TwinE::HQR::numEntries(templateFile);
+	std::vector<TwinE::HQR::HqrPackEntry> entries((size_t)numEntries);
+
+	for (int32 i = 0; i < numEntries; i++) {
+		if (!TwinE::HQR::loadHqrEntry(templateFile, i, entries[(size_t)i])) {
+			fprintf(stderr, "Failed to load template entry %d\n", (int)i);
+			return 1;
+		}
+	}
+
+	int replacedBanks = 0;
+	for (int bank = 0; bank < info.numBanks; bank++) {
+		const int baseIndex = langBaseIndex(bank, language, info.entryCount);
+		const int lbtIndex = baseIndex;
+		const int ordIndex = baseIndex + 1;
+		if (ordIndex < 0 || lbtIndex >= numEntries)
+			continue;
+
+		TwinE::HQR::HqrPackEntry &ordEntry = entries[(size_t)ordIndex];
+		TwinE::HQR::HqrPackEntry &lbtEntry = entries[(size_t)lbtIndex];
+		if (ordEntry.blank || ordEntry.data.empty())
+			continue;
+
+		std::vector<TextLine> lines;
+		if (lbtEntry.blank) {
+			// Create a new LBT from ORD only.
+			const int numIdxEntries = (int)(ordEntry.data.size() / 2);
+			lines.reserve(numIdxEntries);
+			for (int slot = 0; slot < numIdxEntries; slot++) {
+				TextLine line;
+				line.slot = slot;
+				line.textId = (int16_t)(ordEntry.data[slot * 2] | (ordEntry.data[slot * 2 + 1] << 8));
+				line.text.clear();
+				lines.push_back(line);
+			}
+		} else if (!parseTextBank(ordEntry.data.data(), (int32)ordEntry.data.size(), lbtEntry.data.data(),
+					(int32)lbtEntry.data.size(), info.lba1, lines)) {
+			fprintf(stderr, "Warning: failed to parse bank %d (%s), skipping\n", bank, bankName(bank));
+			continue;
+		}
+
+		std::vector<std::string> packedStrings;
+		packedStrings.reserve(lines.size());
+		for (const TextLine &line : lines) {
+			std::string translated = line.text;
+			auto it = translations.find(std::make_pair(bank, line.slot));
+			if (it != translations.end() && !it->second.empty())
+				translated = it->second;
+			packedStrings.push_back(utf8ToCp850(translated));
+		}
+
+		lbtEntry.blank = false;
+		lbtEntry.data = buildLbtBlob(packedStrings, info.lba1);
+		replacedBanks++;
+	}
+
+	const Common::Filename outFile(outPath);
+	if (!TwinE::HQR::writeHqrArchive(outFile, entries)) {
+		fprintf(stderr, "Failed to write %s\n", outPath);
+		return 1;
+	}
+
+	printf("Packed %d text banks for language %d into %s\n", replacedBanks, language, outPath);
+	return 0;
+}
+
+} // namespace
+
+int main(int argc, char *argv[]) {
+	if (argc < 2) {
+		printUsage(argv[0]);
+		return 1;
+	}
+
+	if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
+		printUsage(argv[0]);
+		return 0;
+	}
+
+	int language = 0;
+	bool forceLba1 = false;
+	bool forceLba2 = false;
+
+	for (int i = 2; i < argc; i++) {
+		if (strcmp(argv[i], "--lang") == 0 && i + 1 < argc) {
+			language = atoi(argv[++i]);
+		} else if (strcmp(argv[i], "--lba1") == 0) {
+			forceLba1 = true;
+		} else if (strcmp(argv[i], "--lba2") == 0) {
+			forceLba2 = true;
+		}
+	}
+
+	if (strcmp(argv[1], "extract") == 0) {
+		if (argc < 4) {
+			printUsage(argv[0]);
+			return 1;
+		}
+		const Common::Filename textFile(argv[2]);
+		GameTextInfo info;
+		if (!detectGameTextInfo(textFile, forceLba1, forceLba2, info))
+			return 1;
+		return doExtract(textFile, argv[3], info, language);
+	}
+
+	if (strcmp(argv[1], "pack") == 0) {
+		if (argc < 5) {
+			printUsage(argv[0]);
+			return 1;
+		}
+		const Common::Filename templateFile(argv[3]);
+		GameTextInfo info;
+		if (!detectGameTextInfo(templateFile, forceLba1, forceLba2, info))
+			return 1;
+		return doPack(argv[2], templateFile, argv[4], info, language);
+	}
+
+	printUsage(argv[0]);
+	return 1;
+}
diff --git a/engines/twine/extract_twine.cpp b/engines/twine/extract_twine.cpp
new file mode 100644
index 00000000..7bf5c723
--- /dev/null
+++ b/engines/twine/extract_twine.cpp
@@ -0,0 +1,549 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/* LBA (TwinE) HQR/VOX/ILE/OBL resource extractor */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#ifdef WIN32
+#include <direct.h>
+#else
+#include <sys/stat.h>
+#endif
+
+#include "common/file.h"
+#include "common/util.h"
+#include "engines/twine/extract_twine_convert.h"
+#include "engines/twine/hqr.h"
+
+namespace {
+
+enum VoxType {
+	VOXT_NONE = 0,
+	VOXT_LBA1,
+	VOXT_LBA2
+};
+
+static void printHelp(const char *bin) {
+	printf("Usage: %s [options] <resource> <outputdir> [index]\n\n", bin);
+	printf("Extract entries from Little Big Adventure resource archives.\n");
+	printf("Supported formats: HQR, VOX, ILE, OBL\n\n");
+	printf("If index is omitted, all entries are extracted.\n");
+	printf("Blank entries (zero offsets) are skipped.\n\n");
+	printf("Options:\n");
+	printf("  --convert       Export images/fonts/palettes/islands, models as OBJ, audio as WAV\n");
+	printf("  --palette-hqr <file>  Palette source archive (default: input archive)\n");
+	printf("  --palette-index <n>   Palette entry index for all images/models\n");
+	printf("  --lba1          LBA 1 mode (VOC audio, 16-bit 3D bodies)\n");
+	printf("  --lba2          LBA 2 mode (WAV audio, 32-bit 3D bodies)\n");
+	printf("  --vox           Treat the archive as a VOX file (extract hidden entries)\n");
+	printf("  -h, --help      Show this help\n");
+}
+
+static bool makeDirectory(const char *path) {
+#ifdef WIN32
+	return _mkdir(path) == 0 || errno == EEXIST;
+#else
+	return mkdir(path, 0755) == 0 || errno == EEXIST;
+#endif
+}
+
+static bool ensureDirectory(const Common::String &path) {
+	char buf[1024];
+	strncpy(buf, path.c_str(), sizeof(buf) - 1);
+	buf[sizeof(buf) - 1] = '\0';
+
+	for (size_t i = 1; buf[i]; i++) {
+		if (buf[i] == '/' || buf[i] == '\\') {
+			buf[i] = '\0';
+			if (!makeDirectory(buf) && errno != EEXIST)
+				return false;
+			buf[i] = '/';
+		}
+	}
+
+	return makeDirectory(buf) || errno == EEXIST;
+}
+
+static uint32 getEntryOffset(const Common::Filename &filename, int32 index) {
+	Common::File file;
+	file.open(filename, "r");
+	if (!file.isOpen())
+		return 0;
+
+	const uint32 headerSize = file.readUint32LE();
+	if ((uint32)index >= headerSize / 4)
+		return 0;
+
+	file.seek(4 + index * 4, SEEK_SET);
+	return file.readUint32LE();
+}
+
+static uint32 getArchiveFileSize(const Common::Filename &filename) {
+	Common::File file;
+	file.open(filename, "r");
+	if (!file.isOpen())
+		return 0;
+
+	const uint32 headerSize = file.readUint32LE();
+	file.seek(headerSize - 4, SEEK_SET);
+	return file.readUint32LE();
+}
+
+static uint32 getNextNonBlankOffset(const Common::Filename &filename, int32 index, int32 numEntries, uint32 fileSize) {
+	for (int32 i = index + 1; i < numEntries; i++) {
+		const uint32 offset = getEntryOffset(filename, i);
+		if (offset != 0)
+			return offset;
+	}
+	return fileSize;
+}
+
+static int32 countHiddenEntries(const Common::Filename &filename, int32 index, int32 numEntries, uint32 fileSize) {
+	const uint32 offset = getEntryOffset(filename, index);
+	if (offset == 0)
+		return 0;
+
+	Common::File file;
+	file.open(filename, "r");
+	if (!file.isOpen())
+		return 0;
+
+	file.seek(offset + 4, SEEK_SET);
+	uint32 compSize = file.readUint32LE();
+
+	uint32 nextOffset = offset + compSize + 10;
+	const uint32 nextNonBlank = getNextNonBlankOffset(filename, index, numEntries, fileSize);
+
+	int32 count = 0;
+	while (nextOffset < nextNonBlank) {
+		count++;
+		file.seek(nextOffset + 4, SEEK_SET);
+		compSize = file.readUint32LE();
+		nextOffset += compSize + 10;
+	}
+
+	return count;
+}
+
+static char detectVoxHeaderByte(const uint8 *data, int32 size) {
+	if (size < 4)
+		return 0;
+	if (data[1] == 'r' && data[2] == 'e' && data[3] == 'a')
+		return 'C';
+	if (data[1] == 'I' && data[2] == 'F' && data[3] == 'F')
+		return 'R';
+	return 0;
+}
+
+static void fixVoxHeader(uint8 *data, int32 size, VoxType voxType) {
+	if (size <= 0)
+		return;
+	if (data[0] != 0x00 && data[0] != 0x01)
+		return;
+
+	char headerByte = 0;
+	if (voxType == VOXT_LBA1)
+		headerByte = 'C';
+	else if (voxType == VOXT_LBA2)
+		headerByte = 'R';
+	else
+		headerByte = detectVoxHeaderByte(data, size);
+
+	if (headerByte)
+		data[0] = headerByte;
+}
+
+static bool loadEntryData(const Common::Filename &filename, int32 index, int32 hiddenIndex, bool isVox,
+		uint8 **data, int32 *size) {
+	*data = nullptr;
+	*size = 0;
+
+	if (isVox)
+		*size = TwinE::HQR::getAllocVoxEntry(data, filename, index, hiddenIndex);
+	else
+		*size = TwinE::HQR::getAllocEntry(data, filename, index);
+
+	return *data != nullptr && *size > 0;
+}
+
+static void loadArchivePalettes(const Common::Filename &filename, int32 numEntries, TwinePalette *palettes) {
+	for (int32 i = 0; i < numEntries; i++) {
+		if (TwinE::HQR::entrySize(filename, i) != 256 * 3)
+			continue;
+
+		uint8 *data = nullptr;
+		if (TwinE::HQR::getAllocEntry(&data, filename, i) != 256 * 3) {
+			free(data);
+			continue;
+		}
+
+		memcpy(palettes[i].data, data, 256 * 3);
+		palettes[i].loaded = true;
+		free(data);
+	}
+}
+
+static bool writeRawEntry(const char *outPath, const uint8 *data, int32 size) {
+	Common::File out;
+	out.open(outPath, "wb");
+	if (!out.isOpen()) {
+		fprintf(stderr, "Unable to open %s for writing\n", outPath);
+		return false;
+	}
+
+	out.write(data, size);
+	return true;
+}
+
+static bool writeConvertedEntry(const uint8 *data, int32 size, int32 entryIndex, bool convert,
+		const TwineConvertContext &ctx, const char *outPath) {
+	if (!convert)
+		return writeRawEntry(outPath, data, size);
+
+	const TwineEntryType type = twineDetectEntryType(data, size, ctx.preferLba1);
+	return twineConvertEntry(data, size, entryIndex, type, ctx, outPath);
+}
+
+static bool isVoxExtension(const Common::Filename &filename) {
+	return scumm_stricmp(filename.getExtension().c_str(), "vox") == 0;
+}
+
+static void buildOutputBasename(char *outPath, size_t outPathSize, const char *outDir, int32 index, int32 hiddenIndex) {
+	if (hiddenIndex > 0)
+		snprintf(outPath, outPathSize, "%s/%04d_%02d", outDir, index, hiddenIndex);
+	else
+		snprintf(outPath, outPathSize, "%s/%04d", outDir, index);
+}
+
+static bool loadRawFile(const Common::Filename &filename, uint8 **data, int32 *size) {
+	Common::File file;
+	file.open(filename, "r");
+	if (!file.isOpen())
+		return false;
+
+	*size = (int32)file.size();
+	if (*size <= 0)
+		return false;
+
+	*data = (uint8 *)malloc(*size);
+	if (!*data)
+		return false;
+
+	file.read_throwsOnError(*data, *size);
+	return true;
+}
+
+static bool isLikelyHqrArchive(const Common::Filename &filename) {
+	Common::File file;
+	file.open(filename, "r");
+	if (!file.isOpen())
+		return false;
+
+	const uint32 fileSize = file.size();
+	if (fileSize < 12)
+		return false;
+
+	const uint32 headerSize = file.readUint32LE();
+	if (headerSize < 8 || headerSize > fileSize || (headerSize % 4) != 0)
+		return false;
+
+	const int32 entries = (int32)(headerSize / 4) - 1;
+	if (entries <= 0)
+		return false;
+
+	file.seek(4, SEEK_SET);
+	for (int32 i = 0; i < entries && i < 8; ++i) {
+		const uint32 offset = file.readUint32LE();
+		if (offset == 0)
+			continue;
+		if (offset < headerSize || offset > fileSize)
+			return false;
+	}
+
+	file.seek(headerSize - 4, SEEK_SET);
+	const uint32 endOffset = file.readUint32LE();
+	if (endOffset < headerSize || endOffset > fileSize)
+		return false;
+
+	return true;
+}
+
+static bool extractRawFile(const Common::Filename &input, const char *outDir, bool convert,
+		const TwineConvertContext &convertCtx) {
+	uint8 *data = nullptr;
+	int32 size = 0;
+	if (!loadRawFile(input, &data, &size)) {
+		fprintf(stderr, "Unable to read %s\n", input.getFullPath().c_str());
+		return false;
+	}
+
+	char outPath[1024];
+	const Common::String baseName = input.getName().c_str();
+	snprintf(outPath, sizeof(outPath), "%s/%s", outDir, baseName.c_str());
+
+	bool ok = true;
+	if (convert) {
+		if (!writeConvertedEntry(data, size, 0, true, convertCtx, outPath))
+			ok = false;
+	} else {
+		snprintf(outPath + strlen(outPath), sizeof(outPath) - strlen(outPath), ".bin");
+		printf("Extracting %s -> %s (%d bytes)\n", input.getFullName().c_str(), outPath, size);
+		if (!writeRawEntry(outPath, data, size))
+			ok = false;
+	}
+
+	free(data);
+	return ok;
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+	VoxType voxType = VOXT_NONE;
+	bool voxForced = false;
+	bool convert = false;
+	bool preferLba1 = true;
+	int fixedPaletteIndex = -1;
+	const char *paletteHqrPath = nullptr;
+	int argi = 1;
+
+	while (argi < argc) {
+		if (!strcmp(argv[argi], "-h") || !strcmp(argv[argi], "--help")) {
+			printHelp(argv[0]);
+			return 0;
+		}
+		if (!strcmp(argv[argi], "--convert")) {
+			convert = true;
+			argi++;
+			continue;
+		}
+		if (!strcmp(argv[argi], "--palette-hqr")) {
+			if (argi + 1 >= argc) {
+				fprintf(stderr, "--palette-hqr requires an argument\n");
+				return -1;
+			}
+			paletteHqrPath = argv[++argi];
+			argi++;
+			continue;
+		}
+		if (!strcmp(argv[argi], "--palette-index")) {
+			if (argi + 1 >= argc) {
+				fprintf(stderr, "--palette-index requires an argument\n");
+				return -1;
+			}
+			fixedPaletteIndex = atoi(argv[++argi]);
+			argi++;
+			continue;
+		}
+		if (!strcmp(argv[argi], "--lba1")) {
+			voxType = VOXT_LBA1;
+			preferLba1 = true;
+			argi++;
+			continue;
+		}
+		if (!strcmp(argv[argi], "--lba2")) {
+			voxType = VOXT_LBA2;
+			preferLba1 = false;
+			argi++;
+			continue;
+		}
+		if (!strcmp(argv[argi], "--vox")) {
+			voxForced = true;
+			argi++;
+			continue;
+		}
+		break;
+	}
+
+	if (argc - argi < 2) {
+		printHelp(argv[0]);
+		return -1;
+	}
+
+	const Common::Filename input(argv[argi]);
+	const char *outDir = argv[argi + 1];
+	int singleIndex = -1;
+	if (argc - argi >= 3)
+		singleIndex = atoi(argv[argi + 2]);
+
+	if (!input.exists()) {
+		fprintf(stderr, "File not found: %s\n", input.getFullPath().c_str());
+		return -1;
+	}
+
+	if (!ensureDirectory(outDir)) {
+		fprintf(stderr, "Unable to create output directory: %s\n", outDir);
+		return -1;
+	}
+
+	const bool isVox = voxForced || isVoxExtension(input);
+
+	if (!isVox && !isLikelyHqrArchive(input)) {
+		TwineConvertContext convertCtx;
+		convertCtx.archivePalettes = nullptr;
+		convertCtx.numEntries = 0;
+		convertCtx.externalPalette = nullptr;
+		convertCtx.fixedPaletteIndex = fixedPaletteIndex;
+		convertCtx.preferLba1 = preferLba1;
+
+		TwinePalette externalPalette;
+		if (paletteHqrPath) {
+			const Common::Filename paletteFile(paletteHqrPath);
+			if (paletteFile.exists()) {
+				const int32 paletteEntries = TwinE::HQR::numEntries(paletteFile);
+				TwinePalette *externalPalettes = new TwinePalette[paletteEntries];
+				loadArchivePalettes(paletteFile, paletteEntries, externalPalettes);
+				if (fixedPaletteIndex >= 0 && fixedPaletteIndex < paletteEntries &&
+					externalPalettes[fixedPaletteIndex].loaded)
+					externalPalette = externalPalettes[fixedPaletteIndex];
+				else if (externalPalettes[0].loaded)
+					externalPalette = externalPalettes[0];
+				convertCtx.externalPalette = externalPalette.loaded ? &externalPalette : nullptr;
+				delete[] externalPalettes;
+			}
+		}
+
+		const bool failed = !extractRawFile(input, outDir, convert, convertCtx);
+		return failed ? 1 : 0;
+	}
+
+	const int32 numEntries = TwinE::HQR::numEntries(input);
+	if (numEntries <= 0) {
+		fprintf(stderr, "No entries found in %s\n", input.getFullName().c_str());
+		return -1;
+	}
+
+	TwinePalette *archivePalettes = new TwinePalette[numEntries];
+	loadArchivePalettes(input, numEntries, archivePalettes);
+
+	TwinePalette externalPalette;
+	if (paletteHqrPath) {
+		const Common::Filename paletteFile(paletteHqrPath);
+		if (!paletteFile.exists()) {
+			fprintf(stderr, "Palette archive not found: %s\n", paletteHqrPath);
+			delete[] archivePalettes;
+			return -1;
+		}
+		const int32 paletteEntries = TwinE::HQR::numEntries(paletteFile);
+		TwinePalette *externalPalettes = new TwinePalette[paletteEntries];
+		loadArchivePalettes(paletteFile, paletteEntries, externalPalettes);
+		if (fixedPaletteIndex >= 0 && fixedPaletteIndex < paletteEntries && externalPalettes[fixedPaletteIndex].loaded)
+			externalPalette = externalPalettes[fixedPaletteIndex];
+		else if (externalPalettes[0].loaded)
+			externalPalette = externalPalettes[0];
+		delete[] externalPalettes;
+	}
+
+	TwineConvertContext convertCtx;
+	convertCtx.archivePalettes = archivePalettes;
+	convertCtx.numEntries = numEntries;
+	convertCtx.externalPalette = externalPalette.loaded ? &externalPalette : nullptr;
+	convertCtx.fixedPaletteIndex = fixedPaletteIndex;
+	convertCtx.preferLba1 = preferLba1;
+
+	if (convert && twineIsIleFilename(input)) {
+		const bool ok = twineConvertIsland(input, outDir, convertCtx);
+		delete[] archivePalettes;
+		return ok ? 0 : 1;
+	}
+
+	const uint32 fileSize = getArchiveFileSize(input);
+
+	const int32 start = singleIndex >= 0 ? singleIndex : 0;
+	const int32 end = singleIndex >= 0 ? singleIndex : numEntries - 1;
+
+	if (singleIndex >= numEntries) {
+		fprintf(stderr, "Invalid entry index %d (max %d)\n", singleIndex, numEntries - 1);
+		delete[] archivePalettes;
+		return -1;
+	}
+
+	char outPath[1024];
+	bool failed = false;
+
+	for (int32 i = start; i <= end; i++) {
+		const uint32 offset = getEntryOffset(input, i);
+		if (offset == 0) {
+			printf("Skipping blank entry %d\n", i);
+			continue;
+		}
+
+		const int32 uncompressedSize = TwinE::HQR::entrySize(input, i);
+		if (uncompressedSize <= 0) {
+			printf("Skipping empty entry %d\n", i);
+			continue;
+		}
+
+		if (isVox) {
+			const int32 hiddenCount = countHiddenEntries(input, i, numEntries, fileSize);
+			for (int32 h = 0; h <= hiddenCount; h++) {
+				uint8 *data = nullptr;
+				int32 size = 0;
+				if (!loadEntryData(input, i, h, true, &data, &size)) {
+					failed = true;
+					continue;
+				}
+
+				fixVoxHeader(data, size, voxType);
+				buildOutputBasename(outPath, sizeof(outPath), outDir, i, h);
+
+				if (convert) {
+					if (!writeConvertedEntry(data, size, i, true, convertCtx, outPath))
+						failed = true;
+				} else {
+					snprintf(outPath + strlen(outPath), sizeof(outPath) - strlen(outPath), ".bin");
+					printf("Extracting entry %d -> %s (%d bytes)\n", i, outPath, size);
+					if (!writeRawEntry(outPath, data, size))
+						failed = true;
+				}
+
+				free(data);
+			}
+		} else {
+			uint8 *data = nullptr;
+			int32 size = 0;
+			if (!loadEntryData(input, i, 0, false, &data, &size)) {
+				failed = true;
+				continue;
+			}
+
+			buildOutputBasename(outPath, sizeof(outPath), outDir, i, 0);
+
+			if (convert) {
+				if (!writeConvertedEntry(data, size, i, true, convertCtx, outPath))
+					failed = true;
+			} else {
+				snprintf(outPath + strlen(outPath), sizeof(outPath) - strlen(outPath), ".bin");
+				printf("Extracting entry %d -> %s (%d bytes)\n", i, outPath, size);
+				if (!writeRawEntry(outPath, data, size))
+					failed = true;
+			}
+
+			free(data);
+		}
+	}
+
+	delete[] archivePalettes;
+	return failed ? 1 : 0;
+}
diff --git a/engines/twine/extract_twine_convert.cpp b/engines/twine/extract_twine_convert.cpp
new file mode 100644
index 00000000..6e49875e
--- /dev/null
+++ b/engines/twine/extract_twine_convert.cpp
@@ -0,0 +1,792 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "engines/twine/extract_twine_convert.h"
+
+#include "common/endian.h"
+#include "common/file.h"
+#include "common/memstream.h"
+#include "common/util.h"
+#include "engines/twine/parser/body.h"
+#include "sound/voc.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef USE_PNG
+#include <png.h>
+#endif
+
+namespace {
+
+static const int kScreenWidth = 640;
+static const int kScreenHeight = 480;
+
+template<typename T>
+static inline T extractBits(T value, uint8 offset, uint8 numBits) {
+	return (((T(1) << numBits) - 1) & (value >> offset));
+}
+
+static bool isCreativeVoc(const uint8 *data, int32 size) {
+	return size >= 20 && !memcmp(data, "Creative Voice File", 19);
+}
+
+static bool isRiffWav(const uint8 *data, int32 size) {
+	if (size < 12)
+		return false;
+	if (!memcmp(data, "RIFF", 4) && !memcmp(data + 8, "WAVE", 4))
+		return true;
+	return data[1] == 'I' && data[2] == 'F' && data[3] == 'F' && !memcmp(data + 8, "WAVE", 4);
+}
+
+static bool looksLikeSpriteHeader(const uint8 *data, int32 size) {
+	if (size < 12)
+		return false;
+
+	const uint32 offset1 = READ_LE_UINT32(data);
+	const uint32 offset2 = READ_LE_UINT32(data + 4);
+	if (offset1 < 8 || offset2 <= offset1 || offset2 > (uint32)size)
+		return false;
+
+	const uint8 width = data[offset1];
+	const uint8 height = data[offset1 + 1];
+	return width > 0 && height > 0;
+}
+
+static bool looksLikeBrickSprite(const uint8 *data, int32 size) {
+	if (size < 4)
+		return false;
+
+	const uint8 width = data[0];
+	const uint8 height = data[1];
+	if (width == 0 || height == 0 || width > 64 || height > 64)
+		return false;
+
+	Common::MemoryReadStream stream(data, size);
+	stream.readByte();
+	stream.readByte();
+	stream.readByte();
+	stream.readByte();
+	const uint8 numRuns = stream.readByte();
+	if (numRuns == 0 || stream.err())
+		return false;
+
+	return true;
+}
+
+struct DecodedImage {
+	int width;
+	int height;
+	uint8 *pixels;
+
+	DecodedImage() : width(0), height(0), pixels(nullptr) {}
+
+	~DecodedImage() {
+		free(pixels);
+	}
+};
+
+static bool decodeSpriteAt(Common::SeekableReadStream &stream, int32 size, uint32 offset, DecodedImage &image) {
+	if (!stream.seek(offset))
+		return false;
+
+	const int width = stream.readByte();
+	const int height = stream.readByte();
+	if (width <= 0 || height <= 0)
+		return false;
+
+	stream.readByte();
+	stream.readByte();
+
+	image.width = width;
+	image.height = height;
+	image.pixels = (uint8 *)calloc(width * height, 1);
+	if (!image.pixels)
+		return false;
+
+	for (int y = 0; y < height; ++y) {
+		if (stream.pos() >= (uint32)size)
+			return false;
+
+		const uint8 numRuns = stream.readByte();
+		int x = 0;
+		for (uint8 run = 0; run < numRuns; ++run) {
+			if (stream.pos() >= (uint32)size)
+				return false;
+
+			const uint8 runSpec = stream.readByte();
+			const uint8 runLength = extractBits(runSpec, 0, 6) + 1;
+			const uint8 type = extractBits(runSpec, 6, 2);
+			if (x + runLength > width)
+				return false;
+
+			if (type == 1) {
+				for (uint8 i = 0; i < runLength; ++i) {
+					if (stream.pos() >= (uint32)size)
+						return false;
+					image.pixels[y * width + x++] = stream.readByte();
+				}
+			} else if (type != 0) {
+				if (stream.pos() >= (uint32)size)
+					return false;
+				const uint8 color = stream.readByte();
+				memset(image.pixels + y * width + x, color, runLength);
+				x += runLength;
+			} else {
+				x += runLength;
+			}
+		}
+	}
+
+	return !stream.err();
+}
+
+static bool decodeSpriteEntry(const uint8 *data, int32 size, DecodedImage &image) {
+	Common::MemoryReadStream stream(data, size);
+
+	if (looksLikeSpriteHeader(data, size)) {
+		const uint32 offset1 = stream.readUint32LE();
+		return decodeSpriteAt(stream, size, offset1, image);
+	}
+
+	if (looksLikeBrickSprite(data, size))
+		return decodeSpriteAt(stream, size, 0, image);
+
+	return false;
+}
+
+#ifdef USE_PNG
+static bool writeIndexedPng(const char *outPath, const DecodedImage &image, const TwinePalette &palette) {
+	FILE *fout = fopen(outPath, "wb");
+	if (!fout) {
+		fprintf(stderr, "Unable to open %s for writing\n", outPath);
+		return false;
+	}
+
+	png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+	if (!png) {
+		fclose(fout);
+		return false;
+	}
+
+	png_infop info = png_create_info_struct(png);
+	if (!info) {
+		png_destroy_write_struct(&png, nullptr);
+		fclose(fout);
+		return false;
+	}
+
+	if (setjmp(png_jmpbuf(png))) {
+		png_destroy_write_struct(&png, &info);
+		fclose(fout);
+		return false;
+	}
+
+	png_init_io(png, fout);
+	png_set_IHDR(png, info, image.width, image.height, 8, PNG_COLOR_TYPE_PALETTE,
+		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+	png_color pngPalette[256];
+	memset(pngPalette, 0, sizeof(pngPalette));
+	for (int i = 0; i < 256; ++i) {
+		pngPalette[i].red = palette.data[i * 3 + 0];
+		pngPalette[i].green = palette.data[i * 3 + 1];
+		pngPalette[i].blue = palette.data[i * 3 + 2];
+	}
+	png_set_PLTE(png, info, pngPalette, 256);
+
+	png_byte trans = 0;
+	png_set_tRNS(png, info, &trans, 1, nullptr);
+
+	png_write_info(png, info);
+
+	png_bytep *rowPointers = (png_bytep *)malloc(sizeof(png_bytep) * image.height);
+	if (!rowPointers) {
+		png_destroy_write_struct(&png, &info);
+		fclose(fout);
+		return false;
+	}
+
+	for (int y = 0; y < image.height; ++y)
+		rowPointers[y] = image.pixels + y * image.width;
+
+	png_write_image(png, rowPointers);
+	png_write_end(png, nullptr);
+
+	free(rowPointers);
+	png_destroy_write_struct(&png, &info);
+	fclose(fout);
+	return true;
+}
+#endif
+
+static bool writePcmWav(FILE *fout, const void *samples, uint32 dataSize, uint32 sampleRate,
+		uint16 bitsPerSample, uint16 numChannels) {
+	const uint16 blockAlign = numChannels * bitsPerSample / 8;
+	const uint32 byteRate = sampleRate * blockAlign;
+	const uint16 audioFormat = 1;
+	const uint32 riffSize = 36 + dataSize;
+
+	fwrite("RIFF", 1, 4, fout);
+	fwrite(&riffSize, 4, 1, fout);
+	fwrite("WAVE", 1, 4, fout);
+	fwrite("fmt ", 1, 4, fout);
+
+	const uint32 fmtChunkSize = 16;
+	fwrite(&fmtChunkSize, 4, 1, fout);
+	fwrite(&audioFormat, 2, 1, fout);
+	fwrite(&numChannels, 2, 1, fout);
+	fwrite(&sampleRate, 4, 1, fout);
+	fwrite(&byteRate, 4, 1, fout);
+	fwrite(&blockAlign, 2, 1, fout);
+	fwrite(&bitsPerSample, 2, 1, fout);
+
+	fwrite("data", 1, 4, fout);
+	fwrite(&dataSize, 4, 1, fout);
+	fwrite(samples, 1, dataSize, fout);
+	return !ferror(fout);
+}
+
+static const int16 kImaStepTable[89] = {
+	7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66,
+	73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
+	449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878,
+	2066, 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132,
+	7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385,
+	24623, 27086, 29794, 32767
+};
+
+static const int kImaIndexTable[16] = {
+	-1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8
+};
+
+static int16 *decodeImaAdpcm(const uint8 *adpcmData, int32 adpcmSize, int32 blockAlign, int32 *outSamples) {
+	if (blockAlign < 8 || adpcmSize < blockAlign) {
+		*outSamples = 0;
+		return nullptr;
+	}
+
+	const int32 samplesPerBlock = (blockAlign - 4) * 2 + 1;
+	const int32 numBlocks = adpcmSize / blockAlign;
+	const int32 remainder = adpcmSize % blockAlign;
+	int32 totalSamples = numBlocks * samplesPerBlock;
+	if (remainder >= 8)
+		totalSamples += (remainder - 4) * 2 + 1;
+
+	int16 *pcm = (int16 *)malloc(sizeof(int16) * totalSamples);
+	if (!pcm) {
+		*outSamples = 0;
+		return nullptr;
+	}
+
+	int32 outIdx = 0;
+	const uint8 *src = adpcmData;
+	int32 bytesLeft = adpcmSize;
+
+	while (bytesLeft >= 8) {
+		const int32 blockSize = bytesLeft >= blockAlign ? blockAlign : bytesLeft;
+		int16 predictor = (int16)(src[0] | (src[1] << 8));
+		int stepIndex = src[2];
+		if (stepIndex < 0)
+			stepIndex = 0;
+		if (stepIndex > 88)
+			stepIndex = 88;
+
+		pcm[outIdx++] = predictor;
+		for (int32 i = 4; i < blockSize && outIdx < totalSamples; ++i) {
+			for (int nibbleIdx = 0; nibbleIdx < 2 && outIdx < totalSamples; ++nibbleIdx) {
+				const int nibble = (nibbleIdx == 0) ? (src[i] & 0x0F) : ((src[i] >> 4) & 0x0F);
+				const int step = kImaStepTable[stepIndex];
+				int diff = step >> 3;
+				if (nibble & 1)
+					diff += step >> 2;
+				if (nibble & 2)
+					diff += step >> 1;
+				if (nibble & 4)
+					diff += step;
+				if (nibble & 8)
+					diff = -diff;
+
+				int sample = (int)predictor + diff;
+				if (sample > 32767)
+					sample = 32767;
+				if (sample < -32768)
+					sample = -32768;
+				predictor = (int16)sample;
+				pcm[outIdx++] = predictor;
+
+				stepIndex += kImaIndexTable[nibble];
+				if (stepIndex < 0)
+					stepIndex = 0;
+				if (stepIndex > 88)
+					stepIndex = 88;
+			}
+		}
+
+		src += blockSize;
+		bytesLeft -= blockSize;
+	}
+
+	*outSamples = outIdx;
+	return pcm;
+}
+
+struct WavPayload {
+	const uint8 *data;
+	int32 size;
+	uint32 sampleRate;
+	uint16 channels;
+	uint16 bitsPerSample;
+	uint16 formatTag;
+	int32 blockAlign;
+};
+
+static bool parseWavPayload(const uint8 *buffer, int32 sizeBytes, WavPayload &payload) {
+	payload.data = buffer;
+	payload.size = sizeBytes;
+	payload.sampleRate = 11025;
+	payload.channels = 1;
+	payload.bitsPerSample = 8;
+	payload.formatTag = 1;
+	payload.blockAlign = 1;
+
+	if (sizeBytes < 12)
+		return false;
+
+	if (!isRiffWav(buffer, sizeBytes))
+		return false;
+
+	int32 pos = 12;
+	while (pos + 8 <= sizeBytes) {
+		const int32 chunkSize = (int32)READ_LE_UINT32(buffer + pos + 4);
+		if (!memcmp(buffer + pos, "fmt ", 4) && chunkSize >= 16 && pos + 8 + 16 <= sizeBytes) {
+			const uint8 *fmt = buffer + pos + 8;
+			payload.formatTag = READ_LE_UINT16(fmt);
+			payload.channels = READ_LE_UINT16(fmt + 2);
+			payload.sampleRate = READ_LE_UINT32(fmt + 4);
+			payload.blockAlign = (int32)READ_LE_UINT16(fmt + 12);
+			payload.bitsPerSample = READ_LE_UINT16(fmt + 14);
+		}
+
+		if (!memcmp(buffer + pos, "data", 4) && chunkSize > 0 && pos + 8 + chunkSize <= sizeBytes) {
+			payload.data = buffer + pos + 8;
+			payload.size = chunkSize;
+			return true;
+		}
+
+		pos += 8 + ((chunkSize + 1) & ~1);
+	}
+
+	return false;
+}
+
+static bool isXmidi(const uint8 *data, int32 size) {
+	if (size < 12)
+		return false;
+	if (!memcmp(data, "FORM", 4) && size >= 8 && !memcmp(data + 8, "XDIR", 4))
+		return true;
+	if (!memcmp(data, "XMID", 4))
+		return true;
+	return false;
+}
+
+static bool looksLikeAnim(const uint8 *data, int32 size) {
+	if (size < 8)
+		return false;
+	const uint16 numKeyframes = READ_LE_UINT16(data);
+	const uint16 numBones = READ_LE_UINT16(data + 2);
+	if (numKeyframes == 0 || numKeyframes > 5000 || numBones == 0 || numBones > 256)
+		return false;
+	const uint32 minSize = 8u + numKeyframes * (8u + numBones * 8u);
+	return (uint32)size >= minSize && (uint32)size <= minSize + 256u;
+}
+
+static bool writeRawFile(const char *outPath, const uint8 *data, int32 size) {
+	FILE *fout = fopen(outPath, "wb");
+	if (!fout)
+		return false;
+	fwrite(data, 1, size, fout);
+	const bool ok = !ferror(fout);
+	fclose(fout);
+	return ok;
+}
+
+static bool writePaletteGpl(const char *outPath, const uint8 *data, int32 entryIndex) {
+	FILE *fout = fopen(outPath, "wb");
+	if (!fout) {
+		fprintf(stderr, "Unable to open %s for writing\n", outPath);
+		return false;
+	}
+
+	fprintf(fout, "GIMP Palette\n");
+	fprintf(fout, "Name: LBA Palette %d\n", entryIndex);
+	fprintf(fout, "#\n");
+
+	for (int i = 0; i < 256; ++i) {
+		fprintf(fout, "%3d %3d %3d  Index %d\n",
+			data[i * 3 + 0], data[i * 3 + 1], data[i * 3 + 2], i);
+	}
+
+	const bool ok = !ferror(fout);
+	fclose(fout);
+	return ok;
+}
+
+#ifdef USE_PNG
+static bool writePaletteStripPng(const char *outPath, const uint8 *data) {
+	FILE *fout = fopen(outPath, "wb");
+	if (!fout) {
+		fprintf(stderr, "Unable to open %s for writing\n", outPath);
+		return false;
+	}
+
+	png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+	if (!png) {
+		fclose(fout);
+		return false;
+	}
+
+	png_infop info = png_create_info_struct(png);
+	if (!info) {
+		png_destroy_write_struct(&png, nullptr);
+		fclose(fout);
+		return false;
+	}
+
+	if (setjmp(png_jmpbuf(png))) {
+		png_destroy_write_struct(&png, &info);
+		fclose(fout);
+		return false;
+	}
+
+	png_init_io(png, fout);
+	png_set_IHDR(png, info, 256, 1, 8, PNG_COLOR_TYPE_RGB,
+		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+	png_write_info(png, info);
+
+	uint8 row[256 * 3];
+	for (int i = 0; i < 256; ++i) {
+		row[i * 3 + 0] = data[i * 3 + 0];
+		row[i * 3 + 1] = data[i * 3 + 1];
+		row[i * 3 + 2] = data[i * 3 + 2];
+	}
+
+	png_bytep rowPointer = row;
+	png_write_image(png, &rowPointer);
+	png_write_end(png, nullptr);
+
+	png_destroy_write_struct(&png, &info);
+	fclose(fout);
+	return true;
+}
+#endif
+
+static bool convertPaletteEntry(const uint8 *data, int32 size, int32 entryIndex, const char *outPath) {
+	if (size != 256 * 3)
+		return false;
+
+	char gplPath[1100];
+	char pngPath[1100];
+	snprintf(gplPath, sizeof(gplPath), "%s.gpl", outPath);
+	snprintf(pngPath, sizeof(pngPath), "%s.png", outPath);
+
+	if (!writePaletteGpl(gplPath, data, entryIndex))
+		return false;
+
+#ifndef USE_PNG
+	fprintf(stderr, "PNG support was not enabled at build time, skipping %s\n", pngPath);
+	printf("Converted entry %d -> %s\n", entryIndex, gplPath);
+	return true;
+#else
+	if (!writePaletteStripPng(pngPath, data))
+		return false;
+	printf("Converted entry %d -> %s (+ %s)\n", entryIndex, gplPath, pngPath);
+	return true;
+#endif
+}
+
+} // namespace
+
+TwineEntryType twineDetectEntryType(const uint8 *data, int32 size, bool preferLba1) {
+	if (!data || size <= 0)
+		return TWINE_ENTRY_RAW;
+
+	if (size == 256 * 3)
+		return TWINE_ENTRY_PALETTE;
+
+	if (size == 131884)
+		return TWINE_ENTRY_SHADING_PALETTE;
+
+	if (isCreativeVoc(data, size))
+		return TWINE_ENTRY_VOC;
+
+	if (isRiffWav(data, size))
+		return TWINE_ENTRY_WAV;
+
+	if (isXmidi(data, size))
+		return TWINE_ENTRY_XMIDI;
+
+	if (twineLooksLikeSjisFont(data, size))
+		return TWINE_ENTRY_FONT_SJIS;
+
+	if (twineLooksLikeMsDosFont(data, size))
+		return TWINE_ENTRY_FONT_MSDOS;
+
+	if (size == kScreenWidth * kScreenHeight)
+		return TWINE_ENTRY_SCREEN;
+
+	if (size == 256 * 256)
+		return TWINE_ENTRY_TEXTURE;
+
+	if (looksLikeAnim(data, size))
+		return TWINE_ENTRY_ANIM;
+
+	if (twineLooksLikeLbaFont(data, size))
+		return TWINE_ENTRY_FONT;
+
+	TwinE::BodyData body;
+	bool isLba1 = false;
+	if (twineTryParseBody(data, size, preferLba1, body, isLba1))
+		return TWINE_ENTRY_BODY;
+
+	if (looksLikeSpriteHeader(data, size) || looksLikeBrickSprite(data, size))
+		return TWINE_ENTRY_SPRITE;
+
+	return TWINE_ENTRY_RAW;
+}
+
+bool twineResolvePalette(const TwineConvertContext &ctx, int32 entryIndex, TwinePalette &out) {
+	if (ctx.archivePalettes && ctx.fixedPaletteIndex >= 0 && ctx.fixedPaletteIndex < ctx.numEntries &&
+		ctx.archivePalettes[ctx.fixedPaletteIndex].loaded) {
+		out = ctx.archivePalettes[ctx.fixedPaletteIndex];
+		return true;
+	}
+
+	if (ctx.archivePalettes && entryIndex + 1 < ctx.numEntries &&
+		ctx.archivePalettes[entryIndex + 1].loaded) {
+		out = ctx.archivePalettes[entryIndex + 1];
+		return true;
+	}
+
+	if (ctx.archivePalettes && ctx.numEntries > 0 && ctx.archivePalettes[0].loaded) {
+		out = ctx.archivePalettes[0];
+		return true;
+	}
+
+	if (ctx.externalPalette && ctx.externalPalette->loaded) {
+		out = *ctx.externalPalette;
+		return true;
+	}
+
+	return false;
+}
+
+static bool convertEntryToPng(const uint8 *data, int32 size, TwineEntryType type, const TwinePalette &palette, const char *outPath) {
+#ifndef USE_PNG
+	(void)data;
+	(void)size;
+	(void)type;
+	(void)palette;
+	(void)outPath;
+	fprintf(stderr, "PNG support was not enabled at build time\n");
+	return false;
+#else
+	if (!palette.loaded) {
+		fprintf(stderr, "No palette available for %s\n", outPath);
+		return false;
+	}
+
+	DecodedImage image;
+	if (type == TWINE_ENTRY_SCREEN) {
+		image.width = kScreenWidth;
+		image.height = kScreenHeight;
+		image.pixels = (uint8 *)malloc(kScreenWidth * kScreenHeight);
+		if (!image.pixels)
+			return false;
+		memcpy(image.pixels, data, kScreenWidth * kScreenHeight);
+	} else if (type == TWINE_ENTRY_SPRITE || type == TWINE_ENTRY_TEXTURE) {
+		if (type == TWINE_ENTRY_TEXTURE) {
+			image.width = 256;
+			image.height = 256;
+			image.pixels = (uint8 *)malloc(256 * 256);
+			if (!image.pixels)
+				return false;
+			memcpy(image.pixels, data, 256 * 256);
+		} else if (!decodeSpriteEntry(data, size, image)) {
+			return false;
+		}
+	} else {
+		return false;
+	}
+
+	const bool ok = writeIndexedPng(outPath, image, palette);
+	return ok;
+#endif
+}
+
+static bool convertEntryToWav(const uint8 *data, int32 size, const char *outPath) {
+	FILE *fout = fopen(outPath, "wb");
+	if (!fout) {
+		fprintf(stderr, "Unable to open %s for writing\n", outPath);
+		return false;
+	}
+
+	bool ok = false;
+
+	if (isCreativeVoc(data, size)) {
+		char tempName[1024];
+		snprintf(tempName, sizeof(tempName), "%s.voctmp", outPath);
+		Common::File tempOut;
+		tempOut.open(tempName, "wb");
+		if (!tempOut.isOpen()) {
+			fclose(fout);
+			return false;
+		}
+		tempOut.write(data, size);
+		tempOut.close();
+
+		Common::File tempIn;
+		tempIn.open(tempName, "rb");
+		int pcmSize = 0;
+		int rate = 0;
+		byte *pcm = Audio::loadVOCFromStream(tempIn, pcmSize, rate);
+		tempIn.close();
+		remove(tempName);
+
+		if (pcm && pcmSize > 0)
+			ok = writePcmWav(fout, pcm, pcmSize, rate, 8, 1);
+		free(pcm);
+	} else if (isRiffWav(data, size)) {
+		WavPayload payload;
+		if (!parseWavPayload(data, size, payload)) {
+			fclose(fout);
+			return false;
+		}
+
+		if (payload.formatTag == 1) {
+			ok = writePcmWav(fout, payload.data, payload.size, payload.sampleRate,
+				payload.bitsPerSample, payload.channels);
+		} else if (payload.formatTag == 17) {
+			int32 numSamples = 0;
+			int16 *pcm = decodeImaAdpcm(payload.data, payload.size, payload.blockAlign, &numSamples);
+			if (pcm && numSamples > 0) {
+				ok = writePcmWav(fout, pcm, numSamples * sizeof(int16), payload.sampleRate, 16, payload.channels);
+				free(pcm);
+			}
+		} else {
+			fprintf(stderr, "Unsupported WAVE compression format %u in %s\n", payload.formatTag, outPath);
+		}
+	}
+
+	fclose(fout);
+	if (!ok)
+		remove(outPath);
+	return ok;
+}
+
+const char *twineConvertedExtension(TwineEntryType type) {
+	switch (type) {
+	case TWINE_ENTRY_SCREEN:
+	case TWINE_ENTRY_TEXTURE:
+	case TWINE_ENTRY_SPRITE:
+	case TWINE_ENTRY_FONT:
+	case TWINE_ENTRY_FONT_SJIS:
+	case TWINE_ENTRY_FONT_MSDOS:
+		return "png";
+	case TWINE_ENTRY_BODY:
+		return "obj";
+	case TWINE_ENTRY_VOC:
+	case TWINE_ENTRY_WAV:
+		return "wav";
+	case TWINE_ENTRY_XMIDI:
+		return "xmi";
+	case TWINE_ENTRY_ANIM:
+		return "anim";
+	case TWINE_ENTRY_PALETTE:
+		return "gpl";
+	case TWINE_ENTRY_SHADING_PALETTE:
+		return "osp";
+	default:
+		return "bin";
+	}
+}
+
+bool twineConvertEntry(const uint8 *data, int32 size, int32 entryIndex, TwineEntryType type,
+		const TwineConvertContext &ctx, const char *outPath) {
+	char convertedPath[1100];
+	snprintf(convertedPath, sizeof(convertedPath), "%s.%s", outPath, twineConvertedExtension(type));
+
+	switch (type) {
+	case TWINE_ENTRY_PALETTE:
+		if (!convertPaletteEntry(data, size, entryIndex, outPath))
+			return false;
+		return true;
+	case TWINE_ENTRY_SCREEN:
+	case TWINE_ENTRY_TEXTURE:
+	case TWINE_ENTRY_SPRITE: {
+		TwinePalette palette;
+		if (!twineResolvePalette(ctx, entryIndex, palette)) {
+			fprintf(stderr, "No palette available for image entry %d\n", entryIndex);
+			return false;
+		}
+		if (!convertEntryToPng(data, size, type, palette, convertedPath))
+			return false;
+		printf("Converted entry %d -> %s\n", entryIndex, convertedPath);
+		return true;
+	}
+	case TWINE_ENTRY_FONT:
+	case TWINE_ENTRY_FONT_SJIS:
+	case TWINE_ENTRY_FONT_MSDOS:
+		if (!twineConvertFontToPng(data, size, type, outPath))
+			return false;
+		printf("Converted entry %d -> %s.png\n", entryIndex, outPath);
+		return true;
+	case TWINE_ENTRY_BODY: {
+		TwinePalette palette;
+		if (!twineResolvePalette(ctx, entryIndex, palette))
+			palette = TwinePalette();
+		if (!twineConvertBodyToObj(data, size, ctx.preferLba1, palette, outPath))
+			return false;
+		printf("Converted entry %d -> %s.obj (+ .mtl)\n", entryIndex, outPath);
+		return true;
+	}
+	case TWINE_ENTRY_VOC:
+	case TWINE_ENTRY_WAV:
+		if (!convertEntryToWav(data, size, convertedPath))
+			return false;
+		printf("Converted entry %d -> %s\n", entryIndex, convertedPath);
+		return true;
+	case TWINE_ENTRY_XMIDI:
+	case TWINE_ENTRY_ANIM:
+	case TWINE_ENTRY_SHADING_PALETTE:
+		if (!writeRawFile(convertedPath, data, size))
+			return false;
+		printf("Extracted entry %d -> %s\n", entryIndex, convertedPath);
+		return true;
+	default:
+		snprintf(convertedPath, sizeof(convertedPath), "%s.bin", outPath);
+		if (!writeRawFile(convertedPath, data, size))
+			return false;
+		printf("Extracting entry %d -> %s (unrecognized format)\n", entryIndex, convertedPath);
+		return true;
+	}
+}
diff --git a/engines/twine/extract_twine_convert.h b/engines/twine/extract_twine_convert.h
new file mode 100644
index 00000000..65595356
--- /dev/null
+++ b/engines/twine/extract_twine_convert.h
@@ -0,0 +1,94 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ENGINES_TWINE_EXTRACT_TWINE_CONVERT_H
+#define ENGINES_TWINE_EXTRACT_TWINE_CONVERT_H
+
+#include "common/scummsys.h"
+#include "common/file.h"
+
+namespace TwinE {
+class BodyData;
+}
+
+struct TwinePalette {
+	uint8 data[256 * 3];
+	bool loaded;
+
+	TwinePalette() : loaded(false) {
+		memset(data, 0, sizeof(data));
+	}
+};
+
+enum TwineEntryType {
+	TWINE_ENTRY_RAW = 0,
+	TWINE_ENTRY_PALETTE,
+	TWINE_ENTRY_SCREEN,
+	TWINE_ENTRY_TEXTURE,
+	TWINE_ENTRY_SHADING_PALETTE,
+	TWINE_ENTRY_SPRITE,
+	TWINE_ENTRY_BODY,
+	TWINE_ENTRY_ANIM,
+	TWINE_ENTRY_VOC,
+	TWINE_ENTRY_WAV,
+	TWINE_ENTRY_XMIDI,
+	TWINE_ENTRY_TEXT,
+	TWINE_ENTRY_FONT,
+	TWINE_ENTRY_FONT_SJIS,
+	TWINE_ENTRY_FONT_MSDOS
+};
+
+struct TwineConvertContext {
+	const TwinePalette *archivePalettes;
+	int32 numEntries;
+	const TwinePalette *externalPalette;
+	int32 fixedPaletteIndex;
+	bool preferLba1;
+};
+
+TwineEntryType twineDetectEntryType(const uint8 *data, int32 size, bool preferLba1);
+bool twineResolvePalette(const TwineConvertContext &ctx, int32 entryIndex, TwinePalette &out);
+bool twineConvertEntry(const uint8 *data, int32 size, int32 entryIndex, TwineEntryType type,
+		const TwineConvertContext &ctx, const char *outPath);
+const char *twineConvertedExtension(TwineEntryType type);
+
+struct TwineBodyTransform {
+	int32 posX;
+	int32 posY;
+	int32 posZ;
+	int32 beta;
+};
+
+bool twineTryParseBody(const uint8 *data, int32 size, bool preferLba1, TwinE::BodyData &body, bool &isLba1);
+bool twineAppendBodyToObj(const uint8 *data, int32 size, bool preferLba1, const TwinePalette &palette,
+		FILE *obj, FILE *mtl, int &vertexBase, int &materialId, const TwineBodyTransform &xform,
+		const char *objectName, bool materialsWritten[256]);
+bool twineConvertBodyToObj(const uint8 *data, int32 size, bool preferLba1, const TwinePalette &palette, const char *outPath);
+
+bool twineLooksLikeLbaFont(const uint8 *data, int32 size);
+bool twineLooksLikeSjisFont(const uint8 *data, int32 size);
+bool twineLooksLikeMsDosFont(const uint8 *data, int32 size);
+bool twineConvertFontToPng(const uint8 *data, int32 size, TwineEntryType type, const char *outPath);
+
+bool twineIsIleFilename(const Common::Filename &filename);
+bool twineConvertIsland(const Common::Filename &ileFile, const char *outDir, const TwineConvertContext &ctx);
+
+#endif
diff --git a/engines/twine/extract_twine_font.cpp b/engines/twine/extract_twine_font.cpp
new file mode 100644
index 00000000..892b31ba
--- /dev/null
+++ b/engines/twine/extract_twine_font.cpp
@@ -0,0 +1,400 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "engines/twine/extract_twine_convert.h"
+
+#include "common/endian.h"
+#include "common/memstream.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef USE_PNG
+#include <png.h>
+#endif
+
+namespace {
+
+static const int kFontAtlasColumns = 16;
+static const int kSjisCharWidth = 24;
+static const int kSjisCharHeight = 24;
+static const int kSjisGlyphCount = 11072;
+static const int kSjisFontSize = kSjisGlyphCount * kSjisCharHeight * (kSjisCharWidth / 8);
+static const int kMsDosFontSize = 256 * 8;
+
+static bool isValidFontGlyphOffset(uint32 offset, int32 size) {
+	if (size < 1028)
+		return false;
+	const uint32 usize = (uint32)size;
+	return offset >= 1024u && offset <= usize - 4u;
+}
+
+static bool decodeLbaFontGlyph(const uint8 *data, int32 size, int character, int cellW, int cellH, uint8 *out) {
+	memset(out, 0, cellW * cellH);
+
+	const uint32 offset = READ_LE_UINT32(data + character * 4);
+	if (!isValidFontGlyphOffset(offset, size))
+		return false;
+
+	Common::MemoryReadStream stream(data, size);
+	if (!stream.seek(offset))
+		return false;
+
+	const uint8 charWidth = stream.readByte();
+	const uint8 sizeY = stream.readByte();
+	stream.readByte();
+	stream.readByte();
+
+	if (charWidth == 0 || sizeY == 0 || charWidth > cellW || sizeY > cellH)
+		return false;
+
+	int tempX = 0;
+	int tempY = 0;
+	for (uint8 fontY = 0; fontY < sizeY; ++fontY) {
+		if (stream.pos() >= (uint32)size)
+			return false;
+
+		uint8 index = stream.readByte();
+		do {
+			if (stream.pos() >= (uint32)size)
+				return false;
+
+			const uint8 jump = stream.readByte();
+			if (--index == 0) {
+				tempY++;
+				tempX = 0;
+				break;
+			}
+
+			if (stream.pos() >= (uint32)size)
+				return false;
+
+			const uint8 number = stream.readByte();
+			tempX += jump;
+			for (uint8 i = 0; i < number; i++) {
+				if (tempX >= 0 && tempX < charWidth && tempY >= 0 && tempY < sizeY)
+					out[tempY * cellW + tempX] = 1;
+				tempX++;
+			}
+
+			if (--index == 0) {
+				tempY++;
+				tempX = 0;
+				break;
+			}
+		} while (true);
+	}
+
+	return true;
+}
+
+static bool measureLbaFontCell(const uint8 *data, int32 size, int &cellW, int &cellH) {
+	cellW = 0;
+	cellH = 0;
+
+	for (int i = 0; i < 256; ++i) {
+		const uint32 offset = READ_LE_UINT32(data + i * 4);
+		if (!isValidFontGlyphOffset(offset, size))
+			continue;
+
+		const uint8 width = data[offset];
+		const uint8 height = data[offset + 1];
+		if (width == 0 || height == 0 || width > 64 || height > 64)
+			continue;
+
+		if (width > cellW)
+			cellW = width;
+		if (height > cellH)
+			cellH = height;
+	}
+
+	return cellW > 0 && cellH > 0;
+}
+
+#ifdef USE_PNG
+static bool writeMonochromePng(const char *outPath, uint8 *pixels, int width, int height) {
+	FILE *fout = fopen(outPath, "wb");
+	if (!fout) {
+		fprintf(stderr, "Unable to open %s for writing\n", outPath);
+		return false;
+	}
+
+	png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+	if (!png) {
+		fclose(fout);
+		return false;
+	}
+
+	png_infop info = png_create_info_struct(png);
+	if (!info) {
+		png_destroy_write_struct(&png, nullptr);
+		fclose(fout);
+		return false;
+	}
+
+	if (setjmp(png_jmpbuf(png))) {
+		png_destroy_write_struct(&png, &info);
+		fclose(fout);
+		return false;
+	}
+
+	png_init_io(png, fout);
+	png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_PALETTE,
+		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+	png_color palette[2];
+	palette[0].red = palette[0].green = palette[0].blue = 0;
+	palette[1].red = palette[1].green = palette[1].blue = 255;
+	png_set_PLTE(png, info, palette, 2);
+
+	png_byte trans = 0;
+	png_set_tRNS(png, info, &trans, 1, nullptr);
+
+	png_write_info(png, info);
+
+	png_bytep *rowPointers = (png_bytep *)malloc(sizeof(png_bytep) * height);
+	if (!rowPointers) {
+		png_destroy_write_struct(&png, &info);
+		fclose(fout);
+		return false;
+	}
+
+	for (int y = 0; y < height; ++y)
+		rowPointers[y] = pixels + y * width;
+
+	png_write_image(png, rowPointers);
+	png_write_end(png, nullptr);
+
+	free(rowPointers);
+	png_destroy_write_struct(&png, &info);
+	fclose(fout);
+	return true;
+}
+#endif
+
+static bool exportLbaFontAtlas(const uint8 *data, int32 size, const char *outPath) {
+#ifndef USE_PNG
+	(void)data;
+	(void)size;
+	(void)outPath;
+	fprintf(stderr, "PNG support was not enabled at build time\n");
+	return false;
+#else
+	int cellW = 0;
+	int cellH = 0;
+	if (!measureLbaFontCell(data, size, cellW, cellH))
+		return false;
+
+	const int atlasW = kFontAtlasColumns * cellW;
+	const int atlasH = kFontAtlasColumns * cellH;
+	uint8 *atlas = (uint8 *)calloc(atlasW * atlasH, 1);
+	if (!atlas)
+		return false;
+
+	uint8 *glyph = (uint8 *)calloc(cellW * cellH, 1);
+	if (!glyph) {
+		free(atlas);
+		return false;
+	}
+
+	for (int ch = 0; ch < 256; ++ch) {
+		if (!decodeLbaFontGlyph(data, size, ch, cellW, cellH, glyph))
+			continue;
+
+		const int col = ch % kFontAtlasColumns;
+		const int row = ch / kFontAtlasColumns;
+		const int dstX = col * cellW;
+		const int dstY = row * cellH;
+
+		for (int y = 0; y < cellH; ++y) {
+			memcpy(atlas + (dstY + y) * atlasW + dstX, glyph + y * cellW, cellW);
+		}
+	}
+
+	const bool ok = writeMonochromePng(outPath, atlas, atlasW, atlasH);
+	free(glyph);
+	free(atlas);
+	return ok;
+#endif
+}
+
+static void decodeSjisGlyph(const uint8 *data, int index, uint8 *out, int cellW, int cellH) {
+	memset(out, 0, cellW * cellH);
+
+	const uint8 *glyphPtr = data + index * (kSjisCharHeight * kSjisCharWidth / 8);
+	for (int fontY = 0; fontY < kSjisCharHeight; ++fontY) {
+		byte bits = 0;
+		int remBits = 0;
+		for (int fontX = 0; fontX < kSjisCharWidth; ++fontX) {
+			if (remBits == 0) {
+				remBits = 8;
+				bits = *glyphPtr++;
+			}
+
+			if (bits & 0x80)
+				out[fontY * cellW + fontX] = 1;
+
+			remBits--;
+			bits <<= 1;
+		}
+	}
+}
+
+static bool exportSjisFontAtlas(const uint8 *data, int32 size, const char *outPath) {
+#ifndef USE_PNG
+	(void)data;
+	(void)size;
+	(void)outPath;
+	fprintf(stderr, "PNG support was not enabled at build time\n");
+	return false;
+#else
+	(void)size;
+
+	const int columns = 104;
+	const int rows = (kSjisGlyphCount + columns - 1) / columns;
+	const int atlasW = columns * kSjisCharWidth;
+	const int atlasH = rows * kSjisCharHeight;
+
+	uint8 *atlas = (uint8 *)calloc(atlasW * atlasH, 1);
+	if (!atlas)
+		return false;
+
+	uint8 *glyph = (uint8 *)calloc(kSjisCharWidth * kSjisCharHeight, 1);
+	if (!glyph) {
+		free(atlas);
+		return false;
+	}
+
+	for (int index = 0; index < kSjisGlyphCount; ++index) {
+		decodeSjisGlyph(data, index, glyph, kSjisCharWidth, kSjisCharHeight);
+
+		const int col = index % columns;
+		const int row = index / columns;
+		const int dstX = col * kSjisCharWidth;
+		const int dstY = row * kSjisCharHeight;
+
+		for (int y = 0; y < kSjisCharHeight; ++y)
+			memcpy(atlas + (dstY + y) * atlasW + dstX, glyph + y * kSjisCharWidth, kSjisCharWidth);
+	}
+
+	const bool ok = writeMonochromePng(outPath, atlas, atlasW, atlasH);
+	free(glyph);
+	free(atlas);
+	return ok;
+#endif
+}
+
+static bool exportMsDosFontAtlas(const uint8 *data, int32 size, const char *outPath) {
+#ifndef USE_PNG
+	(void)data;
+	(void)size;
+	(void)outPath;
+	fprintf(stderr, "PNG support was not enabled at build time\n");
+	return false;
+#else
+	(void)size;
+
+	const int cellW = 8;
+	const int cellH = 8;
+	const int atlasW = kFontAtlasColumns * cellW;
+	const int atlasH = kFontAtlasColumns * cellH;
+	uint8 *atlas = (uint8 *)calloc(atlasW * atlasH, 1);
+	if (!atlas)
+		return false;
+
+	for (int ch = 0; ch < 256; ++ch) {
+		const uint8 *glyph = data + ch * 8;
+		const int col = ch % kFontAtlasColumns;
+		const int row = ch / kFontAtlasColumns;
+		const int dstX = col * cellW;
+		const int dstY = row * cellH;
+
+		for (int y = 0; y < cellH; ++y) {
+			uint8 line = glyph[y];
+			for (int x = 0; x < cellW; ++x) {
+				if (line & (0x80 >> x))
+					atlas[(dstY + y) * atlasW + dstX + x] = 1;
+			}
+		}
+	}
+
+	const bool ok = writeMonochromePng(outPath, atlas, atlasW, atlasH);
+	free(atlas);
+	return ok;
+#endif
+}
+
+} // namespace
+
+bool twineLooksLikeLbaFont(const uint8 *data, int32 size) {
+	if (!data || size < 1024 + 8)
+		return false;
+
+	int validGlyphs = 0;
+	int invalidGlyphs = 0;
+
+	for (int i = 0; i < 256; ++i) {
+		const uint32 offset = READ_LE_UINT32(data + i * 4);
+		if (offset == 0)
+			continue;
+
+		if (!isValidFontGlyphOffset(offset, size)) {
+			invalidGlyphs++;
+			continue;
+		}
+
+		const uint8 width = data[offset];
+		const uint8 height = data[offset + 1];
+		if (width == 0 || height == 0 || width > 64 || height > 64) {
+			invalidGlyphs++;
+			continue;
+		}
+
+		validGlyphs++;
+	}
+
+	return validGlyphs >= 20 && validGlyphs > invalidGlyphs;
+}
+
+bool twineLooksLikeSjisFont(const uint8 *data, int32 size) {
+	return data && size == kSjisFontSize;
+}
+
+bool twineLooksLikeMsDosFont(const uint8 *data, int32 size) {
+	return data && size == kMsDosFontSize;
+}
+
+bool twineConvertFontToPng(const uint8 *data, int32 size, TwineEntryType type, const char *outPath) {
+	char pngPath[1100];
+	snprintf(pngPath, sizeof(pngPath), "%s.png", outPath);
+
+	switch (type) {
+	case TWINE_ENTRY_FONT:
+		return exportLbaFontAtlas(data, size, pngPath);
+	case TWINE_ENTRY_FONT_SJIS:
+		return exportSjisFontAtlas(data, size, pngPath);
+	case TWINE_ENTRY_FONT_MSDOS:
+		return exportMsDosFontAtlas(data, size, pngPath);
+	default:
+		return false;
+	}
+}
diff --git a/engines/twine/extract_twine_island.cpp b/engines/twine/extract_twine_island.cpp
new file mode 100644
index 00000000..ade5aa5a
--- /dev/null
+++ b/engines/twine/extract_twine_island.cpp
@@ -0,0 +1,525 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "engines/twine/extract_twine_convert.h"
+
+#include "common/endian.h"
+#include "common/file.h"
+#include "engines/twine/hqr.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef USE_PNG
+#include <png.h>
+#endif
+
+namespace {
+
+static const int kMapSize = 16;
+static const int kNbCote = 64;
+static const int kCubeWorldSize = 32768;
+static const int kVertexStep = 512;
+static const int kIleMapSize = 256;
+static const int kIleTextureSize = 256 * 256;
+
+static const int kIleEntryMap = 0;
+static const int kIleEntryTexGround = 1;
+static const int kIleEntryTexObj = 2;
+static const int kIleCubeStart = 3;
+static const int kIleCubeStep = 6;
+static const int kIleCubeInf = 0;
+static const int kIleCubeDob = 1;
+static const int kIleCubeGrd = 2;
+static const int kIleCubeY = 4;
+
+static const int kInfoNbDecors = 2;
+static const int kDecorRecordSize = 48;
+static const int kDecInvisible = 1 << 16;
+
+static const int kCodeJeuWater = 1;
+
+struct HalfPoly {
+	uint32 raw;
+
+	explicit HalfPoly(uint32 value) : raw(value) {}
+
+	bool visible() const {
+		const uint8 polyFlag = (raw >> 6) & 3;
+		const uint8 texFlag = (raw >> 4) & 3;
+		return polyFlag + texFlag != 0;
+	}
+
+	bool sens() const {
+		return ((raw >> 13) & 1) != 0;
+	}
+
+	uint8 codeJeu() const {
+		return (raw >> 12) & 0xF;
+	}
+};
+
+struct IslandDecor {
+	int32 body;
+	int32 xworld;
+	int32 yworld;
+	int32 zworld;
+	int32 beta;
+};
+
+struct BodyCacheEntry {
+	uint8 *data;
+	int32 size;
+};
+
+static bool loadEntry(const Common::Filename &file, int32 index, uint8 **data, int32 *size) {
+	*data = nullptr;
+	*size = 0;
+	const int32 entrySize = TwinE::HQR::getAllocEntry(data, file, index);
+	if (entrySize <= 0 || !*data)
+		return false;
+	*size = entrySize;
+	return true;
+}
+
+static int16 readHeight(const uint8 *heights, int dx, int dz) {
+	return (int16)READ_LE_UINT16(heights + (dz * (kNbCote + 1) + dx) * 2);
+}
+
+static void writeVertex(FILE *obj, float x, float y, float z) {
+	fprintf(obj, "v %g %g %g\n", x, y, z);
+}
+
+static void writeFace(FILE *obj, int i0, int i1, int i2) {
+	fprintf(obj, "f %d %d %d\n", i0, i1, i2);
+}
+
+static bool parseDecorRecord(const uint8 *data, int32 size, int offset, IslandDecor &decor) {
+	if (offset + kDecorRecordSize > size)
+		return false;
+
+	decor.body = (int32)READ_LE_UINT32(data + offset);
+	decor.xworld = (int32)READ_LE_UINT32(data + offset + 4);
+	decor.yworld = (int32)READ_LE_UINT32(data + offset + 8);
+	decor.zworld = (int32)READ_LE_UINT32(data + offset + 12);
+	decor.beta = (int32)READ_LE_UINT32(data + offset + 20);
+	return true;
+}
+
+static Common::Filename oblPathFromIle(const Common::Filename &ileFile) {
+	Common::Filename obl = ileFile;
+	obl.setExtension(".OBL");
+	return obl;
+}
+
+static bool loadCachedBody(BodyCacheEntry *cache, int32 cacheSize, const Common::Filename &oblFile,
+		int32 bodyIndex, const uint8 **data, int32 *size) {
+	if (bodyIndex < 0 || bodyIndex >= cacheSize)
+		return false;
+
+	BodyCacheEntry &entry = cache[bodyIndex];
+	if (!entry.data) {
+		const int32 entrySize = TwinE::HQR::getAllocEntry(&entry.data, oblFile, bodyIndex);
+		if (entrySize <= 0 || !entry.data)
+			return false;
+		entry.size = entrySize;
+	}
+
+	*data = entry.data;
+	*size = entry.size;
+	return true;
+}
+
+static void freeBodyCache(BodyCacheEntry *cache, int32 cacheSize) {
+	if (!cache)
+		return;
+	for (int32 i = 0; i < cacheSize; ++i)
+		free(cache[i].data);
+	free(cache);
+}
+
+static bool exportCubeTerrain(FILE *obj, int &vertexBase, int mapX, int mapY,
+		const uint8 *ground, int32 groundSize, const uint8 *heights, int32 heightSize) {
+	if (groundSize < kNbCote * kNbCote * 2 * (int)sizeof(uint32))
+		return false;
+	if (heightSize < (kNbCote + 1) * (kNbCote + 1) * 2)
+		return false;
+
+	const float originX = mapX * (kCubeWorldSize / (float)kVertexStep);
+	const float originZ = mapY * (kCubeWorldSize / (float)kVertexStep);
+	const float scale = 1.0f / kVertexStep;
+
+	for (int dz = 0; dz < kNbCote; ++dz) {
+		for (int dx = 0; dx < kNbCote; ++dx) {
+			const int polyIndex = (dz * kNbCote + dx) * 2;
+			HalfPoly poly0(READ_LE_UINT32(ground + polyIndex * sizeof(uint32)));
+			HalfPoly poly1(READ_LE_UINT32(ground + (polyIndex + 1) * sizeof(uint32)));
+
+			if (poly0.codeJeu() == kCodeJeuWater && poly1.codeJeu() == kCodeJeuWater)
+				continue;
+			if (!poly0.visible() && !poly1.visible())
+				continue;
+
+			const float x0 = originX + dx * scale;
+			const float x1 = originX + (dx + 1) * scale;
+			const float z0 = originZ + dz * scale;
+			const float z2 = originZ + (dz + 1) * scale;
+
+			const float y00 = readHeight(heights, dx, dz) / (float)kVertexStep;
+			const float y01 = readHeight(heights, dx, dz + 1) / (float)kVertexStep;
+			const float y11 = readHeight(heights, dx + 1, dz + 1) / (float)kVertexStep;
+			const float y10 = readHeight(heights, dx + 1, dz) / (float)kVertexStep;
+
+			const int v0 = vertexBase + 1;
+			writeVertex(obj, x0, y00, z0);
+			const int v1 = vertexBase + 2;
+			writeVertex(obj, x0, y01, z2);
+			const int v2 = vertexBase + 3;
+			writeVertex(obj, x1, y11, z2);
+			const int v3 = vertexBase + 4;
+			writeVertex(obj, x1, y10, z0);
+			vertexBase += 4;
+
+			if (poly0.visible()) {
+				if (!poly0.sens())
+					writeFace(obj, v0, v1, v2);
+				else
+					writeFace(obj, v3, v0, v1);
+			}
+
+			if (poly1.visible()) {
+				if (!poly1.sens())
+					writeFace(obj, v2, v3, v0);
+				else
+					writeFace(obj, v1, v2, v3);
+			}
+		}
+	}
+
+	return true;
+}
+
+static int exportCubeDecors(FILE *obj, FILE *mtl, int &vertexBase, int &materialId,
+		const Common::Filename &ileFile, const Common::Filename &oblFile,
+		BodyCacheEntry *bodyCache, int32 bodyCacheSize, int32 baseEntry,
+		int decorIndexStart, const TwineConvertContext &ctx, const TwinePalette &palette,
+		bool materialsWritten[256]) {
+	uint8 *info = nullptr;
+	uint8 *dob = nullptr;
+	int32 infoSize = 0;
+	int32 dobSize = 0;
+	int exported = 0;
+
+	if (!loadEntry(ileFile, baseEntry + kIleCubeInf, &info, &infoSize) ||
+		infoSize < (kInfoNbDecors + 1) * (int)sizeof(int32)) {
+		free(info);
+		return 0;
+	}
+
+	const int32 nbDecors = (int32)READ_LE_UINT32(info + kInfoNbDecors * sizeof(int32));
+	free(info);
+
+	if (nbDecors <= 0)
+		return 0;
+
+	if (!loadEntry(ileFile, baseEntry + kIleCubeDob, &dob, &dobSize) ||
+		dobSize < nbDecors * kDecorRecordSize) {
+		free(dob);
+		return 0;
+	}
+
+	for (int i = 0; i < nbDecors; ++i) {
+		IslandDecor decor;
+		if (!parseDecorRecord(dob, dobSize, i * kDecorRecordSize, decor))
+			continue;
+
+		const int32 bodyIndex = decor.body & 0xFFFF;
+		if (bodyIndex == 0 || (decor.body & kDecInvisible))
+			continue;
+
+		const uint8 *bodyData = nullptr;
+		int32 bodySize = 0;
+		if (!loadCachedBody(bodyCache, bodyCacheSize, oblFile, bodyIndex, &bodyData, &bodySize))
+			continue;
+
+		char objectName[64];
+		snprintf(objectName, sizeof(objectName), "decor_%d", decorIndexStart + exported);
+
+		TwineBodyTransform xform;
+		xform.posX = decor.xworld;
+		xform.posY = decor.yworld;
+		xform.posZ = decor.zworld;
+		xform.beta = decor.beta & 0xFFFF;
+
+		if (twineAppendBodyToObj(bodyData, bodySize, ctx.preferLba1, palette, obj, mtl,
+				vertexBase, materialId, xform, objectName, materialsWritten))
+			exported++;
+	}
+
+	free(dob);
+	return exported;
+}
+
+#ifdef USE_PNG
+static bool writeIndexedTexturePng(const char *outPath, const uint8 *data, const TwinePalette &palette) {
+	if (!palette.loaded) {
+		fprintf(stderr, "No palette available for %s\n", outPath);
+		return false;
+	}
+
+	FILE *fout = fopen(outPath, "wb");
+	if (!fout)
+		return false;
+
+	png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+	if (!png) {
+		fclose(fout);
+		return false;
+	}
+
+	png_infop info = png_create_info_struct(png);
+	if (!info) {
+		png_destroy_write_struct(&png, nullptr);
+		fclose(fout);
+		return false;
+	}
+
+	if (setjmp(png_jmpbuf(png))) {
+		png_destroy_write_struct(&png, &info);
+		fclose(fout);
+		return false;
+	}
+
+	png_init_io(png, fout);
+	png_set_IHDR(png, info, 256, 256, 8, PNG_COLOR_TYPE_PALETTE,
+		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+	png_color pngPalette[256];
+	for (int i = 0; i < 256; ++i) {
+		pngPalette[i].red = palette.data[i * 3 + 0];
+		pngPalette[i].green = palette.data[i * 3 + 1];
+		pngPalette[i].blue = palette.data[i * 3 + 2];
+	}
+	png_set_PLTE(png, info, pngPalette, 256);
+
+	png_byte trans = 0;
+	png_set_tRNS(png, info, &trans, 1, nullptr);
+	png_write_info(png, info);
+
+	png_bytep *rowPointers = (png_bytep *)malloc(sizeof(png_bytep) * 256);
+	if (!rowPointers) {
+		png_destroy_write_struct(&png, &info);
+		fclose(fout);
+		return false;
+	}
+
+	for (int y = 0; y < 256; ++y)
+		rowPointers[y] = (png_bytep)(const_cast<uint8 *>(data) + y * 256);
+
+	png_write_image(png, rowPointers);
+	png_write_end(png, nullptr);
+	free(rowPointers);
+	png_destroy_write_struct(&png, &info);
+	fclose(fout);
+	return true;
+}
+#endif
+
+} // namespace
+
+bool twineIsIleFilename(const Common::Filename &filename) {
+	return scumm_stricmp(filename.getExtension().c_str(), "ile") == 0;
+}
+
+bool twineConvertIsland(const Common::Filename &ileFile, const char *outDir, const TwineConvertContext &ctx) {
+	const int32 numEntries = TwinE::HQR::numEntries(ileFile);
+	if (numEntries < kIleCubeStart + kIleCubeStep) {
+		fprintf(stderr, "Not enough entries for an island ILE file: %s\n", ileFile.getFullPath().c_str());
+		return false;
+	}
+
+	uint8 *mapData = nullptr;
+	int32 mapSize = 0;
+	if (!loadEntry(ileFile, kIleEntryMap, &mapData, &mapSize) || mapSize != kIleMapSize) {
+		fprintf(stderr, "Invalid island map entry in %s\n", ileFile.getFullPath().c_str());
+		free(mapData);
+		return false;
+	}
+
+	char basePath[1024];
+	snprintf(basePath, sizeof(basePath), "%s/%s", outDir, ileFile.getName().c_str());
+
+	char objPath[1100];
+	char mtlPath[1100];
+	snprintf(objPath, sizeof(objPath), "%s_island.obj", basePath);
+	snprintf(mtlPath, sizeof(mtlPath), "%s_island.mtl", basePath);
+
+	FILE *obj = fopen(objPath, "w");
+	if (!obj) {
+		fprintf(stderr, "Unable to open %s for writing\n", objPath);
+		free(mapData);
+		return false;
+	}
+
+	FILE *mtl = fopen(mtlPath, "w");
+	if (!mtl) {
+		fprintf(stderr, "Unable to open %s for writing\n", mtlPath);
+		fclose(obj);
+		free(mapData);
+		return false;
+	}
+
+	fprintf(obj, "# LBA island exported from %s\n", ileFile.getFullName().c_str());
+	fprintf(obj, "mtllib %s_island.mtl\n", ileFile.getName().c_str());
+	fprintf(obj, "o terrain\n");
+	fprintf(obj, "usemtl terrain\n");
+	fprintf(mtl, "newmtl terrain\n");
+	fprintf(mtl, "Kd 0.45 0.50 0.35\n");
+	fprintf(mtl, "Ka 0.10 0.10 0.10\n");
+	fprintf(mtl, "d 1.0\n\n");
+
+	bool materialsWritten[256];
+	memset(materialsWritten, 0, sizeof(materialsWritten));
+	materialsWritten[0] = true; // terrain slot unused for decor shades
+
+	int vertexBase = 0;
+	int materialId = 0;
+	int cubesExported = 0;
+
+	for (int mapY = 0; mapY < kMapSize; ++mapY) {
+		for (int mapX = 0; mapX < kMapSize; ++mapX) {
+			const uint8 cubeIndex = mapData[mapY * kMapSize + mapX] & 127;
+			if (cubeIndex == 0)
+				continue;
+
+			const int32 baseEntry = kIleCubeStart + (cubeIndex - 1) * kIleCubeStep;
+			if (baseEntry + kIleCubeY >= numEntries)
+				continue;
+
+			uint8 *ground = nullptr;
+			uint8 *heights = nullptr;
+			int32 groundSize = 0;
+			int32 heightSize = 0;
+
+			if (!loadEntry(ileFile, baseEntry + kIleCubeGrd, &ground, &groundSize) ||
+				!loadEntry(ileFile, baseEntry + kIleCubeY, &heights, &heightSize)) {
+				free(ground);
+				free(heights);
+				continue;
+			}
+
+			if (exportCubeTerrain(obj, vertexBase, mapX, mapY, ground, groundSize, heights, heightSize))
+				cubesExported++;
+
+			free(ground);
+			free(heights);
+		}
+	}
+
+	if (cubesExported == 0) {
+		fprintf(stderr, "No island terrain cubes found in %s\n", ileFile.getFullName().c_str());
+		fclose(obj);
+		fclose(mtl);
+		free(mapData);
+		remove(objPath);
+		remove(mtlPath);
+		return false;
+	}
+
+	const Common::Filename oblFile = oblPathFromIle(ileFile);
+	BodyCacheEntry *bodyCache = nullptr;
+	int32 bodyCacheSize = 0;
+	int decorsExported = 0;
+
+	if (oblFile.exists()) {
+		bodyCacheSize = TwinE::HQR::numEntries(oblFile);
+		if (bodyCacheSize > 0) {
+			bodyCache = (BodyCacheEntry *)calloc(bodyCacheSize, sizeof(BodyCacheEntry));
+			if (!bodyCache) {
+				fprintf(stderr, "Unable to allocate body cache for %s\n", oblFile.getFullPath().c_str());
+			} else {
+				TwinePalette decorPalette;
+				if (!twineResolvePalette(ctx, kIleEntryTexObj, decorPalette))
+					fprintf(stderr, "Warning: no palette for island decor materials\n");
+
+				int decorIndex = 0;
+				for (int mapY = 0; mapY < kMapSize; ++mapY) {
+					for (int mapX = 0; mapX < kMapSize; ++mapX) {
+						const uint8 cubeIndex = mapData[mapY * kMapSize + mapX] & 127;
+						if (cubeIndex == 0)
+							continue;
+
+						const int32 baseEntry = kIleCubeStart + (cubeIndex - 1) * kIleCubeStep;
+						if (baseEntry + kIleCubeDob >= numEntries)
+							continue;
+
+						const int cubeDecors = exportCubeDecors(obj, mtl, vertexBase, materialId,
+							ileFile, oblFile, bodyCache, bodyCacheSize, baseEntry,
+							decorIndex, ctx, decorPalette, materialsWritten);
+						decorsExported += cubeDecors;
+						decorIndex += cubeDecors;
+					}
+				}
+			}
+		}
+	} else {
+		fprintf(stderr, "Warning: no paired OBL file found at %s, exporting terrain only\n",
+			oblFile.getFullPath().c_str());
+	}
+
+	free(mapData);
+
+	fclose(obj);
+	fclose(mtl);
+	freeBodyCache(bodyCache, bodyCacheSize);
+
+	uint8 *groundTex = nullptr;
+	uint8 *objTex = nullptr;
+	int32 groundTexSize = 0;
+	int32 objTexSize = 0;
+	if (loadEntry(ileFile, kIleEntryTexGround, &groundTex, &groundTexSize) && groundTexSize == kIleTextureSize) {
+#ifdef USE_PNG
+		char pngPath[1100];
+		snprintf(pngPath, sizeof(pngPath), "%s_ground.png", basePath);
+		TwinePalette palette;
+		if (twineResolvePalette(ctx, kIleEntryTexGround, palette) &&
+			writeIndexedTexturePng(pngPath, groundTex, palette))
+			printf("Exported island ground texture -> %s\n", pngPath);
+#endif
+	}
+	if (loadEntry(ileFile, kIleEntryTexObj, &objTex, &objTexSize) && objTexSize == kIleTextureSize) {
+#ifdef USE_PNG
+		char pngPath[1100];
+		snprintf(pngPath, sizeof(pngPath), "%s_objects.png", basePath);
+		TwinePalette palette;
+		if (twineResolvePalette(ctx, kIleEntryTexObj, palette) &&
+			writeIndexedTexturePng(pngPath, objTex, palette))
+			printf("Exported island object texture -> %s\n", pngPath);
+#endif
+	}
+	free(groundTex);
+	free(objTex);
+
+	printf("Converted island %s -> %s (%d cubes, %d decors, + %s)\n",
+		ileFile.getFullName().c_str(), objPath, cubesExported, decorsExported, mtlPath);
+	return true;
+}
diff --git a/engines/twine/extract_twine_obj.cpp b/engines/twine/extract_twine_obj.cpp
new file mode 100644
index 00000000..4a5a9591
--- /dev/null
+++ b/engines/twine/extract_twine_obj.cpp
@@ -0,0 +1,237 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "engines/twine/extract_twine_convert.h"
+
+#include "common/array.h"
+#include "engines/twine/parser/body.h"
+#include "engines/twine/parser/bodytypes.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+namespace {
+
+static int16 clampShade(int32 value) {
+	if (value < 0)
+		return 0;
+	if (value > 255)
+		return 255;
+	return (int16)value;
+}
+
+static void buildNormalTable(const TwinE::BodyData &body, uint16 *normalTable) {
+	const Common::Array<TwinE::BodyNormal> &normals = body.getNormals();
+	for (uint i = 0; i < normals.size(); ++i) {
+		const TwinE::BodyNormal &normal = normals[i];
+		int32 intensity = normal.x * 0 + normal.y * -8192 + normal.z * 8192;
+		if (intensity > 0) {
+			intensity >>= 14;
+			if (normal.prenormalizedRange > 0)
+				intensity /= normal.prenormalizedRange;
+		} else {
+			intensity = 0;
+		}
+		normalTable[i] = (uint16)intensity;
+	}
+}
+
+static int16 polygonShade(const TwinE::BodyData &body, const TwinE::BodyPolygon &poly,
+		int cornerIndex, const uint16 *normalTable) {
+	if (poly.materialType >= TwinE::MAT_GOURAUD) {
+		const uint16 normalIdx = poly.normals[cornerIndex];
+		if (normalIdx < body.getNormals().size())
+			return clampShade(poly.intensity + normalTable[normalIdx]);
+	}
+	if (poly.materialType >= TwinE::MAT_FLAT) {
+		const uint16 normalIdx = poly.normals.empty() ? 0 : poly.normals[0];
+		if (normalIdx < body.getNormals().size())
+			return clampShade(poly.intensity + normalTable[normalIdx]);
+	}
+	return clampShade(poly.intensity);
+}
+
+static void paletteColor(const TwinePalette &palette, int16 shadeIndex, float rgb[3]) {
+	const uint8 idx = (uint8)shadeIndex;
+	if (palette.loaded) {
+		rgb[0] = palette.data[idx * 3 + 0] / 255.0f;
+		rgb[1] = palette.data[idx * 3 + 1] / 255.0f;
+		rgb[2] = palette.data[idx * 3 + 2] / 255.0f;
+	} else {
+		const float gray = idx / 255.0f;
+		rgb[0] = rgb[1] = rgb[2] = gray;
+	}
+}
+
+static bool writeMaterial(FILE *mtl, int materialId, const TwinePalette &palette, int16 shadeIndex) {
+	float rgb[3];
+	paletteColor(palette, shadeIndex, rgb);
+	fprintf(mtl, "newmtl mat_%d\n", materialId);
+	fprintf(mtl, "Kd %g %g %g\n", rgb[0], rgb[1], rgb[2]);
+	fprintf(mtl, "Ka %g %g %g\n", rgb[0] * 0.2f, rgb[1] * 0.2f, rgb[2] * 0.2f);
+	fprintf(mtl, "d 1.0\n\n");
+	return true;
+}
+
+static void useShadeMaterial(FILE *obj, FILE *mtl, int16 shade, const TwinePalette &palette,
+		bool written[256], int &currentMaterial) {
+	const uint8 idx = (uint8)shade;
+	if (!written[idx]) {
+		writeMaterial(mtl, idx, palette, shade);
+		written[idx] = true;
+	}
+	if (shade != currentMaterial) {
+		fprintf(obj, "usemtl mat_%d\n", idx);
+		currentMaterial = shade;
+	}
+}
+
+} // namespace
+
+bool twineTryParseBody(const uint8 *data, int32 size, bool preferLba1, TwinE::BodyData &body, bool &isLba1) {
+	if (preferLba1) {
+		if (TwinE::BodyData::isLikelyLba1Buffer(data, size) && body.loadFromBuffer(data, size, true)) {
+			isLba1 = true;
+			return true;
+		}
+		if (TwinE::BodyData::isLikelyLba2Buffer(data, size) && body.loadFromBuffer(data, size, false)) {
+			isLba1 = false;
+			return true;
+		}
+	} else {
+		if (TwinE::BodyData::isLikelyLba2Buffer(data, size) && body.loadFromBuffer(data, size, false)) {
+			isLba1 = false;
+			return true;
+		}
+		if (TwinE::BodyData::isLikelyLba1Buffer(data, size) && body.loadFromBuffer(data, size, true)) {
+			isLba1 = true;
+			return true;
+		}
+	}
+	return false;
+}
+
+bool twineAppendBodyToObj(const uint8 *data, int32 size, bool preferLba1, const TwinePalette &palette,
+		FILE *obj, FILE *mtl, int &vertexBase, int &materialId, const TwineBodyTransform &xform,
+		const char *objectName, bool materialsWritten[256]) {
+	TwinE::BodyData body;
+	bool isLba1 = preferLba1;
+	if (!twineTryParseBody(data, size, preferLba1, body, isLba1))
+		return false;
+
+	bool localMaterials[256];
+	if (!materialsWritten) {
+		memset(localMaterials, 0, sizeof(localMaterials));
+		materialsWritten = localMaterials;
+	}
+
+	if (objectName && objectName[0])
+		fprintf(obj, "o %s\n", objectName);
+
+	const float worldScale = 1.0f / 512.0f;
+	const float bodyScale = 1.0f / 256.0f;
+	const float angle = xform.beta * (2.0f * 3.14159265f / 4096.0f);
+	const float c = cosf(angle);
+	const float s = sinf(angle);
+	const float tx = xform.posX * worldScale;
+	const float ty = xform.posY * worldScale;
+	const float tz = xform.posZ * worldScale;
+
+	const Common::Array<TwinE::BodyVertex> &vertices = body.getVertices();
+	for (uint i = 0; i < vertices.size(); ++i) {
+		const TwinE::BodyVertex &v = vertices[i];
+		const float lx = v.x * bodyScale;
+		const float ly = v.y * bodyScale;
+		const float lz = v.z * bodyScale;
+		const float rx = lx * c + lz * s;
+		const float rz = -lx * s + lz * c;
+		fprintf(obj, "v %g %g %g\n", rx + tx, ly + ty, rz + tz);
+	}
+
+	uint16 normalTable[512];
+	memset(normalTable, 0, sizeof(normalTable));
+	buildNormalTable(body, normalTable);
+
+	int currentMaterial = -1;
+	const int numVertices = (int)vertices.size();
+	const Common::Array<TwinE::BodyPolygon> &polygons = body.getPolygons();
+	for (uint p = 0; p < polygons.size(); ++p) {
+		const TwinE::BodyPolygon &poly = polygons[p];
+		if (poly.indices.size() < 3)
+			continue;
+
+		bool valid = true;
+		for (uint i = 0; i < poly.indices.size(); ++i) {
+			if (poly.indices[i] >= (uint)numVertices) {
+				valid = false;
+				break;
+			}
+		}
+		if (!valid)
+			continue;
+
+		const int16 shade = polygonShade(body, poly, 0, normalTable);
+		useShadeMaterial(obj, mtl, shade, palette, materialsWritten, currentMaterial);
+
+		fprintf(obj, "f");
+		for (uint i = 0; i < poly.indices.size(); ++i)
+			fprintf(obj, " %d", vertexBase + (int)poly.indices[i] + 1);
+		fprintf(obj, "\n");
+	}
+
+	vertexBase += (int)vertices.size();
+	return true;
+}
+
+bool twineConvertBodyToObj(const uint8 *data, int32 size, bool preferLba1, const TwinePalette &palette, const char *outPath) {
+	char objPath[1100];
+	char mtlPath[1100];
+	snprintf(objPath, sizeof(objPath), "%s.obj", outPath);
+	snprintf(mtlPath, sizeof(mtlPath), "%s.mtl", outPath);
+
+	FILE *obj = fopen(objPath, "w");
+	if (!obj)
+		return false;
+
+	FILE *mtl = fopen(mtlPath, "w");
+	if (!mtl) {
+		fclose(obj);
+		return false;
+	}
+
+	const char *mtlName = strrchr(mtlPath, '/');
+	if (!mtlName)
+		mtlName = strrchr(mtlPath, '\\');
+	mtlName = mtlName ? mtlName + 1 : mtlPath;
+
+	fprintf(obj, "# LBA body exported by extract_twine\n");
+	fprintf(obj, "mtllib %s\n\n", mtlName);
+
+	int vertexBase = 0;
+	int materialId = 0;
+	TwineBodyTransform xform = {0, 0, 0, 0};
+	const bool ok = twineAppendBodyToObj(data, size, preferLba1, palette, obj, mtl, vertexBase, materialId, xform, nullptr, nullptr);
+
+	fclose(mtl);
+	fclose(obj);
+	return ok;
+}
diff --git a/engines/twine/hqr.cpp b/engines/twine/hqr.cpp
index 13b7e411..457f17cf 100644
--- a/engines/twine/hqr.cpp
+++ b/engines/twine/hqr.cpp
@@ -39,11 +39,13 @@ namespace HQR {
  */
 static void decompressEntry(uint8 *dst, const uint8 *compBuf, uint32 compSize, int32 decompsize, int32 mode) {
 	Common::MemoryReadStream stream(compBuf, compSize);
-	do {
+	while (decompsize > 0 && !stream.eos()) {
 		uint8 b = stream.readByte();
-		for (int32 d = 0; d < 8; d++) {
+		for (int32 d = 0; d < 8 && decompsize > 0; d++) {
 			int32 length;
 			if (!(b & (1 << d))) {
+				if (stream.eos())
+					return;
 				const uint16 offset = stream.readUint16LE();
 				length = (offset & 0x0F) + (mode + 1);
 				const uint8 *ptr = dst - (offset >> 4) - 1;
@@ -51,6 +53,8 @@ static void decompressEntry(uint8 *dst, const uint8 *compBuf, uint32 compSize, i
 					*(dst++) = *(ptr++);
 				}
 			} else {
+				if (stream.eos())
+					return;
 				length = 1;
 				*(dst++) = stream.readByte();
 			}
@@ -59,7 +63,7 @@ static void decompressEntry(uint8 *dst, const uint8 *compBuf, uint32 compSize, i
 				return;
 			}
 		}
-	} while (decompsize);
+	}
 }
 
 /**
@@ -82,7 +86,7 @@ static int voxEntrySize(const Common::Filename &filename, int32 index, int32 hid
 		return 0;
 	}
 
-	file.seek(index * 4, SEEK_SET);
+	file.seek(4 + index * 4, SEEK_SET);
 	uint32 offsetToData = file.readUint32LE();
 
 	file.seek(offsetToData, SEEK_SET);
@@ -120,20 +124,30 @@ int32 getEntry(uint8 *ptr, const Common::Filename &filename, int32 index) {
 		return 0;
 	}
 
-	file.seek(index * 4, SEEK_SET);
+	file.seek(4 + index * 4, SEEK_SET);
 	uint32 offsetToData = file.readUint32LE();
 
+	if (offsetToData == 0)
+		return 0;
+
 	file.seek(offsetToData, SEEK_SET);
+	if ((uint32)file.pos() + 10u > file.size())
+		return 0;
+
 	uint32 realSize = file.readUint32LE();
 	uint32 compSize = file.readUint32LE();
 	uint16 mode = file.readUint16LE();
 
 	// uncompressed
 	if (mode == 0) {
+		if (file.pos() + realSize > file.size())
+			return 0;
 		file.read_throwsOnError(ptr, realSize);
 	}
 	// compressed: modes (1 & 2)
 	else if (mode == 1 || mode == 2) {
+		if (file.pos() + compSize > file.size())
+			return 0;
 		uint8 *compDataPtr = (uint8 *)malloc(compSize);
 		file.read_throwsOnError(compDataPtr, compSize);
 		decompressEntry(ptr, compDataPtr, compSize, realSize, mode);
@@ -157,7 +171,7 @@ int32 entrySize(const Common::Filename &filename, int32 index) {
 		return 0;
 	}
 
-	file.seek(index * 4, SEEK_SET);
+	file.seek(4 + index * 4, SEEK_SET);
 	uint32 offsetToData = file.readUint32LE();
 
 	file.seek(offsetToData, SEEK_SET);
@@ -202,9 +216,9 @@ int32 getAllocEntry(uint8 **ptr, const Common::Filename &filename, int32 index)
 		warning("HQR: unable to allocate entry memory");
 		return 0;
 	}
-	const int32 entrySize = getEntry(*ptr, filename, index);
-	assert(entrySize == size);
-	return entrySize;
+	const int32 bytesRead = getEntry(*ptr, filename, index);
+	assert(bytesRead == size);
+	return bytesRead;
 }
 
 int32 getVoxEntry(uint8 *ptr, const Common::Filename &filename, int32 index, int32 hiddenIndex) {
@@ -225,7 +239,7 @@ int32 getVoxEntry(uint8 *ptr, const Common::Filename &filename, int32 index, int
 		return 0;
 	}
 
-	file.seek(index * 4, SEEK_SET);
+	file.seek(4 + index * 4, SEEK_SET);
 	uint32 offsetToData = file.readUint32LE();
 
 	file.seek(offsetToData, SEEK_SET);
@@ -270,9 +284,96 @@ int32 getAllocVoxEntry(uint8 **ptr, const Common::Filename &filename, int32 inde
 		warning("HQR: unable to allocate entry memory of size %d for index: %d", size, index);
 		return 0;
 	}
-	const int32 entrySize = getVoxEntry(*ptr, filename, index, hiddenIndex);
-	assert(entrySize == size);
-	return entrySize;
+	const int32 entryBytes = getVoxEntry(*ptr, filename, index, hiddenIndex);
+	assert(entryBytes == size);
+	return entryBytes;
+}
+
+bool loadHqrEntry(const Common::Filename &filename, int32 index, HqrPackEntry &out) {
+	out.blank = true;
+	out.data.clear();
+
+	Common::File file;
+	file.open(filename, "r");
+	if (!file.isOpen())
+		return false;
+
+	const uint32 headerSize = file.readUint32LE();
+	if ((uint32)index >= headerSize / 4)
+		return false;
+
+	file.seek(4 + index * 4, SEEK_SET);
+	const uint32 offsetToData = file.readUint32LE();
+	if (offsetToData == 0)
+		return true;
+
+	uint8 *data = nullptr;
+	const int32 size = getAllocEntry(&data, filename, index);
+	if (size <= 0 || !data)
+		return false;
+
+	out.blank = false;
+	out.data.assign(data, data + size);
+	free(data);
+	return true;
+}
+
+bool writeHqrArchive(const Common::Filename &filename, const std::vector<HqrPackEntry> &entries) {
+	if (entries.empty())
+		return false;
+
+	const size_t numEntries = entries.size();
+	const uint32 headerSize = (uint32)((numEntries + 1) * 4);
+	std::vector<uint8> file(headerSize, 0);
+
+	file[0] = (uint8)(headerSize);
+	file[1] = (uint8)(headerSize >> 8);
+	file[2] = (uint8)(headerSize >> 16);
+	file[3] = (uint8)(headerSize >> 24);
+
+	uint32 dataOffset = headerSize;
+	std::vector<uint32> offsets(numEntries, 0);
+
+	for (size_t i = 0; i + 1 < numEntries; i++) {
+		if (entries[i].blank || entries[i].data.empty())
+			continue;
+
+		offsets[i] = dataOffset;
+
+		const uint32 realSize = (uint32)entries[i].data.size();
+		file.push_back((uint8)(realSize));
+		file.push_back((uint8)(realSize >> 8));
+		file.push_back((uint8)(realSize >> 16));
+		file.push_back((uint8)(realSize >> 24));
+		file.push_back((uint8)(realSize));
+		file.push_back((uint8)(realSize >> 8));
+		file.push_back((uint8)(realSize >> 16));
+		file.push_back((uint8)(realSize >> 24));
+		file.push_back(0);
+		file.push_back(0);
+		file.insert(file.end(), entries[i].data.begin(), entries[i].data.end());
+
+		dataOffset += 10 + realSize;
+	}
+
+	offsets[numEntries - 1] = dataOffset;
+
+	for (size_t i = 0; i < numEntries; i++) {
+		const uint32 off = offsets[i];
+		const size_t pos = 4 + i * 4;
+		file[pos] = (uint8)(off);
+		file[pos + 1] = (uint8)(off >> 8);
+		file[pos + 2] = (uint8)(off >> 16);
+		file[pos + 3] = (uint8)(off >> 24);
+	}
+
+	Common::File out;
+	out.open(filename, "wb");
+	if (!out.isOpen())
+		return false;
+
+	out.write(file.data(), file.size());
+	return true;
 }
 
 } // namespace HQR
diff --git a/engines/twine/hqr.h b/engines/twine/hqr.h
index 8b103402..9d713e27 100644
--- a/engines/twine/hqr.h
+++ b/engines/twine/hqr.h
@@ -25,6 +25,8 @@
 #include "common/stream.h"
 #include "common/file.h"
 
+#include <vector>
+
 namespace TwinE {
 
 class TwinEEngine;
@@ -91,6 +93,14 @@ int32 getAllocVoxEntry(uint8 **ptr, const Common::Filename &filename, int32 inde
 
 Common::SeekableReadStream *makeReadStream(const Common::Filename &filename, int index);
 
+struct HqrPackEntry {
+	bool blank = true;
+	std::vector<uint8> data;
+};
+
+bool loadHqrEntry(const Common::Filename &filename, int32 index, HqrPackEntry &out);
+bool writeHqrArchive(const Common::Filename &filename, const std::vector<HqrPackEntry> &entries);
+
 } // namespace HQR
 
 } // namespace TwinE
diff --git a/engines/twine/parser/body.cpp b/engines/twine/parser/body.cpp
new file mode 100644
index 00000000..e46d1f00
--- /dev/null
+++ b/engines/twine/parser/body.cpp
@@ -0,0 +1,548 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "engines/twine/parser/body.h"
+#include "common/endian.h"
+#include "common/memstream.h"
+
+#define INFO_ANIM 2
+#define MASK_OBJECT_ANIMATED (1 << 8)
+
+namespace {
+
+static bool bodySeek(Common::SeekableReadStream &stream, int32 pos, uint32 size) {
+	if (pos < 0 || (uint32)pos > size)
+		return false;
+	return stream.seek(pos);
+}
+
+static bool isReasonableCount(int32 count, int32 maxCount = 20000) {
+	return count >= 0 && count <= maxCount;
+}
+
+static bool isValidBodyOffset(int32 offset, uint32 size, uint32 minOffset) {
+	return offset >= (int32)minOffset && (uint32)offset <= size;
+}
+
+static bool validateLba2Header(int32 nbGroupes, int32 offGroupes, int32 nbPoints, int32 offPoints,
+		int32 nbNormals, int32 offNormals, int32 nbPolys, int32 offPolys,
+		int32 nbLines, int32 offLines, int32 nbSpheres, int32 offSpheres, uint32 size) {
+	static const uint32 kHeaderEnd = 0x60;
+
+	if (!isReasonableCount(nbGroupes, 1024) || !isReasonableCount(nbPoints) ||
+		!isReasonableCount(nbNormals) || !isReasonableCount(nbPolys) ||
+		!isReasonableCount(nbLines, 5000) || !isReasonableCount(nbSpheres, 5000))
+		return false;
+
+	if (nbPoints == 0 || nbPolys == 0)
+		return false;
+
+	if (!isValidBodyOffset(offGroupes, size, kHeaderEnd) ||
+		!isValidBodyOffset(offPoints, size, kHeaderEnd) ||
+		!isValidBodyOffset(offNormals, size, kHeaderEnd) ||
+		!isValidBodyOffset(offPolys, size, kHeaderEnd) ||
+		!isValidBodyOffset(offLines, size, kHeaderEnd) ||
+		!isValidBodyOffset(offSpheres, size, kHeaderEnd))
+		return false;
+
+	if (offPoints + (uint32)nbPoints * 8u > size)
+		return false;
+	if (offGroupes + (uint32)nbGroupes * 8u > size)
+		return false;
+	if (offNormals + (uint32)nbNormals * 8u > size)
+		return false;
+
+	return true;
+}
+
+static bool looksLikeLba1BodyHeader(const uint8 *data, uint32 size) {
+	static const uint32 kVertexOffset = 0x1A;
+	static const uint32 kBoneRecordSize = 36;
+
+	if (size < kVertexOffset + 2)
+		return false;
+
+	const uint16 numVertices = READ_LE_UINT16(data + kVertexOffset);
+	if (!isReasonableCount(numVertices))
+		return false;
+
+	const uint32 bonesOffset = kVertexOffset + 2u + (uint32)numVertices * 6u;
+	if (bonesOffset + 2 > size)
+		return false;
+
+	const uint16 numBones = READ_LE_UINT16(data + bonesOffset);
+	if (!isReasonableCount(numBones, 1024))
+		return false;
+
+	if (bonesOffset + 2u + (uint32)numBones * kBoneRecordSize > size)
+		return false;
+
+	return true;
+}
+
+static bool looksLikeLba2BodyHeader(const uint8 *data, uint32 size) {
+	if (size < 0x60)
+		return false;
+
+	const int32 nbGroupes = (int32)READ_LE_UINT32(data + 0x20);
+	const int32 offGroupes = (int32)READ_LE_UINT32(data + 0x24);
+	const int32 nbPoints = (int32)READ_LE_UINT32(data + 0x28);
+	const int32 offPoints = (int32)READ_LE_UINT32(data + 0x2C);
+	const int32 nbNormals = (int32)READ_LE_UINT32(data + 0x30);
+	const int32 offNormals = (int32)READ_LE_UINT32(data + 0x34);
+	const int32 nbPolys = (int32)READ_LE_UINT32(data + 0x40);
+	const int32 offPolys = (int32)READ_LE_UINT32(data + 0x44);
+	const int32 nbLines = (int32)READ_LE_UINT32(data + 0x48);
+	const int32 offLines = (int32)READ_LE_UINT32(data + 0x4C);
+	const int32 nbSpheres = (int32)READ_LE_UINT32(data + 0x50);
+	const int32 offSpheres = (int32)READ_LE_UINT32(data + 0x54);
+
+	return validateLba2Header(nbGroupes, offGroupes, nbPoints, offPoints, nbNormals, offNormals,
+		nbPolys, offPolys, nbLines, offLines, nbSpheres, offSpheres, size);
+}
+
+static int groupedPolyRecordSize(uint16 typePoly) {
+	static const int kPolyDitherTable = 7;
+	static const uint16 kMaskQuad = 1 << 15;
+	static const uint16 kMaskEnv = 1 << 14;
+
+	const uint8 baseType = typePoly & 0xFF;
+	const bool isQuad = (typePoly & kMaskQuad) != 0;
+	const bool isEnv = (typePoly & kMaskEnv) != 0;
+	const bool isTexture = baseType > kPolyDitherTable;
+
+	if (isQuad) {
+		if (isEnv)
+			return 16;
+		return isTexture ? 32 : 12;
+	}
+	if (isEnv)
+		return 16;
+	return isTexture ? 24 : 12;
+}
+
+static bool appendGroupedTriangle(Common::Array<TwinE::BodyPolygon> &polygons, uint16 p1, uint16 p2,
+		uint16 p3, int16 intensity) {
+	TwinE::BodyPolygon poly;
+	poly.intensity = intensity;
+	poly.indices.push_back(p1);
+	poly.indices.push_back(p2);
+	poly.indices.push_back(p3);
+	if (poly.indices.size() < 3)
+		return false;
+	polygons.push_back(poly);
+	return true;
+}
+
+static bool readGroupedPolyRecord(Common::SeekableReadStream &stream, uint32 streamSize,
+		uint16 typePoly, Common::Array<TwinE::BodyPolygon> &polygons) {
+	static const uint16 kMaskQuad = 1 << 15;
+
+	const int recordSize = groupedPolyRecordSize(typePoly);
+	if (stream.pos() + 8 > streamSize)
+		return false;
+
+	const bool isQuad = (typePoly & kMaskQuad) != 0;
+	const uint16 p1 = stream.readUint16LE();
+	const uint16 p2 = stream.readUint16LE();
+	const uint16 p3 = stream.readUint16LE();
+
+	if (isQuad) {
+		if (stream.pos() + 4 > streamSize)
+			return false;
+		const uint16 p4 = stream.readUint16LE();
+		const int16 intensity = stream.readSint16LE();
+		if (stream.pos() + recordSize - 10 > streamSize)
+			return false;
+		stream.skip(recordSize - 10);
+		return appendGroupedTriangle(polygons, p1, p2, p3, intensity) &&
+			appendGroupedTriangle(polygons, p1, p3, p4, intensity);
+	}
+
+	if (stream.pos() + 4 > streamSize)
+		return false;
+	stream.skip(2);
+	const int16 intensity = stream.readSint16LE();
+	if (stream.pos() + recordSize - 10 > streamSize)
+		return false;
+	stream.skip(recordSize - 10);
+	return appendGroupedTriangle(polygons, p1, p2, p3, intensity);
+}
+
+static bool loadGroupedPolygonsLba2(Common::SeekableReadStream &stream, uint32 streamSize,
+		int32 offPolys, int32 offLines, Common::Array<TwinE::BodyPolygon> &polygons) {
+	if (!isValidBodyOffset(offPolys, streamSize, 0x60) ||
+		!isValidBodyOffset(offLines, streamSize, offPolys))
+		return false;
+
+	uint32 pos = offPolys;
+	while (pos < (uint32)offLines) {
+		if (pos + 8 > streamSize)
+			return false;
+
+		stream.seek(pos);
+		const uint16 typePoly = stream.readUint16LE();
+		const uint16 nbPoly = stream.readUint16LE();
+		const int32 offNext = stream.readSint32LE();
+		if (nbPoly == 0 && offNext == 0)
+			break;
+
+		for (uint16 i = 0; i < nbPoly; ++i) {
+			if (!readGroupedPolyRecord(stream, streamSize, typePoly, polygons))
+				return false;
+		}
+
+		if (offNext <= 0)
+			break;
+		pos += (uint32)offNext;
+	}
+
+	return !polygons.empty();
+}
+
+} // namespace
+
+namespace TwinE {
+
+bool BodyData::isLikelyLba1Buffer(const uint8 *buf, uint32 size) {
+	return buf && looksLikeLba1BodyHeader(buf, size);
+}
+
+bool BodyData::isLikelyLba2Buffer(const uint8 *buf, uint32 size) {
+	return buf && looksLikeLba2BodyHeader(buf, size);
+}
+
+void BodyData::reset() {
+	_vertices.clear();
+	_bones.clear();
+	_normals.clear();
+	_polygons.clear();
+	_spheres.clear();
+	_lines.clear();
+}
+
+void BodyData::loadVertices(Common::SeekableReadStream &stream, uint32 streamSize) {
+	const uint32 start = stream.pos();
+	const uint16 numVertices = stream.readUint16LE();
+	if (stream.eos() || !isReasonableCount(numVertices) ||
+		start + 2u + (uint32)numVertices * 6u > streamSize)
+		return;
+
+	_vertices.reserve(numVertices);
+	for (uint16 i = 0U; i < numVertices; ++i) {
+		const int16 x = stream.readSint16LE();
+		const int16 y = stream.readSint16LE();
+		const int16 z = stream.readSint16LE();
+		const uint16 bone = 0;
+		_vertices.push_back({x, y, z, bone});
+	}
+}
+
+void BodyData::loadBones(Common::SeekableReadStream &stream) {
+	const uint16 numBones = stream.readUint16LE();
+	if (stream.eos())
+		return;
+
+	_bones.reserve(numBones);
+	for (uint16 i = 0; i < numBones; ++i) {
+		const int16 firstPoint = stream.readSint16LE() / 6;
+		const int16 numPoints = stream.readSint16LE();
+		const int16 basePoint = stream.readSint16LE() / 6;
+		const int16 baseElementOffset = stream.readSint16LE();
+		BoneFrame boneframe;
+		boneframe.type = (BoneType)stream.readSint16LE();
+		boneframe.x = stream.readSint16LE();
+		boneframe.y = stream.readSint16LE();
+		boneframe.z = stream.readSint16LE();
+		stream.readSint16LE();
+		const int16 numNormals = stream.readSint16LE();
+		stream.readSint16LE();
+		stream.readSint32LE();
+		stream.readSint32LE();
+		stream.readSint32LE();
+		stream.readSint32LE();
+
+		BodyBone bone;
+		bone.parent = baseElementOffset == -1 ? 0xffff : baseElementOffset / 38;
+		bone.vertex = basePoint;
+		bone.firstVertex = firstPoint;
+		bone.numVertices = numPoints;
+		bone.initalBoneState = boneframe;
+		bone.numNormals = numNormals;
+
+		for (int j = 0; j < numPoints; ++j) {
+			const int idx = firstPoint + j;
+			if (idx >= 0 && (uint)idx < _vertices.size())
+				_vertices[idx].bone = i;
+		}
+
+		_bones.push_back(bone);
+	}
+}
+
+void BodyData::loadNormals(Common::SeekableReadStream &stream) {
+	const uint16 numNormals = stream.readUint16LE();
+	if (stream.eos())
+		return;
+
+	_normals.reserve(numNormals);
+	for (uint16 i = 0; i < numNormals; ++i) {
+		BodyNormal shape;
+		shape.x = stream.readSint16LE();
+		shape.y = stream.readSint16LE();
+		shape.z = stream.readSint16LE();
+		shape.prenormalizedRange = stream.readUint16LE();
+		_normals.push_back(shape);
+	}
+}
+
+void BodyData::loadPolygons(Common::SeekableReadStream &stream) {
+	const uint16 numPolygons = stream.readUint16LE();
+	if (stream.eos())
+		return;
+
+	_polygons.reserve(numPolygons);
+	for (uint16 i = 0; i < numPolygons; ++i) {
+		BodyPolygon poly;
+		poly.materialType = stream.readByte();
+		const uint8 numVertices = stream.readByte();
+
+		poly.intensity = stream.readSint16LE();
+		int16 normal = -1;
+		if (poly.materialType == MAT_FLAT || poly.materialType == MAT_GRANIT) {
+			normal = stream.readSint16LE();
+		}
+
+		poly.indices.reserve(numVertices);
+		poly.normals.reserve(numVertices);
+		for (int k = 0; k < numVertices; ++k) {
+			if (poly.materialType >= MAT_GOURAUD) {
+				normal = stream.readSint16LE();
+			}
+			const uint16 vertexIndex = stream.readUint16LE() / 6;
+			poly.indices.push_back(vertexIndex);
+			poly.normals.push_back(normal);
+		}
+
+		_polygons.push_back(poly);
+	}
+}
+
+void BodyData::loadLines(Common::SeekableReadStream &stream) {
+	const uint16 numLines = stream.readUint16LE();
+	if (stream.eos())
+		return;
+
+	_lines.reserve(numLines);
+	for (uint16 i = 0; i < numLines; ++i) {
+		BodyLine line;
+		stream.skip(1);
+		line.color = stream.readByte();
+		stream.skip(2);
+		line.vertex1 = stream.readUint16LE() / 6;
+		line.vertex2 = stream.readUint16LE() / 6;
+		_lines.push_back(line);
+	}
+}
+
+void BodyData::loadSpheres(Common::SeekableReadStream &stream) {
+	const uint16 numSpheres = stream.readUint16LE();
+	if (stream.eos())
+		return;
+
+	_spheres.reserve(numSpheres);
+	for (uint16 i = 0; i < numSpheres; ++i) {
+		BodySphere sphere;
+		sphere.fillType = stream.readByte();
+		sphere.color = stream.readUint16LE();
+		stream.readByte();
+		sphere.radius = stream.readUint16LE();
+		sphere.vertex = stream.readUint16LE() / 6;
+		_spheres.push_back(sphere);
+	}
+}
+
+bool BodyData::loadFromStream(Common::SeekableReadStream &stream, bool lba1) {
+	reset();
+	const uint32 streamSize = stream.size();
+
+	if (lba1) {
+		if (streamSize < 0x1C)
+			return false;
+
+		const uint16 flags = stream.readUint16LE();
+		animated = (flags & INFO_ANIM) != 0;
+		bbox.mins.x = stream.readSint16LE();
+		bbox.maxs.x = stream.readSint16LE();
+		bbox.mins.y = stream.readSint16LE();
+		bbox.maxs.y = stream.readSint16LE();
+		bbox.mins.z = stream.readSint16LE();
+		bbox.maxs.z = stream.readSint16LE();
+		offsetToData = stream.readSint16LE();
+
+		if (!bodySeek(stream, 0x1A, streamSize))
+			return false;
+
+		loadVertices(stream, streamSize);
+		if (_vertices.empty())
+			return false;
+		loadBones(stream);
+		loadNormals(stream);
+		loadPolygons(stream);
+		loadLines(stream);
+		loadSpheres(stream);
+	} else {
+		if (streamSize < 0x5C)
+			return false;
+
+		const uint32 flags = stream.readUint32LE();
+		animated = (flags & MASK_OBJECT_ANIMATED) != 0;
+		stream.skip(4);
+		bbox.mins.x = stream.readSint32LE();
+		bbox.maxs.x = stream.readSint32LE();
+		bbox.mins.y = stream.readSint32LE();
+		bbox.maxs.y = stream.readSint32LE();
+		bbox.mins.z = stream.readSint32LE();
+		bbox.maxs.z = stream.readSint32LE();
+
+		const int32 nbGroupes = stream.readSint32LE();
+		const int32 offGroupes = stream.readSint32LE();
+		const int32 nbPoints = stream.readSint32LE();
+		const int32 offPoints = stream.readSint32LE();
+		const int32 nbNormals = stream.readSint32LE();
+		const int32 offNormals = stream.readSint32LE();
+		stream.readSint32LE();
+		stream.readSint32LE();
+		const int32 nbPolys = stream.readSint32LE();
+		const int32 offPolys = stream.readSint32LE();
+		const int32 nbLines = stream.readSint32LE();
+		const int32 offLines = stream.readSint32LE();
+		const int32 nbSpheres = stream.readSint32LE();
+		const int32 offSpheres = stream.readSint32LE();
+		stream.readSint32LE();
+		stream.readSint32LE();
+
+		if (!validateLba2Header(nbGroupes, offGroupes, nbPoints, offPoints, nbNormals, offNormals,
+				nbPolys, offPolys, nbLines, offLines, nbSpheres, offSpheres, streamSize))
+			return false;
+
+		if (!bodySeek(stream, offPoints, streamSize))
+			return false;
+		_vertices.reserve(nbPoints);
+		for (int32 i = 0; i < nbPoints; ++i) {
+			if (stream.pos() + 8 > streamSize)
+				return false;
+			const int16 x = stream.readSint16LE();
+			const int16 y = stream.readSint16LE();
+			const int16 z = stream.readSint16LE();
+			stream.skip(2);
+			_vertices.push_back({x, y, z, 0});
+		}
+
+		if (!bodySeek(stream, offGroupes, streamSize))
+			return false;
+		_bones.reserve(nbGroupes);
+		int16 vertexOffset = 0;
+		for (int32 i = 0; i < nbGroupes; ++i) {
+			if (stream.pos() + 8 > streamSize)
+				return false;
+			const uint16 orgGroupe = stream.readUint16LE();
+			const uint16 orgPoint = stream.readUint16LE();
+			const uint16 nbPts = stream.readUint16LE();
+			const uint16 nbNorm = stream.readUint16LE();
+
+			BodyBone bone;
+			bone.parent = (i == 0) ? 0xffff : orgGroupe;
+			bone.vertex = orgPoint;
+			bone.firstVertex = vertexOffset;
+			bone.numVertices = nbPts;
+			bone.numNormals = nbNorm;
+			bone.initalBoneState.type = TYPE_ROTATE;
+
+			for (int j = 0; j < nbPts; ++j) {
+				if (vertexOffset + j < (int)_vertices.size()) {
+					_vertices[vertexOffset + j].bone = i;
+				}
+			}
+			vertexOffset += nbPts;
+
+			_bones.push_back(bone);
+		}
+
+		if (!bodySeek(stream, offNormals, streamSize))
+			return false;
+		_normals.reserve(nbNormals);
+		for (int32 i = 0; i < nbNormals; ++i) {
+			if (stream.pos() + 8 > streamSize)
+				return false;
+			BodyNormal normal;
+			normal.x = stream.readSint16LE();
+			normal.y = stream.readSint16LE();
+			normal.z = stream.readSint16LE();
+			normal.prenormalizedRange = stream.readUint16LE();
+			_normals.push_back(normal);
+		}
+
+		if (!bodySeek(stream, offPolys, streamSize))
+			return false;
+		if (!loadGroupedPolygonsLba2(stream, streamSize, offPolys, offLines, _polygons))
+			return false;
+
+		if (!bodySeek(stream, offLines, streamSize))
+			return false;
+		_lines.reserve(nbLines);
+		for (int32 i = 0; i < nbLines; ++i) {
+			if (stream.pos() + 8 > streamSize)
+				return false;
+			BodyLine line;
+			stream.skip(2);
+			line.color = (uint8)stream.readUint16LE();
+			line.vertex1 = stream.readUint16LE();
+			line.vertex2 = stream.readUint16LE();
+			_lines.push_back(line);
+		}
+
+		if (!bodySeek(stream, offSpheres, streamSize))
+			return false;
+		_spheres.reserve(nbSpheres);
+		for (int32 i = 0; i < nbSpheres; ++i) {
+			if (stream.pos() + 8 > streamSize)
+				return false;
+			BodySphere sphere;
+			sphere.fillType = (uint8)stream.readUint16LE();
+			sphere.color = stream.readUint16LE();
+			sphere.vertex = stream.readUint16LE();
+			sphere.radius = stream.readUint16LE();
+			_spheres.push_back(sphere);
+		}
+	}
+
+	return !stream.err() && !_vertices.empty() && !_polygons.empty();
+}
+
+bool BodyData::loadFromBuffer(const uint8 *buf, uint32 size, bool lba1) {
+	if (!buf || size == 0)
+		return false;
+	Common::MemoryReadStream stream(buf, size);
+	return loadFromStream(stream, lba1);
+}
+
+} // namespace TwinE
diff --git a/engines/twine/parser/body.h b/engines/twine/parser/body.h
new file mode 100644
index 00000000..94721fb3
--- /dev/null
+++ b/engines/twine/parser/body.h
@@ -0,0 +1,86 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TWINE_PARSER_BODY_H
+#define TWINE_PARSER_BODY_H
+
+#include "common/stream.h"
+#include "engines/twine/parser/bodytypes.h"
+
+namespace TwinE {
+
+class BodyData {
+private:
+	void loadVertices(Common::SeekableReadStream &stream, uint32 streamSize);
+	void loadBones(Common::SeekableReadStream &stream);
+	void loadNormals(Common::SeekableReadStream &stream);
+	void loadPolygons(Common::SeekableReadStream &stream);
+	void loadLines(Common::SeekableReadStream &stream);
+	void loadSpheres(Common::SeekableReadStream &stream);
+
+	Common::Array<BodyPolygon> _polygons;
+	Common::Array<BodyVertex> _vertices;
+	Common::Array<BodySphere> _spheres;
+	Common::Array<BodyNormal> _normals;
+	Common::Array<BodyLine> _lines;
+	Common::Array<BodyBone> _bones;
+
+	void reset();
+
+public:
+	bool animated = false;
+	BoundingBox bbox;
+	int16 offsetToData = 0;
+
+	bool loadFromStream(Common::SeekableReadStream &stream, bool lba1);
+	bool loadFromBuffer(const uint8 *buf, uint32 size, bool lba1);
+
+	static bool isLikelyLba1Buffer(const uint8 *buf, uint32 size);
+	static bool isLikelyLba2Buffer(const uint8 *buf, uint32 size);
+
+	inline uint getNumVertices() const {
+		return _vertices.size();
+	}
+
+	const Common::Array<BodyPolygon> &getPolygons() const {
+		return _polygons;
+	}
+
+	const Common::Array<BodyVertex> &getVertices() const {
+		return _vertices;
+	}
+
+	const Common::Array<BodyNormal> &getNormals() const {
+		return _normals;
+	}
+
+	const BodyNormal &getNormal(int16 normalIdx) const {
+		return _normals[normalIdx];
+	}
+
+	const Common::Array<BodyBone> &getBones() const {
+		return _bones;
+	}
+};
+
+} // namespace TwinE
+
+#endif
diff --git a/engines/twine/parser/bodytypes.h b/engines/twine/parser/bodytypes.h
new file mode 100644
index 00000000..ce798d0e
--- /dev/null
+++ b/engines/twine/parser/bodytypes.h
@@ -0,0 +1,117 @@
+/* ScummVM Tools
+ *
+ * ScummVM Tools is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TWINE_PARSER_BODYTYPES_H
+#define TWINE_PARSER_BODYTYPES_H
+
+#include "common/array.h"
+#include "common/scummsys.h"
+
+namespace TwinE {
+
+enum MaterialType {
+	MAT_TRISTE = 0,
+	MAT_PIERRE = 1,
+	MAT_COPPER = 2,
+	MAT_BOPPER = 3,
+	MAT_MARBRE = 4,
+	MAT_TRANS = 5,
+	MAT_TRAME = 6,
+	MAT_FLAT = 7,
+	MAT_GRANIT = 8,
+	MAT_GOURAUD = 9,
+	MAT_DITHER = 10
+};
+
+enum BoneType : uint16 {
+	TYPE_ROTATE = 0,
+	TYPE_TRANSLATE = 1,
+	TYPE_ZOOM = 2,
+};
+
+struct BoneFrame {
+	BoneType type = TYPE_ROTATE;
+	int16 x = 0;
+	int16 y = 0;
+	int16 z = 0;
+};
+
+struct IVec3 {
+	int32 x = 0;
+	int32 y = 0;
+	int32 z = 0;
+};
+
+struct BoundingBox {
+	IVec3 mins;
+	IVec3 maxs;
+};
+
+struct BodyVertex {
+	int16 x;
+	int16 y;
+	int16 z;
+	uint16 bone;
+};
+
+struct BodyLine {
+	uint8 color;
+	uint16 vertex1;
+	uint16 vertex2;
+};
+
+struct BodySphere {
+	uint8 fillType;
+	uint16 color;
+	uint16 radius;
+	uint16 vertex;
+};
+
+struct BodyBone {
+	uint16 parent;
+	uint16 vertex;
+	int16 firstVertex;
+	int16 numVertices;
+	int32 numNormals;
+	BoneFrame initalBoneState;
+
+	inline bool isRoot() const {
+		return parent == 0xffff;
+	}
+};
+
+struct BodyNormal {
+	int16 x;
+	int16 y;
+	int16 z;
+	uint16 prenormalizedRange;
+};
+
+struct BodyPolygon {
+	Common::Array<uint16> indices;
+	Common::Array<uint16> normals;
+	int8 materialType = 0;
+	int16 intensity = 0;
+};
+
+} // namespace TwinE
+
+#endif

From 9f1d32cc67b9528af70233488b0c589fbec9280e Mon Sep 17 00:00:00 2001
From: Martin Gerhardy <martin.gerhardy@gmail.com>
Date: Wed, 8 Jul 2026 22:45:15 +0200
Subject: [PATCH 2/2] TWINE: add lba2 support

---
 engines/twine/create_twine_translation.cpp | 257 ++++++++++++++++-----
 engines/twine/hqr.cpp                      | 189 +++++++++++----
 engines/twine/hqr.h                        |   6 +-
 3 files changed, 337 insertions(+), 115 deletions(-)

diff --git a/engines/twine/create_twine_translation.cpp b/engines/twine/create_twine_translation.cpp
index 1ba579bd..7e59af5b 100644
--- a/engines/twine/create_twine_translation.cpp
+++ b/engines/twine/create_twine_translation.cpp
@@ -27,10 +27,13 @@
  *   2. Translate the .po file (Poedit, Weblate, etc.)
  *   3. Pack:    create_twine_translation pack <translated.po> <template TEXT.HQR> <output TEXT.HQR> [--lang N]
  *
- * PO format:
- *   msgctxt "bank:2:slot:0:textId:123"
- *   msgid "Original dialog line"
- *   msgstr "Translated dialog line"
+ * PO format (Weblate / game-translations compatible):
+ *   # 1:Options and Menus dialogs
+ *   #: 1:0
+ *   msgid "Normal"
+ *   msgstr "..."
+ *
+ * The first number in the comments is (bank * 2 + 1); the second is the slot index.
  */
 
 #include "common/file.h"
@@ -66,6 +69,43 @@ static const char *const kBankNames[] = {
 	nullptr
 };
 
+static const char *const kBankDisplayNames[] = {
+	"Options and Menus",
+	"Credits",
+	"Inventory, Intro and Holomap",
+	"Citadel Island",
+	"Principal Island",
+	"White Leaf Desert",
+	"Proxima Island",
+	"Rebellion Island",
+	"Hamalayi Mountains - Southern Range",
+	"Hamalayi Mountains - Northern Range",
+	"Tippet Island",
+	"Brundle Island",
+	"Fortress Island",
+	"Polar Island",
+	nullptr
+};
+
+static const char *const kBankDisplayNamesLba2[] = {
+	"Options and Menus",
+	"Credits",
+	"Inventory and Holomap",
+	"Citadel Island",
+	"Unused",
+	"Desert Island",
+	"Emerald Moon",
+	"Otringal",
+	"Celebration Island",
+	"Wannies Island",
+	"Mosquibees Island",
+	"Francos Island",
+	"Island CX",
+	"Undergas elevator",
+	"Volcano Island",
+	nullptr
+};
+
 struct GameTextInfo {
 	bool lba1;
 	int entryCount;
@@ -76,9 +116,26 @@ struct GameTextInfo {
 struct TextLine {
 	int slot;
 	int16_t textId;
+	uint8_t flag;
 	std::string text;
 };
 
+struct TextBankIndices {
+	int ordIndex;
+	int lbtIndex;
+};
+
+static TextBankIndices getTextBankIndices(const GameTextInfo &info, int bank, int language) {
+	const int base = bank * 2 + info.entryCount * language;
+	TextBankIndices indices;
+	indices.lbtIndex = base;
+	if (!info.lba1 && bank == 0)
+		indices.ordIndex = base + 3;
+	else
+		indices.ordIndex = base + 1;
+	return indices;
+}
+
 static void printUsage(const char *bin) {
 	printf("LBA TEXT.HQR translation tool\n\n");
 	printf("Usage:\n");
@@ -276,13 +333,18 @@ static bool parseTextBank(const uint8 *ordData, int32 ordSize, const uint8 *lbtD
 		if (end >= (uint16)lbtSize)
 			break;
 
-		if (!lba1)
-			++start;
+		uint8 flag = 0;
+		uint16 textStart = start;
+		if (!lba1) {
+			if (textStart < lbtSize)
+				flag = lbtData[textStart];
+			++textStart;
+		}
 
 		std::string result;
-		if (start < lbtSize && end > start) {
-			lbtStream.seek(start);
-			for (int32 i = start; i < (int32)end - 1 && i < lbtSize; ++i) {
+		if (textStart < lbtSize && end > textStart) {
+			lbtStream.seek(textStart);
+			for (int32 i = textStart; i < (int32)end - 1 && i < lbtSize; ++i) {
 				const char c = (char)lbtStream.readByte();
 				if (c == '\0')
 					break;
@@ -293,6 +355,7 @@ static bool parseTextBank(const uint8 *ordData, int32 ordSize, const uint8 *lbtD
 		TextLine line;
 		line.slot = entry;
 		line.textId = textId;
+		line.flag = flag;
 		line.text = result;
 		lines.push_back(line);
 
@@ -302,17 +365,19 @@ static bool parseTextBank(const uint8 *ordData, int32 ordSize, const uint8 *lbtD
 	return !lines.empty();
 }
 
-static std::vector<uint8> buildLbtBlob(const std::vector<std::string> &strings, bool lba1) {
+static std::vector<uint8> buildLbtBlob(const std::vector<TextLine> &lines, bool lba1) {
 	std::vector<uint16_t> offsets;
 	std::vector<uint8> stringData;
 
-	const uint16_t tableSize = (uint16_t)((strings.size() + 1) * 2);
+	const uint16_t tableSize = (uint16_t)((lines.size() + 1) * 2);
 	uint16_t pos = tableSize;
 
-	for (size_t i = 0; i < strings.size(); i++) {
+	for (const TextLine &line : lines) {
 		const uint16_t stored = lba1 ? pos : (uint16_t)(pos - 1);
 		offsets.push_back(stored);
-		for (unsigned char c : strings[i])
+		if (!lba1)
+			stringData.push_back(line.flag);
+		for (unsigned char c : line.text)
 			stringData.push_back(c);
 		stringData.push_back(0);
 		pos = (uint16_t)(tableSize + stringData.size());
@@ -329,9 +394,6 @@ static std::vector<uint8> buildLbtBlob(const std::vector<std::string> &strings,
 	return out;
 }
 
-static int langBaseIndex(int bank, int language, int entryCount) {
-	return bank * 2 + entryCount * language;
-}
 
 static const char *bankName(int bank) {
 	if (bank >= 0 && kBankNames[bank])
@@ -339,6 +401,36 @@ static const char *bankName(int bank) {
 	return "unknown";
 }
 
+static const char *bankDisplayName(int bank, bool lba1) {
+	const char *const *names = lba1 ? kBankDisplayNames : kBankDisplayNamesLba2;
+	if (bank >= 0 && names[bank])
+		return names[bank];
+	return bankName(bank);
+}
+
+static int bankFromDisplaySection(const char *section, bool lba1) {
+	if (!section)
+		return -1;
+
+	const char *const *names = lba1 ? kBankDisplayNames : kBankDisplayNamesLba2;
+	for (int bank = 0; names[bank]; bank++) {
+		const char *name = names[bank];
+		const size_t nameLen = strlen(name);
+		if (strncmp(section, name, nameLen) == 0)
+			return bank;
+	}
+	// Accept LBA1 section names when packing LBA2 PO files from mixed sources.
+	if (!lba1) {
+		for (int bank = 0; kBankDisplayNames[bank]; bank++) {
+			const char *name = kBankDisplayNames[bank];
+			const size_t nameLen = strlen(name);
+			if (strncmp(section, name, nameLen) == 0)
+				return bank;
+		}
+	}
+	return -1;
+}
+
 static int doExtract(const Common::Filename &textFile, const char *outPath, const GameTextInfo &info, int language) {
 	if (language < 0 || language >= info.numLanguages) {
 		fprintf(stderr, "Invalid language index %d (available: 0-%d)\n", language, info.numLanguages - 1);
@@ -351,8 +443,9 @@ static int doExtract(const Common::Filename &textFile, const char *outPath, cons
 		return 1;
 	}
 
-	fprintf(out, "# Little Big Adventure TEXT.HQR translation file\n");
+	fprintf(out, "# Little Big Adventure %d language file\n", info.lba1 ? 1 : 2);
 	fprintf(out, "# Copyright (C) ScummVM Team\n");
+	fprintf(out, "# This file is distributed under the same license as the ScummVM package.\n");
 	fprintf(out, "#\n");
 	fprintf(out, "msgid \"\"\n");
 	fprintf(out, "msgstr \"\"\n");
@@ -364,9 +457,9 @@ static int doExtract(const Common::Filename &textFile, const char *outPath, cons
 
 	int totalEntries = 0;
 	for (int bank = 0; bank < info.numBanks; bank++) {
-		const int baseIndex = langBaseIndex(bank, language, info.entryCount);
-		const int lbtIndex = baseIndex;
-		const int ordIndex = baseIndex + 1;
+		const TextBankIndices indices = getTextBankIndices(info, bank, language);
+		const int lbtIndex = indices.lbtIndex;
+		const int ordIndex = indices.ordIndex;
 
 		TwinE::HQR::HqrPackEntry ordEntry;
 		TwinE::HQR::HqrPackEntry lbtEntry;
@@ -386,11 +479,10 @@ static int doExtract(const Common::Filename &textFile, const char *outPath, cons
 			continue;
 		}
 
-		fprintf(out, "#. bank: %d (%s)\n", bank, bankName(bank));
+		const int bankRef = bank * 2 + 1;
 		for (const TextLine &line : lines) {
-			if (line.text.empty())
-				continue;
-			fprintf(out, "msgctxt \"bank:%d:slot:%d:textId:%d\"\n", bank, line.slot, (int)line.textId);
+			fprintf(out, "# %d:%s dialogs\n", bankRef, bankDisplayName(bank, info.lba1));
+			fprintf(out, "#: %d:%d\n", bankRef, line.slot);
 			fprintf(out, "msgid \"%s\"\n", poEscape(cp850ToUtf8(line.text)).c_str());
 			fprintf(out, "msgstr \"\"\n\n");
 			totalEntries++;
@@ -425,15 +517,16 @@ static int doPack(const char *poPath, const Common::Filename &templateFile, cons
 	char buf[8192];
 	int currentBank = -1;
 	int currentSlot = -1;
+	bool hasEntry = false;
 	bool inMsgstr = false;
 	std::string currentMsgstr;
 
 	auto flushEntry = [&]() {
-		if (currentBank >= 0 && currentSlot >= 0 && !currentMsgstr.empty()) {
+		if (hasEntry && currentBank >= 0 && currentSlot >= 0 && !currentMsgstr.empty()) {
 			translations[std::make_pair(currentBank, currentSlot)] = poUnescape(currentMsgstr);
 		}
-		currentBank = -1;
 		currentSlot = -1;
+		hasEntry = false;
 		currentMsgstr.clear();
 		inMsgstr = false;
 	};
@@ -443,12 +536,35 @@ static int doPack(const char *poPath, const Common::Filename &templateFile, cons
 		while (len > 0 && (buf[len - 1] == '\n' || buf[len - 1] == '\r'))
 			buf[--len] = '\0';
 
+		if (buf[0] == '#' && buf[1] == ' ') {
+			const char *section = strchr(buf + 2, ':');
+			if (section) {
+				flushEntry();
+				section++;
+				const int bank = bankFromDisplaySection(section, info.lba1);
+				if (bank >= 0)
+					currentBank = bank;
+			}
+			continue;
+		}
+		if (strncmp(buf, "#: ", 3) == 0) {
+			flushEntry();
+			int refId = 0, slot = 0;
+			if (sscanf(buf + 3, "%d:%d", &refId, &slot) == 2) {
+				currentSlot = slot;
+				if (currentBank < 0 && refId > 0)
+					currentBank = (refId - 1) / 2;
+				hasEntry = true;
+			}
+			continue;
+		}
 		if (strncmp(buf, "msgctxt \"", 9) == 0) {
 			flushEntry();
 			int bank = 0, slot = 0, textId = 0;
 			if (sscanf(buf + 9, "bank:%d:slot:%d:textId:%d", &bank, &slot, &textId) == 3) {
 				currentBank = bank;
 				currentSlot = slot;
+				hasEntry = true;
 				(void)textId;
 			}
 			continue;
@@ -478,68 +594,83 @@ static int doPack(const char *poPath, const Common::Filename &templateFile, cons
 	flushEntry();
 	fclose(in);
 
-	const int32 numEntries = TwinE::HQR::numEntries(templateFile);
-	std::vector<TwinE::HQR::HqrPackEntry> entries((size_t)numEntries);
-
-	for (int32 i = 0; i < numEntries; i++) {
-		if (!TwinE::HQR::loadHqrEntry(templateFile, i, entries[(size_t)i])) {
-			fprintf(stderr, "Failed to load template entry %d\n", (int)i);
-			return 1;
+	if (translations.empty()) {
+		const Common::Filename outFile(outPath);
+		const Common::Filename inFile(templateFile);
+		if (inFile.getFullPath() != outFile.getFullPath()) {
+			if (!TwinE::HQR::copyHqrFile(templateFile, outFile)) {
+				fprintf(stderr, "Failed to copy %s to %s\n", templateFile.getFullPath().c_str(), outPath);
+				return 1;
+			}
 		}
+		printf("Packed 0 text banks for language %d into %s (unchanged)\n", language, outPath);
+		return 0;
 	}
 
+	std::map<int32_t, std::vector<uint8>> patches;
 	int replacedBanks = 0;
+
 	for (int bank = 0; bank < info.numBanks; bank++) {
-		const int baseIndex = langBaseIndex(bank, language, info.entryCount);
-		const int lbtIndex = baseIndex;
-		const int ordIndex = baseIndex + 1;
-		if (ordIndex < 0 || lbtIndex >= numEntries)
-			continue;
+		const TextBankIndices indices = getTextBankIndices(info, bank, language);
+		const int lbtIndex = indices.lbtIndex;
+		const int ordIndex = indices.ordIndex;
 
-		TwinE::HQR::HqrPackEntry &ordEntry = entries[(size_t)ordIndex];
-		TwinE::HQR::HqrPackEntry &lbtEntry = entries[(size_t)lbtIndex];
-		if (ordEntry.blank || ordEntry.data.empty())
+		TwinE::HQR::HqrPackEntry ordEntry;
+		TwinE::HQR::HqrPackEntry lbtEntry;
+		if (!TwinE::HQR::loadHqrEntry(templateFile, ordIndex, ordEntry) || ordEntry.blank)
+			continue;
+		if (!TwinE::HQR::loadHqrEntry(templateFile, lbtIndex, lbtEntry) || lbtEntry.blank)
 			continue;
 
 		std::vector<TextLine> lines;
-		if (lbtEntry.blank) {
-			// Create a new LBT from ORD only.
-			const int numIdxEntries = (int)(ordEntry.data.size() / 2);
-			lines.reserve(numIdxEntries);
-			for (int slot = 0; slot < numIdxEntries; slot++) {
-				TextLine line;
-				line.slot = slot;
-				line.textId = (int16_t)(ordEntry.data[slot * 2] | (ordEntry.data[slot * 2 + 1] << 8));
-				line.text.clear();
-				lines.push_back(line);
-			}
-		} else if (!parseTextBank(ordEntry.data.data(), (int32)ordEntry.data.size(), lbtEntry.data.data(),
+		if (!parseTextBank(ordEntry.data.data(), (int32)ordEntry.data.size(), lbtEntry.data.data(),
 					(int32)lbtEntry.data.size(), info.lba1, lines)) {
 			fprintf(stderr, "Warning: failed to parse bank %d (%s), skipping\n", bank, bankName(bank));
 			continue;
 		}
 
-		std::vector<std::string> packedStrings;
-		packedStrings.reserve(lines.size());
-		for (const TextLine &line : lines) {
-			std::string translated = line.text;
+		bool changed = false;
+		for (TextLine &line : lines) {
 			auto it = translations.find(std::make_pair(bank, line.slot));
-			if (it != translations.end() && !it->second.empty())
-				translated = it->second;
-			packedStrings.push_back(utf8ToCp850(translated));
+			if (it != translations.end()) {
+				const std::string packed = utf8ToCp850(it->second);
+				if (packed != line.text) {
+					line.text = packed;
+					changed = true;
+				}
+			}
 		}
 
-		lbtEntry.blank = false;
-		lbtEntry.data = buildLbtBlob(packedStrings, info.lba1);
+		if (!changed)
+			continue;
+
+		patches[lbtIndex] = TwinE::HQR::makeUncompressedDiskBlock(buildLbtBlob(lines, info.lba1));
 		replacedBanks++;
 	}
 
 	const Common::Filename outFile(outPath);
-	if (!TwinE::HQR::writeHqrArchive(outFile, entries)) {
+	const Common::Filename inFile(templateFile);
+	Common::Filename writeTarget(outPath);
+	std::string tempPath;
+	const bool inPlace = (inFile.getFullPath() == outFile.getFullPath());
+
+	if (inPlace && !patches.empty()) {
+		tempPath = std::string(outPath) + ".tmp";
+		writeTarget = Common::Filename(tempPath.c_str());
+	}
+
+	if (!TwinE::HQR::patchHqrArchive(templateFile, writeTarget, patches)) {
 		fprintf(stderr, "Failed to write %s\n", outPath);
 		return 1;
 	}
 
+	if (inPlace && !patches.empty()) {
+		if (rename(tempPath.c_str(), outPath) != 0) {
+			fprintf(stderr, "Failed to replace %s\n", outPath);
+			return 1;
+		}
+	}
+
 	printf("Packed %d text banks for language %d into %s\n", replacedBanks, language, outPath);
 	return 0;
 }
diff --git a/engines/twine/hqr.cpp b/engines/twine/hqr.cpp
index 457f17cf..11cc47ef 100644
--- a/engines/twine/hqr.cpp
+++ b/engines/twine/hqr.cpp
@@ -25,6 +25,8 @@
 #include "common/substream.h"
 #include "common/memstream.h"
 
+#include <string.h>
+
 namespace TwinE {
 
 namespace HQR {
@@ -127,7 +129,7 @@ int32 getEntry(uint8 *ptr, const Common::Filename &filename, int32 index) {
 	file.seek(4 + index * 4, SEEK_SET);
 	uint32 offsetToData = file.readUint32LE();
 
-	if (offsetToData == 0)
+	if (offsetToData == 0 || offsetToData >= file.size())
 		return 0;
 
 	file.seek(offsetToData, SEEK_SET);
@@ -174,7 +176,13 @@ int32 entrySize(const Common::Filename &filename, int32 index) {
 	file.seek(4 + index * 4, SEEK_SET);
 	uint32 offsetToData = file.readUint32LE();
 
+	if (offsetToData == 0 || offsetToData >= file.size())
+		return 0;
+
 	file.seek(offsetToData, SEEK_SET);
+	if ((uint32)file.pos() + 4u > file.size())
+		return 0;
+
 	uint32 realSize = file.readUint32LE();
 
 	return realSize;
@@ -293,6 +301,20 @@ bool loadHqrEntry(const Common::Filename &filename, int32 index, HqrPackEntry &o
 	out.blank = true;
 	out.data.clear();
 
+	uint8 *data = nullptr;
+	const int32 size = getAllocEntry(&data, filename, index);
+	if (size <= 0 || !data)
+		return true;
+
+	out.blank = false;
+	out.data.assign(data, data + size);
+	free(data);
+	return true;
+}
+
+static bool readRawDiskBlock(const Common::Filename &filename, int32 index, std::vector<uint8> &out) {
+	out.clear();
+
 	Common::File file;
 	file.open(filename, "r");
 	if (!file.isOpen())
@@ -304,75 +326,140 @@ bool loadHqrEntry(const Common::Filename &filename, int32 index, HqrPackEntry &o
 
 	file.seek(4 + index * 4, SEEK_SET);
 	const uint32 offsetToData = file.readUint32LE();
-	if (offsetToData == 0)
-		return true;
+	if (offsetToData == 0 || offsetToData >= file.size())
+		return false;
 
-	uint8 *data = nullptr;
-	const int32 size = getAllocEntry(&data, filename, index);
-	if (size <= 0 || !data)
+	file.seek(offsetToData, SEEK_SET);
+	if ((uint32)file.pos() + 10u > file.size())
 		return false;
 
-	out.blank = false;
-	out.data.assign(data, data + size);
-	free(data);
+	const uint32 realSize = file.readUint32LE();
+	const uint32 compSize = file.readUint32LE();
+	const uint16 mode = file.readUint16LE();
+	const uint32 payloadSize = (mode == 0) ? realSize : compSize;
+	if ((uint32)file.pos() + payloadSize > file.size())
+		return false;
+
+	out.resize(10 + payloadSize);
+	out[0] = (uint8)(realSize);
+	out[1] = (uint8)(realSize >> 8);
+	out[2] = (uint8)(realSize >> 16);
+	out[3] = (uint8)(realSize >> 24);
+	out[4] = (uint8)(compSize);
+	out[5] = (uint8)(compSize >> 8);
+	out[6] = (uint8)(compSize >> 16);
+	out[7] = (uint8)(compSize >> 24);
+	out[8] = (uint8)(mode);
+	out[9] = (uint8)(mode >> 8);
+	file.read_throwsOnError(out.data() + 10, payloadSize);
 	return true;
 }
 
-bool writeHqrArchive(const Common::Filename &filename, const std::vector<HqrPackEntry> &entries) {
-	if (entries.empty())
+bool copyHqrFile(const Common::Filename &src, const Common::Filename &dst) {
+	Common::File in;
+	in.open(src, "r");
+	if (!in.isOpen())
 		return false;
 
-	const size_t numEntries = entries.size();
-	const uint32 headerSize = (uint32)((numEntries + 1) * 4);
-	std::vector<uint8> file(headerSize, 0);
+	const int64 size = in.size();
+	if (size <= 0)
+		return false;
 
-	file[0] = (uint8)(headerSize);
-	file[1] = (uint8)(headerSize >> 8);
-	file[2] = (uint8)(headerSize >> 16);
-	file[3] = (uint8)(headerSize >> 24);
+	std::vector<uint8> buf((size_t)size);
+	in.read_throwsOnError(buf.data(), (uint32)size);
+	in.close();
 
-	uint32 dataOffset = headerSize;
-	std::vector<uint32> offsets(numEntries, 0);
-
-	for (size_t i = 0; i + 1 < numEntries; i++) {
-		if (entries[i].blank || entries[i].data.empty())
-			continue;
-
-		offsets[i] = dataOffset;
-
-		const uint32 realSize = (uint32)entries[i].data.size();
-		file.push_back((uint8)(realSize));
-		file.push_back((uint8)(realSize >> 8));
-		file.push_back((uint8)(realSize >> 16));
-		file.push_back((uint8)(realSize >> 24));
-		file.push_back((uint8)(realSize));
-		file.push_back((uint8)(realSize >> 8));
-		file.push_back((uint8)(realSize >> 16));
-		file.push_back((uint8)(realSize >> 24));
-		file.push_back(0);
-		file.push_back(0);
-		file.insert(file.end(), entries[i].data.begin(), entries[i].data.end());
-
-		dataOffset += 10 + realSize;
+	Common::File out;
+	out.open(dst, "wb");
+	if (!out.isOpen())
+		return false;
+
+	out.write(buf.data(), (uint32)size);
+	return true;
+}
+
+std::vector<uint8> makeUncompressedDiskBlock(const std::vector<uint8> &data) {
+	std::vector<uint8> out(10 + data.size());
+	const uint32 realSize = (uint32)data.size();
+	out[0] = (uint8)(realSize);
+	out[1] = (uint8)(realSize >> 8);
+	out[2] = (uint8)(realSize >> 16);
+	out[3] = (uint8)(realSize >> 24);
+	out[4] = out[0];
+	out[5] = out[1];
+	out[6] = out[2];
+	out[7] = out[3];
+	out[8] = 0;
+	out[9] = 0;
+	if (!data.empty())
+		memcpy(out.data() + 10, data.data(), data.size());
+	return out;
+}
+
+bool patchHqrArchive(const Common::Filename &templateFile, const Common::Filename &outFile,
+		const std::map<int32_t, std::vector<uint8>> &patches) {
+	if (patches.empty())
+		return copyHqrFile(templateFile, outFile);
+
+	Common::File in;
+	in.open(templateFile, "r");
+	if (!in.isOpen())
+		return false;
+
+	const uint32 headerSize = in.readUint32LE();
+	const int32 numEntries = (int32)(headerSize / 4) - 1;
+	if (numEntries <= 0)
+		return false;
+
+	std::vector<uint32> oldOffsets((size_t)numEntries + 1, 0);
+	for (int32 i = 0; i <= numEntries; i++) {
+		in.seek(4 + (uint32)i * 4, SEEK_SET);
+		oldOffsets[(size_t)i] = in.readUint32LE();
 	}
 
-	offsets[numEntries - 1] = dataOffset;
+	std::vector<uint32> newOffsets((size_t)numEntries + 1, 0);
+	std::vector<uint8> fileData;
+	fileData.reserve(in.size());
+	fileData.resize(headerSize, 0);
+	fileData[0] = (uint8)(headerSize);
+	fileData[1] = (uint8)(headerSize >> 8);
+	fileData[2] = (uint8)(headerSize >> 16);
+	fileData[3] = (uint8)(headerSize >> 24);
+
+	uint32 dataOffset = headerSize;
+	std::vector<uint8> block;
+
+	for (int32 i = 0; i < numEntries; i++) {
+		const auto patchIt = patches.find(i);
+		if (patchIt != patches.end()) {
+			block = patchIt->second;
+		} else if (!readRawDiskBlock(templateFile, i, block)) {
+			block.clear();
+		}
 
-	for (size_t i = 0; i < numEntries; i++) {
-		const uint32 off = offsets[i];
-		const size_t pos = 4 + i * 4;
-		file[pos] = (uint8)(off);
-		file[pos + 1] = (uint8)(off >> 8);
-		file[pos + 2] = (uint8)(off >> 16);
-		file[pos + 3] = (uint8)(off >> 24);
+		if (!block.empty()) {
+			newOffsets[(size_t)i] = dataOffset;
+			fileData.insert(fileData.end(), block.begin(), block.end());
+			dataOffset += (uint32)block.size();
+		}
+	}
+	newOffsets[(size_t)numEntries] = dataOffset;
+
+	for (int32 i = 0; i <= numEntries; i++) {
+		const uint32 off = newOffsets[(size_t)i];
+		const size_t pos = 4 + (size_t)i * 4;
+		fileData[pos] = (uint8)(off);
+		fileData[pos + 1] = (uint8)(off >> 8);
+		fileData[pos + 2] = (uint8)(off >> 16);
+		fileData[pos + 3] = (uint8)(off >> 24);
 	}
 
 	Common::File out;
-	out.open(filename, "wb");
+	out.open(outFile, "wb");
 	if (!out.isOpen())
 		return false;
 
-	out.write(file.data(), file.size());
+	out.write(fileData.data(), fileData.size());
 	return true;
 }
 
diff --git a/engines/twine/hqr.h b/engines/twine/hqr.h
index 9d713e27..3444c703 100644
--- a/engines/twine/hqr.h
+++ b/engines/twine/hqr.h
@@ -25,6 +25,7 @@
 #include "common/stream.h"
 #include "common/file.h"
 
+#include <map>
 #include <vector>
 
 namespace TwinE {
@@ -99,7 +100,10 @@ struct HqrPackEntry {
 };
 
 bool loadHqrEntry(const Common::Filename &filename, int32 index, HqrPackEntry &out);
-bool writeHqrArchive(const Common::Filename &filename, const std::vector<HqrPackEntry> &entries);
+bool copyHqrFile(const Common::Filename &src, const Common::Filename &dst);
+std::vector<uint8> makeUncompressedDiskBlock(const std::vector<uint8> &data);
+bool patchHqrArchive(const Common::Filename &templateFile, const Common::Filename &outFile,
+		const std::map<int32_t, std::vector<uint8>> &patches);
 
 } // namespace HQR