clank/rodecomp
1
0
Fork 0
Code Issues Wiki Activity

Reconstruct readable C++ and organize cohesive source subsystems

Browse source 
Administrative source import: native x86 compilation passed for 423 authored units. Source placement and submission states are migrated separately; this commit does not imply peer acceptance.

Previous head: 35d2a8cb36
Payload SHA256: 592f016d2730c5593bb653aa054c1e5f76a6df72c8f5a09e66f74876e2e33dee
This commit is contained in:
ragnarok-clanker 2026-10-25 07:42:41 +00:00
commit a47d20f8be
890 changed files with 11796 additions and 16664 deletions
Download patch file Download diff file Expand all files Collapse all files

169
Source/Render/TextureCache.cpp
View file

@ -1,169 +0,0 @@
#include "Render/RenderSystemBase.h"
#include "Render/Texture.h"
#include "Render/TextureCache.h"
#include "Resource/BitmapResource.h"
#include "Resource/ResourceMgr.h"
#include <cstring>
#include <mmsystem.h>
// Original key comparison is unsigned-byte, case-sensitive string order.
bool TextureNameLess::operator()(const char* left, const char* right) const {
return std::strcmp(left, right) < 0;
}
// OFFSET: 0x004074F5
// FUNCTION: fn_00152
TextureCache::TextureCache(
ResourceMgr& resources,
CRenderSystemBase*& system,
TextureSources& sources,
const int& reduction,
const unsigned& reuseDelay
)
: m_resources(resources), m_system(system), m_sources(sources), m_reduction(reduction), m_reuseDelay(reuseDelay) {
}
// OFFSET: 0x005713C0
// FUNCTION: fn_02447
TextureCache::~TextureCache() {
this->Clear();
}
// OFFSET: 0x00571790
// FUNCTION: fn_02453
CTexture* TextureCache::Default() {
return this->m_system ? this->m_system->BackBufferTexture() : nullptr;
}
// OFFSET: 0x005715E0
// FUNCTION: fn_02449
CTexture* TextureCache::Upload(
int width,
int height,
const std::uint32_t* pixels,
int format,
int option,
bool fullSize,
bool dynamic,
bool renderTarget
) {
const int outputWidth = fullSize ? width : width / this->m_reduction;
const int outputHeight = fullSize ? height : height / this->m_reduction;
CTexture* texture =
this->m_system ? this->m_system->CreateTexture(outputWidth, outputHeight, format, dynamic, renderTarget) : nullptr;
if (texture) {
texture->Upload(0, 0, width, height, pixels, option, 0);
texture->unknown_0008 = (texture->unknown_0008 & 0xFF00u) | fullSize;
}
return texture;
}
// OFFSET: 0x00571930
// FUNCTION: fn_02455
CTexture* TextureCache::Create(const char* name, int option, bool fullSize, bool dynamic, bool renderTarget) {
if (std::strstr(name, ".bik")) {
int width;
int height;
if (this->m_sources.MovieSize(name, width, height)) {
CTexture* texture = this->m_system ? this->m_system->CreateTexture(width, height, 4, false, false) : nullptr;
if (texture) {
return texture;
}
}
} else {
auto* bitmap = static_cast<CBitmapRes*>(this->m_resources.Load(this->m_sources.Resolve(name)));
if (bitmap) {
const auto& image = bitmap->image;
CTexture* texture = this->Upload(
image.width, image.height, image.pixels, image.alpha != 0 ? 1 : 0, option, fullSize, dynamic, renderTarget
);
this->m_resources.Remove(bitmap);
return texture;
}
}
// Original explicitly creates a transparent 1x1 substitute on a missing
// bitmap/movie, rather than returning the renderer's shared default here.
const int extent = 1 / this->m_reduction;
CTexture* texture = this->m_system ? this->m_system->CreateTexture(extent, extent, 0, false, false) : nullptr;
if (texture) {
const std::uint32_t transparent = 0;
texture->Upload(0, 0, 1, 1, &transparent, option, 0);
texture->unknown_0008 &= 0xFF00u;
}
return texture;
}
// OFFSET: 0x005717A0
// FUNCTION: fn_02454
CTexture* TextureCache::Load(const char* name, int option, bool fullSize, bool dynamic, bool renderTarget) {
const auto found = this->m_textures.find(name);
if (found != this->m_textures.end() && found->second) {
found->second->unknown_0020 = timeGetTime();
return found->second;
}
CTexture* texture = this->Create(name, option, fullSize, dynamic, renderTarget);
if (!texture) {
return this->Default();
}
strncpy_s(texture->m_name, sizeof(texture->m_name), name, _TRUNCATE);
texture->unknown_0020 = timeGetTime();
this->m_textures.emplace(texture->m_name, texture);
return texture;
}
// OFFSET: 0x005716F0
// FUNCTION: fn_02452
void TextureCache::Remove(CTexture* texture) {
if (texture->unknown_001C == 0 && texture != this->Default()) {
const auto found = this->m_textures.find(texture->m_name);
if (found != this->m_textures.end()) {
delete found->second;
this->m_textures.erase(found);
}
}
}
// OFFSET: 0x00571670
// FUNCTION: fn_02451
void TextureCache::Clear() {
for (auto& [name, texture] : this->m_textures) {
delete texture;
}
this->m_textures.clear();
}
// OFFSET: 0x00571C50
// FUNCTION: fn_02457
void TextureCache::ClearUnused() {
const unsigned threshold = timeGetTime() - this->m_reuseDelay;
for (auto entry = this->m_textures.begin(); entry != this->m_textures.end();) {
CTexture* texture = entry->second;
if (texture->unknown_001C != 0 || texture->unknown_0020 >= threshold) {
++entry;
} else {
delete texture;
entry = this->m_textures.erase(entry);
}
}
HeapCompact(GetProcessHeap(), 0);
this->m_sources.CleanupTextures();
}