mirror of
https://github.com/open-goal/jak-project
synced 2026-06-13 14:07:02 -04:00
texture decoding
This commit is contained in:
water
@@ -81,6 +81,8 @@ set(RUNTIME_SOURCE
|
||||
graphics/opengl_renderer/DirectRenderer.cpp
|
||||
graphics/opengl_renderer/OpenGLRenderer.cpp
|
||||
graphics/opengl_renderer/Shader.cpp
|
||||
graphics/texture/TextureConverter.cpp
|
||||
graphics/texture/TexturePool.cpp
|
||||
system/vm/dmac.cpp
|
||||
system/vm/vm.cpp)
|
||||
|
||||
|
||||
+17
-1
@@ -16,6 +16,7 @@
|
||||
#include "common/goal_constants.h"
|
||||
#include "common/util/Timer.h"
|
||||
#include "game/graphics/opengl_renderer/OpenGLRenderer.h"
|
||||
#include "game/graphics/texture/TexturePool.h"
|
||||
|
||||
namespace Gfx {
|
||||
|
||||
@@ -31,10 +32,16 @@ struct GraphicsData {
|
||||
bool has_data_to_render = false;
|
||||
FixedChunkDmaCopier dma_copier;
|
||||
|
||||
// texture pool
|
||||
std::shared_ptr<TexturePool> texture_pool;
|
||||
|
||||
// temporary opengl renderer
|
||||
OpenGLRenderer ogl_renderer;
|
||||
|
||||
GraphicsData() : dma_copier(EE_MAIN_MEM_SIZE) {}
|
||||
GraphicsData()
|
||||
: dma_copier(EE_MAIN_MEM_SIZE),
|
||||
texture_pool(std::make_shared<TexturePool>()),
|
||||
ogl_renderer(texture_pool) {}
|
||||
};
|
||||
|
||||
std::unique_ptr<GraphicsData> g_gfx_data;
|
||||
@@ -186,4 +193,13 @@ void send_chain(const void* data, u32 offset) {
|
||||
}
|
||||
}
|
||||
|
||||
void texture_upload_now(const u8* tpage, int mode, u32 s7_ptr) {
|
||||
if (g_gfx_data) {
|
||||
// just pass it to the texture pool.
|
||||
// the texture pool will take care of locking.
|
||||
// we don't want to lock here for the entire duration of the conversion.
|
||||
g_gfx_data->texture_pool->handle_upload_now(tpage, mode, g_ee_main_mem, s7_ptr);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace Gfx
|
||||
|
||||
@@ -21,6 +21,7 @@ u32 Exit();
|
||||
|
||||
u32 vsync();
|
||||
void send_chain(const void* data, u32 offset);
|
||||
void texture_upload_now(const u8* tpage, int mode, u32 s7_ptr);
|
||||
|
||||
} // namespace Gfx
|
||||
|
||||
|
||||
@@ -1,8 +1,10 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include "game/graphics/dma/dma_chain_read.h"
|
||||
#include "game/graphics/opengl_renderer/Shader.h"
|
||||
#include "game/graphics/texture/TexturePool.h"
|
||||
|
||||
/*!
|
||||
* Matches the bucket-id enum in GOAL
|
||||
@@ -21,7 +23,10 @@ enum class BucketId {
|
||||
* This allows bucket renders to share textures and shaders.
|
||||
*/
|
||||
struct SharedRenderState {
|
||||
explicit SharedRenderState(std::shared_ptr<TexturePool> _texture_pool)
|
||||
: texture_pool(_texture_pool) {}
|
||||
ShaderLibrary shaders;
|
||||
std::shared_ptr<TexturePool> texture_pool;
|
||||
u32 buckets_base = 0; // address of buckets array.
|
||||
u32 next_bucket = 0; // address of next bucket that we haven't started rendering in buckets
|
||||
u32 default_regs_buffer = 0; // address of the default regs chain.
|
||||
|
||||
@@ -20,7 +20,8 @@ void GLAPIENTRY opengl_error_callback(GLenum /*source*/,
|
||||
lg::error("OpenGL error: {}", message);
|
||||
}
|
||||
|
||||
OpenGLRenderer::OpenGLRenderer() {
|
||||
OpenGLRenderer::OpenGLRenderer(std::shared_ptr<TexturePool> texture_pool)
|
||||
: m_render_state(texture_pool) {
|
||||
// setup OpenGL errors
|
||||
glEnable(GL_DEBUG_OUTPUT);
|
||||
glDebugMessageCallback(opengl_error_callback, nullptr);
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
|
||||
class OpenGLRenderer {
|
||||
public:
|
||||
OpenGLRenderer();
|
||||
OpenGLRenderer(std::shared_ptr<TexturePool> texture_pool);
|
||||
void render(DmaFollower dma, int window_width_px, int window_height_px);
|
||||
|
||||
private:
|
||||
|
||||
@@ -0,0 +1,414 @@
|
||||
#include "TextureConverter.h"
|
||||
#include "common/util/assert.h"
|
||||
#include "third-party/fmt/core.h"
|
||||
#include "common/util/FileUtil.h"
|
||||
|
||||
/*!
|
||||
* Convert from a pixel location in a texture (x, y, texture buffer width) to VRAM address (byte).
|
||||
* Uses the PSMCT32 format.
|
||||
* This format is used either to store 8-bit RGBA (texture palettes) or to copy memory.
|
||||
* See Ch. 8, Details of GS Local Memory for these tables.
|
||||
*/
|
||||
u32 psmct32_addr(u32 x, u32 y, u32 width) {
|
||||
// XXX_col refers to which XXX you're in (screen)
|
||||
// XXX refers to which XXX you're in (memory)
|
||||
// XXX_x refers to the pixel within the XXX
|
||||
|
||||
// first, determine the page
|
||||
u32 pages_per_row = width / 64;
|
||||
u32 page_col = x / 64;
|
||||
u32 page_row = y / 32;
|
||||
u32 page_x = x % 64;
|
||||
u32 page_y = y % 32;
|
||||
u32 page = page_col + page_row * pages_per_row;
|
||||
|
||||
// next the block
|
||||
u32 block_col = page_x / 8;
|
||||
u32 block_row = page_y / 8;
|
||||
u32 block_x = page_x % 8;
|
||||
u32 block_y = page_y % 8;
|
||||
const u32 psm32_table[4][8] = {{0, 1, 4, 5, 16, 17, 20, 21},
|
||||
{2, 3, 6, 7, 18, 19, 22, 23},
|
||||
{8, 9, 12, 13, 24, 25, 28, 29},
|
||||
{10, 11, 14, 15, 26, 27, 30, 31}};
|
||||
|
||||
u32 block = psm32_table[block_row][block_col];
|
||||
|
||||
// next the column (there's only one "column" per column)
|
||||
u32 col_row = block_y / 2;
|
||||
u32 col_y = block_y % 2;
|
||||
u32 col_x = block_x;
|
||||
|
||||
// next the pixel
|
||||
const u32 psm32_pix_table[2][8] = {{0, 1, 4, 5, 8, 9, 12, 13}, {2, 3, 6, 7, 10, 11, 14, 15}};
|
||||
u32 pixel = psm32_pix_table[col_y][col_x];
|
||||
|
||||
// now the sum
|
||||
return ((page * 64 * 32) + (block * 8 * 8) + (col_row * 8 * 2) + pixel) * 4;
|
||||
}
|
||||
|
||||
/*!
|
||||
* Convert from a pixel location in a texture (x, y, texture buffer width) to VRAM address (byte).
|
||||
* Uses the PSMT8 format.
|
||||
* This format is used either to store 8-bit palette indices, used in most textures.
|
||||
* See Ch. 8, Details of GS Local Memory for these tables.
|
||||
*/
|
||||
u32 psmt8_addr(u32 x, u32 y, u32 width) {
|
||||
// page is 128, 64
|
||||
// block is 16, 16
|
||||
// column is 16, 4
|
||||
|
||||
// first determine the page
|
||||
u32 pages_per_row = width / 128;
|
||||
u32 page_col = x / 128;
|
||||
u32 page_row = y / 64;
|
||||
u32 page_x = x % 128;
|
||||
u32 page_y = y % 64;
|
||||
u32 page = page_col + page_row * pages_per_row;
|
||||
|
||||
// next block
|
||||
u32 block_col = page_x / 16;
|
||||
u32 block_row = page_y / 16;
|
||||
u32 block_x = page_x % 16;
|
||||
u32 block_y = page_y % 16;
|
||||
const u32 psm32_table[4][8] = {{0, 1, 4, 5, 16, 17, 20, 21},
|
||||
{2, 3, 6, 7, 18, 19, 22, 23},
|
||||
{8, 9, 12, 13, 24, 25, 28, 29},
|
||||
{10, 11, 14, 15, 26, 27, 30, 31}};
|
||||
u32 block = psm32_table[block_row][block_col]; // it's the same table!!!
|
||||
|
||||
// both columns and pixels within columns.
|
||||
const uint8_t pix_table[16][16] = {
|
||||
{0, 4, 16, 20, 32, 36, 48, 52, 2, 6, 18, 22, 34, 38, 50, 54},
|
||||
{8, 12, 24, 28, 40, 44, 56, 60, 10, 14, 26, 30, 42, 46, 58, 62},
|
||||
{33, 37, 49, 53, 1, 5, 17, 21, 35, 39, 51, 55, 3, 7, 19, 23},
|
||||
{41, 45, 57, 61, 9, 13, 25, 29, 43, 47, 59, 63, 11, 15, 27, 31},
|
||||
{96, 100, 112, 116, 64, 68, 80, 84, 98, 102, 114, 118, 66, 70, 82, 86},
|
||||
{104, 108, 120, 124, 72, 76, 88, 92, 106, 110, 122, 126, 74, 78, 90, 94},
|
||||
{65, 69, 81, 85, 97, 101, 113, 117, 67, 71, 83, 87, 99, 103, 115, 119},
|
||||
{73, 77, 89, 93, 105, 109, 121, 125, 75, 79, 91, 95, 107, 111, 123, 127},
|
||||
{128, 132, 144, 148, 160, 164, 176, 180, 130, 134, 146, 150, 162, 166, 178, 182},
|
||||
{136, 140, 152, 156, 168, 172, 184, 188, 138, 142, 154, 158, 170, 174, 186, 190},
|
||||
{161, 165, 177, 181, 129, 133, 145, 149, 163, 167, 179, 183, 131, 135, 147, 151},
|
||||
{169, 173, 185, 189, 137, 141, 153, 157, 171, 175, 187, 191, 139, 143, 155, 159},
|
||||
{224, 228, 240, 244, 192, 196, 208, 212, 226, 230, 242, 246, 194, 198, 210, 214},
|
||||
{232, 236, 248, 252, 200, 204, 216, 220, 234, 238, 250, 254, 202, 206, 218, 222},
|
||||
{193, 197, 209, 213, 225, 229, 241, 245, 195, 199, 211, 215, 227, 231, 243, 247},
|
||||
{201, 205, 217, 221, 233, 237, 249, 253, 203, 207, 219, 223, 235, 239, 251, 255},
|
||||
};
|
||||
|
||||
u32 pixel = pix_table[block_y][block_x];
|
||||
return (page * 128 * 64) + (block * 16 * 16) + pixel;
|
||||
}
|
||||
|
||||
u32 psmct16_addr(u32 x, u32 y, u32 width) {
|
||||
// page is 64x64
|
||||
// block is 16x8
|
||||
// column is 16x2
|
||||
|
||||
// page
|
||||
u32 pages_per_row = width / 64;
|
||||
u32 page_col = x / 64;
|
||||
u32 page_row = y / 64;
|
||||
u32 page_x = x % 64;
|
||||
u32 page_y = y % 64;
|
||||
u32 page = page_col + page_row * pages_per_row;
|
||||
|
||||
// block
|
||||
u32 block_col = page_x / 16;
|
||||
u32 block_row = page_y / 8;
|
||||
u32 block_x = page_x % 16;
|
||||
u32 block_y = page_y % 8;
|
||||
const u32 psm16_table[8][4] = {{0, 2, 8, 10}, {1, 3, 9, 11}, {4, 6, 12, 14},
|
||||
{5, 7, 13, 15}, {16, 18, 24, 26}, {17, 19, 25, 27},
|
||||
{20, 22, 28, 30}, {21, 23, 29, 31}};
|
||||
u32 block = psm16_table[block_row][block_col];
|
||||
|
||||
const uint8_t pix_tabel[8][16] = {
|
||||
{0, 2, 8, 10, 16, 18, 24, 26, 1, 3, 9, 11, 17, 19, 25, 27},
|
||||
{4, 6, 12, 14, 20, 22, 28, 30, 5, 7, 13, 15, 21, 23, 29, 31},
|
||||
{32, 34, 40, 42, 48, 50, 56, 58, 33, 35, 41, 43, 49, 51, 57, 59},
|
||||
{36, 38, 44, 46, 52, 54, 60, 62, 37, 39, 45, 47, 53, 55, 61, 63},
|
||||
{64, 66, 72, 74, 80, 82, 88, 90, 65, 67, 73, 75, 81, 83, 89, 91},
|
||||
{68, 70, 76, 78, 84, 86, 92, 94, 69, 71, 77, 79, 85, 87, 93, 95},
|
||||
{96, 98, 104, 106, 112, 114, 120, 122, 97, 99, 105, 107, 113, 115, 121, 123},
|
||||
{100, 102, 108, 110, 116, 118, 124, 126, 101, 103, 109, 111, 117, 119, 125, 127},
|
||||
};
|
||||
u32 pixel = pix_tabel[block_y][block_x];
|
||||
return 2 * ((page * 64 * 64) + (block * 16 * 8) + pixel);
|
||||
}
|
||||
|
||||
u32 psmt4_addr_half_byte(u32 x, u32 y, u32 width) {
|
||||
// page is 128, 128
|
||||
// block is 32, 16
|
||||
// column is 32, 4
|
||||
|
||||
// first determine the page
|
||||
u32 pages_per_row = width / 128;
|
||||
u32 page_col = x / 128;
|
||||
u32 page_row = y / 128;
|
||||
u32 page_x = x % 128;
|
||||
u32 page_y = y % 128;
|
||||
u32 page = page_col + page_row * pages_per_row;
|
||||
|
||||
// next block
|
||||
u32 block_col = page_x / 32;
|
||||
u32 block_row = page_y / 16;
|
||||
u32 block_x = page_x % 32;
|
||||
u32 block_y = page_y % 16;
|
||||
const u32 psm4_table[8][4] = {{0, 2, 8, 10}, {1, 3, 9, 11}, {4, 6, 12, 14},
|
||||
{5, 7, 13, 15}, {16, 18, 24, 26}, {17, 19, 25, 27},
|
||||
{20, 22, 28, 30}, {21, 23, 29, 31}};
|
||||
assert(block_row < 8);
|
||||
assert(block_col < 4);
|
||||
u32 block = psm4_table[block_row][block_col]; // it's the same table!!!
|
||||
|
||||
// both columns and pixels within columns.
|
||||
const uint16_t pix_table[16][32] = {
|
||||
{0, 8, 32, 40, 64, 72, 96, 104, 2, 10, 34, 42, 66, 74, 98, 106,
|
||||
4, 12, 36, 44, 68, 76, 100, 108, 6, 14, 38, 46, 70, 78, 102, 110},
|
||||
{16, 24, 48, 56, 80, 88, 112, 120, 18, 26, 50, 58, 82, 90, 114, 122,
|
||||
20, 28, 52, 60, 84, 92, 116, 124, 22, 30, 54, 62, 86, 94, 118, 126},
|
||||
{65, 73, 97, 105, 1, 9, 33, 41, 67, 75, 99, 107, 3, 11, 35, 43,
|
||||
69, 77, 101, 109, 5, 13, 37, 45, 71, 79, 103, 111, 7, 15, 39, 47},
|
||||
{81, 89, 113, 121, 17, 25, 49, 57, 83, 91, 115, 123, 19, 27, 51, 59,
|
||||
85, 93, 117, 125, 21, 29, 53, 61, 87, 95, 119, 127, 23, 31, 55, 63},
|
||||
{192, 200, 224, 232, 128, 136, 160, 168, 194, 202, 226, 234, 130, 138, 162, 170,
|
||||
196, 204, 228, 236, 132, 140, 164, 172, 198, 206, 230, 238, 134, 142, 166, 174},
|
||||
{208, 216, 240, 248, 144, 152, 176, 184, 210, 218, 242, 250, 146, 154, 178, 186,
|
||||
212, 220, 244, 252, 148, 156, 180, 188, 214, 222, 246, 254, 150, 158, 182, 190},
|
||||
{129, 137, 161, 169, 193, 201, 225, 233, 131, 139, 163, 171, 195, 203, 227, 235,
|
||||
133, 141, 165, 173, 197, 205, 229, 237, 135, 143, 167, 175, 199, 207, 231, 239},
|
||||
{145, 153, 177, 185, 209, 217, 241, 249, 147, 155, 179, 187, 211, 219, 243, 251,
|
||||
149, 157, 181, 189, 213, 221, 245, 253, 151, 159, 183, 191, 215, 223, 247, 255},
|
||||
{256, 264, 288, 296, 320, 328, 352, 360, 258, 266, 290, 298, 322, 330, 354, 362,
|
||||
260, 268, 292, 300, 324, 332, 356, 364, 262, 270, 294, 302, 326, 334, 358, 366},
|
||||
{272, 280, 304, 312, 336, 344, 368, 376, 274, 282, 306, 314, 338, 346, 370, 378,
|
||||
276, 284, 308, 316, 340, 348, 372, 380, 278, 286, 310, 318, 342, 350, 374, 382},
|
||||
{321, 329, 353, 361, 257, 265, 289, 297, 323, 331, 355, 363, 259, 267, 291, 299,
|
||||
325, 333, 357, 365, 261, 269, 293, 301, 327, 335, 359, 367, 263, 271, 295, 303},
|
||||
{337, 345, 369, 377, 273, 281, 305, 313, 339, 347, 371, 379, 275, 283, 307, 315,
|
||||
341, 349, 373, 381, 277, 285, 309, 317, 343, 351, 375, 383, 279, 287, 311, 319},
|
||||
{448, 456, 480, 488, 384, 392, 416, 424, 450, 458, 482, 490, 386, 394, 418, 426,
|
||||
452, 460, 484, 492, 388, 396, 420, 428, 454, 462, 486, 494, 390, 398, 422, 430},
|
||||
{464, 472, 496, 504, 400, 408, 432, 440, 466, 474, 498, 506, 402, 410, 434, 442,
|
||||
468, 476, 500, 508, 404, 412, 436, 444, 470, 478, 502, 510, 406, 414, 438, 446},
|
||||
{385, 393, 417, 425, 449, 457, 481, 489, 387, 395, 419, 427, 451, 459, 483, 491,
|
||||
389, 397, 421, 429, 453, 461, 485, 493, 391, 399, 423, 431, 455, 463, 487, 495},
|
||||
{401, 409, 433, 441, 465, 473, 497, 505, 403, 411, 435, 443, 467, 475, 499, 507,
|
||||
405, 413, 437, 445, 469, 477, 501, 509, 407, 415, 439, 447, 471, 479, 503, 511},
|
||||
};
|
||||
|
||||
assert(block_y < 16);
|
||||
assert(block_x < 32);
|
||||
u32 pixel = pix_table[block_y][block_x];
|
||||
return (page * 128 * 128) + (block * 32 * 16) + pixel;
|
||||
}
|
||||
|
||||
u32 rgba16_to_rgba32(u32 in) {
|
||||
float ratio = 255.0 / 31.0;
|
||||
u32 r = (in & 0b11111) * ratio;
|
||||
u32 g = ((in >> 5) & 0b11111) * ratio;
|
||||
u32 b = ((in >> 10) & 0b11111) * ratio;
|
||||
u32 a = (in & 0x8000) * 0x1FE00;
|
||||
|
||||
return a | (b << 16) | (g << 8) | r;
|
||||
}
|
||||
|
||||
TextureConverter::TextureConverter() {
|
||||
m_vram.resize(4 * 1024 * 1024);
|
||||
}
|
||||
|
||||
void TextureConverter::upload(const u8* data, u32 dest, u32 size_vram_words) {
|
||||
// all textures are copied to vram 128 pixels wide, regardless of actual width
|
||||
int copy_width = 128;
|
||||
// scale the copy height to be whatever it needs to be to transfer the right amount of data.
|
||||
int copy_height = size_vram_words / copy_width;
|
||||
fmt::print("upload dest is {}, size is {}\n", dest, copy_height);
|
||||
|
||||
for (int y = 0; y < copy_height; y++) {
|
||||
for (int x = 0; x < copy_width; x++) {
|
||||
// VRAM address (bytes)
|
||||
auto addr32 = psmct32_addr(x, y, copy_width) + dest * 4;
|
||||
|
||||
*(u32*)(m_vram.data() + addr32) = *((const u32*)(data) + (x + y * copy_width));
|
||||
// fmt::print("{} = {}\n", addr32, *(const u32*)(data + (x + y * copy_width)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// texture format enums
|
||||
enum class PSM { PSMCT16 = 0x02, PSMT8 = 0x13, PSMT4 = 0x14 };
|
||||
// clut format enums
|
||||
enum class CPSM { PSMCT32 = 0x0, PSMCT16 = 0x02 };
|
||||
|
||||
void TextureConverter::download_rgba8888(u8* result,
|
||||
u32 vram_addr,
|
||||
u32 goal_tex_width,
|
||||
u32 w,
|
||||
u32 h,
|
||||
u32 psm,
|
||||
u32 clut_psm,
|
||||
u32 clut_vram_addr) {
|
||||
fmt::print("psm: {} cpsm: {}\n", psm, clut_psm);
|
||||
if (psm == int(PSM::PSMT8) && clut_psm == int(CPSM::PSMCT32)) {
|
||||
// this is the only supported texture format for now.
|
||||
|
||||
// will store output pixels, rgba (8888)
|
||||
// std::vector<u32> out;
|
||||
u32 out_offset = 0;
|
||||
|
||||
// width is like the TEX0 register, in 64 texel units.
|
||||
// not sure what the other widths are yet.
|
||||
int read_width = 64 * goal_tex_width;
|
||||
// loop over pixels in output texture image
|
||||
for (int y = 0; y < h; y++) {
|
||||
for (int x = 0; x < w; x++) {
|
||||
// read as the PSMT8 type. The dest field tells us a block offset.
|
||||
auto addr8 = psmt8_addr(x, y, read_width) + vram_addr * 256;
|
||||
u8 value = *(u8*)(m_vram.data() + addr8);
|
||||
// fmt::print("{} {} = {}\n", x, y, value);
|
||||
|
||||
// there's yet another scramble from the CLUT. The palette index turns into an X, Y value
|
||||
// See GS manual 2.7.3 CLUT Storage Mode, IDTEX8 in CSM1 mode.
|
||||
u32 clut_chunk = value / 16;
|
||||
u32 off_in_chunk = value % 16;
|
||||
u8 clx = 0, cly = 0;
|
||||
if (clut_chunk & 1) {
|
||||
clx = 8;
|
||||
}
|
||||
cly = (clut_chunk >> 1) * 2;
|
||||
if (off_in_chunk >= 8) {
|
||||
off_in_chunk -= 8;
|
||||
cly++;
|
||||
}
|
||||
clx += off_in_chunk;
|
||||
|
||||
// the x, y CLUT value is looked up in PSMCT32 mode
|
||||
u32 clut_addr = psmct32_addr(clx, cly, 64) + clut_vram_addr * 256;
|
||||
u32 clut_value = *(u32*)(m_vram.data() + clut_addr);
|
||||
// fmt::print("{} {}\n", clut_addr, clut_value);
|
||||
// out.push_back(clut_value);
|
||||
memcpy(result + out_offset, &clut_value, 4);
|
||||
out_offset += 4;
|
||||
}
|
||||
}
|
||||
|
||||
} else if (psm == int(PSM::PSMT8) && clut_psm == int(CPSM::PSMCT16)) {
|
||||
// will store output pixels, rgba (8888)
|
||||
u32 out_offset = 0;
|
||||
|
||||
// width is like the TEX0 register, in 64 texel units.
|
||||
// not sure what the other widths are yet.
|
||||
int read_width = 64 * goal_tex_width;
|
||||
|
||||
// loop over pixels in output texture image
|
||||
for (int y = 0; y < h; y++) {
|
||||
for (int x = 0; x < w; x++) {
|
||||
// read as the PSMT8 type. The dest field tells us a block offset.
|
||||
auto addr8 = psmt8_addr(x, y, read_width) + vram_addr * 256;
|
||||
u8 value = *(u8*)(m_vram.data() + addr8);
|
||||
|
||||
// there's yet another scramble from the CLUT. The palette index turns into an X, Y value
|
||||
// See GS manual 2.7.3 CLUT Storage Mode, IDTEX8 in CSM1 mode.
|
||||
u32 clut_chunk = value / 16;
|
||||
u32 off_in_chunk = value % 16;
|
||||
u8 clx = 0, cly = 0;
|
||||
if (clut_chunk & 1) {
|
||||
clx = 8;
|
||||
}
|
||||
cly = (clut_chunk >> 1) * 2;
|
||||
if (off_in_chunk >= 8) {
|
||||
off_in_chunk -= 8;
|
||||
cly++;
|
||||
}
|
||||
clx += off_in_chunk;
|
||||
|
||||
// the x, y CLUT value is looked up in PSMCT32 mode
|
||||
u32 clut_addr = psmct16_addr(clx, cly, 64) + clut_vram_addr * 256;
|
||||
u32 clut_value = *(u16*)(m_vram.data() + clut_addr);
|
||||
u32 rgba32 = rgba16_to_rgba32(clut_value);
|
||||
memcpy(result + out_offset, &rgba32, 4);
|
||||
out_offset += 4;
|
||||
}
|
||||
}
|
||||
|
||||
} else if (psm == int(PSM::PSMT4) && clut_psm == int(CPSM::PSMCT16)) {
|
||||
// will store output pixels, rgba (8888)
|
||||
u32 out_offset = 0;
|
||||
|
||||
// width is like the TEX0 register, in 64 texel units.
|
||||
// not sure what the other widths are yet.
|
||||
int read_width = 64 * goal_tex_width;
|
||||
|
||||
// loop over pixels in output texture image
|
||||
for (int y = 0; y < h; y++) {
|
||||
for (int x = 0; x < w; x++) {
|
||||
// read as the PSMT4 type, use half byte addressing
|
||||
auto addr4 = psmt4_addr_half_byte(x, y, read_width) + vram_addr * 512;
|
||||
|
||||
// read (half bytes)
|
||||
u8 value = *(u8*)(m_vram.data() + addr4 / 2);
|
||||
if (addr4 & 1) {
|
||||
value >>= 4;
|
||||
} else {
|
||||
value = value & 0x0f;
|
||||
}
|
||||
|
||||
// there's yet another scramble from the CLUT. The palette index turns into an X, Y value
|
||||
// See GS manual 2.7.3 CLUT Storage Mode, IDTEX4 in CSM1 mode.
|
||||
|
||||
u8 clx = value & 0x7;
|
||||
u8 cly = value >> 3;
|
||||
|
||||
// the x, y CLUT value is looked up in PSMCT16 mode
|
||||
u32 clut_addr = psmct16_addr(clx, cly, 64) + clut_vram_addr * 256;
|
||||
u32 clut_value = *(u16*)(m_vram.data() + clut_addr);
|
||||
u32 rgba32 = rgba16_to_rgba32(clut_value);
|
||||
memcpy(result + out_offset, &rgba32, 4);
|
||||
out_offset += 4;
|
||||
}
|
||||
}
|
||||
} else if (psm == int(PSM::PSMT4) && clut_psm == int(CPSM::PSMCT32)) {
|
||||
// will store output pixels, rgba (8888)
|
||||
u32 out_offset = 0;
|
||||
|
||||
// width is like the TEX0 register, in 64 texel units.
|
||||
// not sure what the other widths are yet.
|
||||
int read_width = 64 * goal_tex_width;
|
||||
|
||||
// loop over pixels in output texture image
|
||||
for (int y = 0; y < h; y++) {
|
||||
for (int x = 0; x < w; x++) {
|
||||
// read as the PSMT4 type, use half byte addressing
|
||||
auto addr4 = psmt4_addr_half_byte(x, y, read_width) + vram_addr * 512;
|
||||
// fmt::print("addr: {}\n", addr4/8);
|
||||
|
||||
// read (half bytes)
|
||||
u8 value = *(u8*)(m_vram.data() + addr4 / 2);
|
||||
if (addr4 & 1) {
|
||||
value >>= 4;
|
||||
} else {
|
||||
value = value & 0x0f;
|
||||
}
|
||||
|
||||
// there's yet another scramble from the CLUT. The palette index turns into an X, Y value
|
||||
// See GS manual 2.7.3 CLUT Storage Mode, IDTEX4 in CSM1 mode.
|
||||
|
||||
u8 clx = value & 0x7;
|
||||
u8 cly = value >> 3;
|
||||
|
||||
// the x, y CLUT value is looked up in PSMCT16 mode
|
||||
u32 clut_addr = psmct32_addr(clx, cly, 64) + clut_vram_addr * 256;
|
||||
u32 clut_value = *(u32*)(m_vram.data() + clut_addr);
|
||||
// fmt::print("{} {}\n", value, clut_value);
|
||||
memcpy(result + out_offset, &clut_value, 4);
|
||||
out_offset += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
else {
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
#pragma once
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "common/common_types.h"
|
||||
|
||||
class TextureConverter {
|
||||
public:
|
||||
TextureConverter();
|
||||
void upload(const u8* data, u32 dest, u32 size_vram_words);
|
||||
void download_rgba8888(u8* result,
|
||||
u32 vram_addr,
|
||||
u32 goal_tex_width,
|
||||
u32 w,
|
||||
u32 h,
|
||||
u32 psm,
|
||||
u32 clut_psm,
|
||||
u32 clut_vram_addr);
|
||||
|
||||
private:
|
||||
std::vector<u8> m_vram;
|
||||
};
|
||||
@@ -0,0 +1,153 @@
|
||||
#include "TexturePool.h"
|
||||
|
||||
#include "third-party/fmt/core.h"
|
||||
#include "common/util/assert.h"
|
||||
#include "common/util/FileUtil.h"
|
||||
|
||||
////////////////////////////////
|
||||
// Extraction of textures
|
||||
// Note: this is intended to be temporary until we have a better system.
|
||||
// this simply converts the PS2 format textures loaded by the game, then puts them into the PC
|
||||
// port texture pool.
|
||||
|
||||
const char empty_string[] = "";
|
||||
const char* goal_string(u32 ptr, const u8* memory_base) {
|
||||
if (ptr == 0) {
|
||||
return empty_string;
|
||||
}
|
||||
return (const char*)(memory_base + ptr + 4);
|
||||
}
|
||||
|
||||
struct GoalTexture {
|
||||
s16 w;
|
||||
s16 h;
|
||||
u8 num_mips;
|
||||
u8 tex1_control;
|
||||
u8 psm;
|
||||
u8 mip_shift;
|
||||
u16 clutpsm;
|
||||
u16 dest[7];
|
||||
u16 clut_dest;
|
||||
u8 width[7];
|
||||
u32 name_ptr;
|
||||
u32 size;
|
||||
float uv_dist;
|
||||
u32 masks[3];
|
||||
|
||||
s32 segment_of_mip(s32 mip) const {
|
||||
if (2 >= num_mips) {
|
||||
return num_mips - mip - 1;
|
||||
} else {
|
||||
return std::max(0, 2 - mip);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
static_assert(sizeof(GoalTexture) == 60, "GoalTexture size");
|
||||
static_assert(offsetof(GoalTexture, clutpsm) == 8);
|
||||
static_assert(offsetof(GoalTexture, clut_dest) == 24);
|
||||
|
||||
struct GoalTexturePage {
|
||||
struct Seg {
|
||||
u32 block_data_ptr;
|
||||
u32 size;
|
||||
u32 dest;
|
||||
};
|
||||
u32 file_info_ptr;
|
||||
u32 name_ptr;
|
||||
u32 id;
|
||||
s32 length; // texture count
|
||||
u32 mip0_size;
|
||||
u32 size;
|
||||
Seg segment[3];
|
||||
u32 pad[16];
|
||||
// start of array.
|
||||
|
||||
std::string print() const {
|
||||
return fmt::format("Tpage id {} textures {} seg0 {} {} seg1 {} {} seg2 {} {}\n", id, length,
|
||||
segment[0].size, segment[0].dest, segment[1].size, segment[1].dest,
|
||||
segment[2].size, segment[2].dest);
|
||||
}
|
||||
|
||||
bool try_copy_texture_description(GoalTexture* dest,
|
||||
int idx,
|
||||
const u8* memory_base,
|
||||
const u8* tpage,
|
||||
u32 s7_ptr) {
|
||||
u32 ptr;
|
||||
memcpy(&ptr, tpage + sizeof(GoalTexturePage) + 4 * idx, 4);
|
||||
if (ptr == s7_ptr) {
|
||||
return false;
|
||||
}
|
||||
memcpy(dest, memory_base + ptr, sizeof(GoalTexture));
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/*!
|
||||
* Handle a GOAL texture-page object being uploaded to VRAM.
|
||||
* The strategy:
|
||||
* - upload the texture-age to a fake 4MB VRAM, like the GOAL code would have done.
|
||||
* - "download" each texture in a reasonable format for the PC Port (currently RGBA8888)
|
||||
* - add this to the PC pool.
|
||||
*
|
||||
* The textures are scrambled around in a confusing way.
|
||||
*/
|
||||
void TexturePool::handle_upload_now(const u8* tpage, int mode, const u8* memory_base, u32 s7_ptr) {
|
||||
fmt::print("[TexutrePool C++] Got upload now! {} {}\n", (const void*)tpage, mode);
|
||||
|
||||
// extract the texture-page object. This is just a description of the page data.
|
||||
GoalTexturePage texture_page;
|
||||
memcpy(&texture_page, tpage, sizeof(GoalTexturePage));
|
||||
|
||||
std::vector<u8> output_buffer;
|
||||
output_buffer.resize(1024 * 1024);
|
||||
|
||||
u32 sizes[3] = {texture_page.segment[0].size, texture_page.segment[1].size,
|
||||
texture_page.segment[2].size};
|
||||
if (mode == -1) {
|
||||
// I don't really understand what's going on here with the size.
|
||||
// the sizes given aren't the actual sizes in memory, so if you just use that, you get the
|
||||
// wrong answer. I solved this in the decompiler by using
|
||||
u32 size = ((sizes[0] + sizes[1] + sizes[2] + 255) / 256) * 256;
|
||||
m_tex_converter.upload(memory_base + texture_page.segment[0].block_data_ptr,
|
||||
texture_page.segment[0].dest, size);
|
||||
} else {
|
||||
assert(false);
|
||||
}
|
||||
|
||||
|
||||
// loop over all texture in the tpage and download them.
|
||||
for (int tex_idx = 0; tex_idx < texture_page.length; tex_idx++) {
|
||||
GoalTexture tex;
|
||||
if (texture_page.try_copy_texture_description(&tex, tex_idx, memory_base, tpage, s7_ptr)) {
|
||||
|
||||
// each texture may have multiple mip levels.
|
||||
for (int mip_idx = 0; mip_idx < tex.num_mips; mip_idx++) {
|
||||
s32 segment = tex.segment_of_mip(mip_idx);
|
||||
|
||||
u32 ww = tex.w >> mip_idx;
|
||||
u32 hh = tex.h >> mip_idx;
|
||||
m_tex_converter.download_rgba8888(output_buffer.data(), tex.dest[mip_idx],
|
||||
tex.width[mip_idx], ww, hh, tex.psm, tex.clutpsm,
|
||||
tex.clut_dest);
|
||||
|
||||
// Debug output.
|
||||
const char* tpage_name = goal_string(texture_page.name_ptr, memory_base);
|
||||
const char* tex_name = goal_string(tex.name_ptr, memory_base);
|
||||
file_util::create_dir_if_needed(
|
||||
file_util::get_file_path({"debug_out", "textures", tpage_name}));
|
||||
file_util::write_rgba_png(
|
||||
fmt::format(
|
||||
file_util::get_file_path({"debug_out", "textures", tpage_name, "{}-{}-{}.png"}),
|
||||
tex_idx, tex_name, mip_idx),
|
||||
output_buffer.data(), ww, hh);
|
||||
}
|
||||
|
||||
// TODO the clut
|
||||
} else {
|
||||
fmt::print("[{}] #f ------------\n", tex_idx);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
#pragma once
|
||||
|
||||
#include "common/common_types.h"
|
||||
#include "game/graphics/texture/TextureConverter.h"
|
||||
|
||||
class TexturePool {
|
||||
public:
|
||||
void handle_upload_now(const u8* tpage, int mode, const u8* memory_base, u32 s7_ptr);
|
||||
|
||||
private:
|
||||
TextureConverter m_tex_converter;
|
||||
};
|
||||
@@ -442,6 +442,10 @@ void send_gfx_dma_chain(u32 /*bank*/, u32 chain) {
|
||||
Gfx::send_chain(g_ee_main_mem, chain);
|
||||
}
|
||||
|
||||
void pc_texture_upload_now(u32 page, u32 mode) {
|
||||
Gfx::texture_upload_now(Ptr<u8>(page).c(), mode, s7.offset);
|
||||
}
|
||||
|
||||
/*!
|
||||
* Open a file-stream. Name is a GOAL string. Mode is a GOAL symbol. Use 'read for readonly
|
||||
* and anything else for write only.
|
||||
@@ -601,6 +605,7 @@ void InitMachine_PCPort() {
|
||||
make_function_symbol_from_c("__read-ee-timer", (void*)read_ee_timer);
|
||||
make_function_symbol_from_c("__mem-move", (void*)c_memmove);
|
||||
make_function_symbol_from_c("__send-gfx-dma-chain", (void*)send_gfx_dma_chain);
|
||||
make_function_symbol_from_c("__pc-texture-upload-now", (void*)pc_texture_upload_now);
|
||||
}
|
||||
|
||||
/*!
|
||||
|
||||
@@ -1687,6 +1687,12 @@
|
||||
|
||||
(defmethod upload-now! texture-page ((obj texture-page) (arg0 int))
|
||||
"Immediately upload the texture-page to the given buffer, using arg0 mode."
|
||||
|
||||
(#when PC_PORT
|
||||
;; load it to the PC Port's texture pool.
|
||||
(__pc-texture-upload-now obj arg0)
|
||||
)
|
||||
|
||||
(let ((gp-0 *txt-dma-list*))
|
||||
;; Set up the DMA buffer
|
||||
(let ((v1-0 gp-0))
|
||||
@@ -2094,6 +2100,7 @@
|
||||
(-> obj info maya-file-name)
|
||||
(-> obj info tool-debug)
|
||||
(-> obj info mdb-file-name))
|
||||
(tex-dbg "block data #x~X~%" (-> obj segment 0 block-data))
|
||||
(local-vars (s4-0 texture-page-dir-entry))
|
||||
(cond
|
||||
((or (not obj)
|
||||
|
||||
@@ -182,6 +182,7 @@
|
||||
(define-extern __read-ee-timer (function uint))
|
||||
(define-extern __mem-move (function pointer pointer uint none))
|
||||
(define-extern __send-gfx-dma-chain (function object object none))
|
||||
(define-extern __pc-texture-upload-now (function object object none))
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; ksound - InitSoundScheme
|
||||
|
||||
Reference in New Issue
Block a user