feat(texture): wrap modes and tiling

texture:SetTexture(file, wrapModeHorizontal, wrapModeVertical), the XML
hWrapMode / vWrapMode attributes, texture:SetHorizTile / GetHorizTile /
SetVertTile / GetVertTile and the XML horizTile / vertTile attributes.

Wrap. 1.12 fixes a texture's wrap when its file loads.
CSimpleTexture::SetTexture (0x00770200) builds the flags word with
CGxTexFlags (0x0058A980) from one wrap argument for both axes, and
TextureCreate (0x00449D90) caches the handle under the name and that
word, so a repeating copy of a file is its own shared texture. The device
reads one bit per axis (3 for U, 4 for V), repeat or clamp, so the mirror
and border modes clamp. A texture with a mode or a tile flag loads
through a co-hook on that SetTexture: the same body, with a repeat per
axis. The engine's same-file early-out (0x0044AC70) ignores flags, so the
co-hook also compares the held image's wrap (its device texture's flags
at +0x3C, or a loading BLP handle's at +0x150), and for the same file it
swaps in the other copy and keeps the pixel shader. Changing a mode or a
tile flag reloads the held file the same way. The Lua method is
registered again so it stores the wrap arguments before the engine
handler (0x0079BB40) runs: true or "REPEAT" repeats, anything else clamps.

Tiling. A tiled axis repeats, and each non-zero coordinate on it becomes
the texture's length in script units over the image's size in texels.
The script units are the engine's own coordinate push: DivideByScreenScaleX
(0x0041AE40) of aspect (0x0041AD70) x 1024 x length, over the effective
scale. The texels are the device texture's width and height (+0x24 /
+0x28): the file's size, halved only past the GPU limit and untouched by
BaseMip. The layer batch keeps a pointer to the eight coordinates
(0x00772FD0), so the count is written whenever an input changes: after
each corner store, after both native SetTexCoord forms (0x00770410,
0x007704C0), on a tile change, and after CSimpleTexture::Emit
(0x007706E0), whose device lookup loads the image. A tile change counts
against the held image before the repeating copy of the same file
replaces it, since the copy has no size until it is drawn.

A texture showing an atlas does not tile (the atlases are parts of their
files), and neither does one with SetTexCoordModifiesRect on. SetAtlas
clears modes and tiling. A tiled status bar texture takes
StatusBar::Fill's anchored layout instead of 1.12's crop, which would size
it by the count, and its fill sets no coordinates. An XML <TexCoords> that
moves a tiled axis off 0..1 logs "Invalid TexCoords value (horizTile is
on)" at error level (new Xml::Error) and falls back to the whole image.

Also corrects the AtlasData.h note on the atlas tile flags: 4 is
horizontal and 2 is vertical.
This commit is contained in:
Brues
2026-11-01 18:34:36 -06:00
parent b032dc09ac
commit 932e6ed82f
15 changed files with 807 additions and 33 deletions
+71
View File
@@ -359,6 +359,8 @@ build instructions.
- [`texture:GetAtlas()`](#texturegetatlas)
- [`texture:ResetTexCoord()`](#textureresettexcoord)
- [`texture:SetSpriteSheetCell(cell, numRows, numColumns)`](#texturesetspritesheetcellcell-numrows-numcolumns)
- [`texture:SetTexture(file [, wrapModeHorizontal, wrapModeVertical])`](#texturesettexturefile--wrapmodehorizontal-wrapmodevertical)
- [`texture:SetHorizTile(tiling)` / `texture:SetVertTile(tiling)`](#texturesethoriztiletiling--texturesetverttiletiling)
- [`texture:SetDesaturation(amount)`](#texturesetdesaturationamount)
- [`texture:GetDesaturation()`](#texturegetdesaturation)
- [`IsDesaturateSupported()`](#isdesaturatesupported)
@@ -8571,6 +8573,7 @@ After `SetAtlas`, texture coordinates address the art and not the file it sits
in, so `0` to `1` covers the whole of the art. `SetTexCoord(0, 0.5, 0, 0.5)`
shows the top-left quarter of the art, and `GetTexCoord` reads back what you
asked for. `SetTexture` points the texture at a file again and clears the atlas.
`SetAtlas` turns tiling off and sets both wrap modes to `"CLAMP"`.
When the name is not known, the texture keeps whatever it was showing. Call
`_classicapi_DumpAtlasMisses()` to list the names that were asked for and not
@@ -8622,6 +8625,74 @@ t:SetTexture("Interface\\TargetingFrame\\UI-RaidTargetingIcons")
t:SetSpriteSheetCell(8, 4, 4)
```
### `texture:SetTexture(file [, wrapModeHorizontal, wrapModeVertical])`
Points the texture at an image file. The two optional arguments set the wrap
mode of the horizontal and the vertical axis. The wrap mode decides what the
texture shows where its coordinates go past `0` or `1`:
- `"REPEAT"` or `true` repeats the image.
- `"CLAMP"`, `false` or `nil` stretches the pixels at the edge of the image.
This is the default.
`"CLAMPTOBLACKADDITIVE"`, `"CLAMPTOBLACK"`, `"CLAMPTOWHITE"` and `"MIRROR"`
work the same as `"CLAMP"`.
Each call with a file sets both modes again, so `SetTexture(file)` sets them
back to `"CLAMP"`. A color fill, `SetTexture(r, g, b)`, keeps the modes. An axis
with tiling on always repeats (see
[`texture:SetHorizTile`](#texturesethoriztiletiling--texturesetverttiletiling)).
```lua
bg:SetTexture("Interface\\AddOns\\MyAddon\\stripes", "REPEAT", "REPEAT")
bg:SetTexCoord(0, 4, 0, 2) -- four copies across, two copies down
```
A `<Texture>` element takes the same modes in its `hWrapMode` and `vWrapMode`
attributes:
```xml
<Texture parentKey="Fill" file="Interface\AddOns\MyAddon\stripes" hWrapMode="REPEAT"/>
```
### `texture:SetHorizTile(tiling)` / `texture:SetVertTile(tiling)`
Turns tiling on or off for one axis. A tiled axis repeats the image at its own
size: one pixel of the image covers one unit of the texture's width or height. For example,
an image 32 pixels wide on a texture 100 units wide shows the image a little
more than three times across. The count changes when the texture changes size.
`GetHorizTile()` and `GetVertTile()` return `true` or `false`.
Tiling sets each coordinate on that axis that is not `0` to the repeat count,
so `GetTexCoord` returns the count. The count needs the size of the image, so
for a new image it is set when the texture is first drawn. Tiling stays on when
`SetTexture` sets a new file. A texture that shows an atlas does not tile, and
neither does a texture with `SetTexCoordModifiesRect` on.
A tiled status bar texture keeps the image at its own size as the bar fills.
The bar shows more or fewer copies and does not squeeze the image.
```lua
local edge = frame:CreateTexture(nil, "BORDER")
edge:SetTexture("Interface\\AddOns\\MyAddon\\border-top")
edge:SetPoint("TOPLEFT")
edge:SetPoint("TOPRIGHT")
edge:SetHeight(16)
edge:SetHorizTile(true)
```
A `<Texture>` element takes `horizTile` and `vertTile` attributes. A
`<TexCoords>` child must keep a tiled axis at `0` and `1`, for example
`left="0" right="1"` with `horizTile`. Other values are an error in the XML log,
and the texture then shows the whole image. The other axis can take any values,
so one strip of a file can tile:
```xml
<Texture parentKey="Rail" file="Interface\AddOns\MyAddon\rails" horizTile="true">
<TexCoords left="0" right="1" top="0.25" bottom="0.5"/>
</Texture>
```
### `texture:SetDesaturation(amount)`
Removes some or all of the color from a texture. `amount` is a number from `0`
+65 -4
View File
@@ -862,6 +862,20 @@ enum Offsets {
// texcoords (no v-flip — the engine region path is top-left origin).
FUN_SIMPLETEXTURE_SET_TEXCOORD = 0x00770410,
OFF_SIMPLETEXTURE_HTEXTURE = 0xCC, // owned HTEXTURE ref (diagnostic)
// The eight coordinates, UL, LL, UR, LR as (x, y) pairs — what GetTexCoord
// pushes (0x0079BDF0) and both SetTexCoord forms write. The layer batch
// keeps a pointer to them (FUN_00772FD0 0x00773020) and reads them on
// every draw.
OFF_SIMPLETEXTURE_TEXCOORDS = 0x104,
// CSimpleTexture::Emit — `void __thiscall(texture, batch)`, `ret 4`, the
// layer-batch rebuild's per-texture call (4.3.4's CSimpleTexture::Draw):
// with an image it runs the quad append FUN_00772FD0, whose device-texture
// lookup loads the texture, so after it the device texture exists.
FUN_SIMPLETEXTURE_EMIT = 0x007706E0,
// CScriptRegion::NotifyLayerChanged — `void __thiscall(region)`: marks the
// region's layer for a batch rebuild. SetTexture (0x007702E2) and SetImage
// (0x00770300) call it after storing a new image.
FUN_REGION_NOTIFY_LAYER_CHANGED = 0x0077FDF0,
// The four drawn-quad corner POSITIONS: 4 vertices of {x, y, z} floats (0xC
// stride), order BL, TL, BR, TR (from FUN_REGION_STORE_CORNERS's writes). The
// region draw enqueue FUN_00772fd0 (0x00772fd0) hands region+0xD4 straight to
@@ -879,10 +893,10 @@ enum Offsets {
// its screen rect with NO anchors (anchoring 100+ textures/frame corrupts the
// UI-manager pending-layout list — the FUN_00765650 crash). Hooked by
// Texture::CornerStore, whose listeners re-apply rotation
// (Texture::Transform) right after the engine restores the axis-aligned
// corners (layout resolve / SetTexCoord). Writes only the corners:
// nothing marks the layer changed, since the layer batch reads them
// through a pointer on every draw.
// (Texture::Transform) and the repeat count (Texture::Tile) right after
// the engine restores the axis-aligned corners (layout resolve /
// SetTexCoord). Writes only the corners: nothing marks the layer changed,
// since the layer batch reads them through a pointer on every draw.
FUN_REGION_STORE_CORNERS = 0x007705B0,
// CSimpleTexture::OnFrameSizeChanged — `__thiscall(texture+OFF_REGION_ANCHOR,
// const float *oldRect)`, the layout callback: lays out dependents, then
@@ -12011,6 +12025,7 @@ enum Offsets {
// names them: 0 info, 1 warning, 2 error, 3 fatal.
VTBL_XML_STATUS_ADD = 0x0C,
XML_STATUS_WARNING = 1,
XML_STATUS_ERROR = 2,
// `float __stdcall SStrToFloat(const char *)` (RET 4, x87 result) — the
// frame loader's `alpha` conversion (0x00769A10).
FUN_SSTR_TO_FLOAT = 0x0064AAA0,
@@ -12501,8 +12516,54 @@ enum Offsets {
GXTEX_FORMAT_ARGB8888 = 2,
GXTEX_CMD_LATCH = 1,
PTR_TEXLOAD_DESC_VTBL = 0x007FFA10,
// CGxTexFlags::CGxTexFlags — `void *__thiscall(flags, filter, wrapU,
// wrapV, 0, 0, 0, anisotropy, 0)`. CSimpleTexture::SetTexture builds its
// word with (filter, wrap, wrap, 0, 0, 0, 1, 0) (0x00770241..0x00770270),
// one wrap argument for both axes. The bits: 0..2 the filter, 3 repeat in
// U, 4 repeat in V — the OpenGL backend's ApplyTextureParams (0x0059F170)
// maps `& 8` / `& 0x10` to GL_REPEAT or a clamp, one bit per axis, so the
// device has no mirror or border mode (benilla-re gx/textures, verified).
FUN_GX_TEXFLAGS_INIT = 0x0058A980,
GXTEX_FLAG_FILTER_MASK = 0x7,
GXTEX_FLAG_WRAP_U = 0x8,
GXTEX_FLAG_WRAP_V = 0x10,
// GetTextureDeviceObject — `CGxTex *__fastcall(HTEXTURE, int load, void
// *callback)`: [hTex + OFF_HTEXTURE_DEVICE], or with `load` set the
// texture is first waited for (0x0044AD03), so 0 with `load` clear means
// not loaded yet.
FUN_TEXTURE_GET_RENDERABLE = 0x0044ACF0,
// The HTEXTURE object (CTexture, 0x15C bytes, benilla-re gx/textures):
// its file name as loaded (the path, extension kept), a source word whose
// bit 1 the file loaders TextureCreateFromBlp (0x0044A310),
// TextureCreateFromTga (0x0044A140) and TextureCreateFromFile (0x00449610)
// set for a load with the file flag CSimpleTexture::SetTexture always
// passes (a solid colour or a pixel source never has it), the device
// texture (0 until loaded) and, for a BLP only, the texture flags word it
// was created with (TextureCreateFromBlp stores it before queuing the
// read; the build ORs in 0x40 for mips). A TGA hands its word only to its
// device texture (OFF_GXTEX_FLAGS).
OFF_HTEXTURE_NAME = 0x0C,
OFF_HTEXTURE_SOURCE = 0x110,
HTEXTURE_SOURCE_FILE = 0x2,
OFF_HTEXTURE_DEVICE = 0x140,
OFF_HTEXTURE_TEX_FLAGS = 0x150,
// TextureNameMatch — `int __fastcall(HTEXTURE, const char *name)`: 1 when
// the texture was made from a file of that name (extension ignored, any
// case), else 0. Flags play no part, so SetTexture's same-file early-out
// (0x0077021E) keeps a held image whatever wrap a new call asks for.
FUN_TEXTURE_NAME_MATCH = 0x0044AC70,
// The device texture record (CGxTex): its width and height, stored by the
// record constructor 0x00591600 from its arguments. They are the BLP's
// size after TextureLimitSize (0x00448B60), which halves only past the
// GPU's maximum texture size; the BaseMip skip ([device + 0x31C]) is
// applied at upload and never written here. 4.3.4's CRenderBatch::
// QueueTexture reads the same `gxTex->m_width` for its tile count.
OFF_GXTEX_WIDTH = 0x24,
OFF_GXTEX_HEIGHT = 0x28,
// Its texture flags word (FUN_GX_TEXFLAGS_INIT bits), stored by 0x00591600
// and read on every bind by ApplyTextureParams (0x0059F170): the wrap the
// device actually samples with.
OFF_GXTEX_FLAGS = 0x3C,
// SysMsgAdd — `int __fastcall(CStatus *status, uint32_t level)`: hands a
// status's error text to the system-message printer 0x0044CB20, which in
// this build formats it and drops it (nothing reaches the screen; seen
+27 -7
View File
@@ -30,6 +30,10 @@
// off pins the texture to the bar again and gives it back its crop flag, as
// InstallBarTexture and SetBarTexture leave it.
//
// A tiled bar texture (Texture::Tile) takes the same layout, since the crop
// would size it by its repeat count, and keeps its coordinates, as 4.3.4's
// OnLayerUpdate sets none for a texture with a tile flag on.
//
// The retail fill styles (Enum.StatusBarFillStyle) fit the same layout:
// Reverse is the reversed fill; Center insets both ends by half the empty
// part and shows the middle of the image; StandardNoRangeFill draws a bar
@@ -48,6 +52,7 @@
#include "Offsets.h"
#include "baselib/Ascii.h"
#include "frame/Destruction.h"
#include "texture/Wrap.h"
#include "xml/FrameLoad.h"
#include "xml/TypeLoad.h"
@@ -148,7 +153,8 @@ void SetFullTexCoord(void *texture, bool rotates) {
// 4.3.4's OnLayerUpdate body. [s0, s1] is the filled part of the bar along the
// fill axis, from its start edge; [t0, t1] the part of the image drawn there.
void LayOut(void *bar, State &state) {
// A tiled texture keeps its coordinates, which its repeat count owns.
void LayOut(void *bar, State &state, bool tiled) {
void *texture = BarTexture(bar);
float width, height;
BarSize(bar, width, height);
@@ -168,22 +174,22 @@ void LayOut(void *bar, State &state) {
float left = 0.0f, right = 0.0f, top = 0.0f, bottom = 0.0f;
if (IsVertical(bar)) {
if (state.rotatesTexture) {
if (!tiled && state.rotatesTexture) {
const float corners[8] = {t1, 0.0f, t0, 0.0f, t1, 1.0f, t0, 1.0f}; // UL, LL, UR, LR
reinterpret_cast<SetTexCoordCorners_t>(Offsets::FUN_SIMPLETEXTURE_SET_TEXCOORD_CORNERS)(texture,
corners);
} else {
} else if (!tiled) {
const float rect[4] = {1.0f - t1, 0.0f, 1.0f - t0, 1.0f};
reinterpret_cast<SetTexCoordRect_t>(Offsets::FUN_SIMPLETEXTURE_SET_TEXCOORD)(texture, rect);
}
bottom = s0 * height;
top = -((1.0f - s1) * height);
} else {
if (state.rotatesTexture) {
if (!tiled && state.rotatesTexture) {
const float corners[8] = {0.0f, 1.0f - t0, 1.0f, 1.0f - t0, 0.0f, 1.0f - t1, 1.0f, 1.0f - t1};
reinterpret_cast<SetTexCoordCorners_t>(Offsets::FUN_SIMPLETEXTURE_SET_TEXCOORD_CORNERS)(texture,
corners);
} else {
} else if (!tiled) {
const float rect[4] = {0.0f, t0, 1.0f, t1};
reinterpret_cast<SetTexCoordRect_t>(Offsets::FUN_SIMPLETEXTURE_SET_TEXCOORD)(texture, rect);
}
@@ -213,8 +219,22 @@ void Restore(void *bar) {
}
void __fastcall Update_h(void *bar, void *edx, float elapsed) {
const auto it = g_state.find(bar);
void *texture = BarTexture(bar);
const bool tiled = texture != nullptr && Texture::Wrap::Tiles(texture);
auto it = g_state.find(bar);
if (it == g_state.end()) {
if (!tiled) {
g_origUpdate(bar, edx, elapsed);
return;
}
// 1.12's crop would size a tiled texture by its repeat count.
it = g_state.emplace(bar, State{}).first;
Game::Ref<int>(texture, Offsets::OFF_REGION_TEXCOORD_MODIFIES_RECT) = 0;
it->second.owned = true;
Flags(bar) |= Offsets::VALUE_FLAG_CHANGED;
} else if (!it->second.Active() && !tiled) {
Restore(bar);
g_state.erase(it);
g_origUpdate(bar, edx, elapsed);
return;
}
@@ -233,7 +253,7 @@ void __fastcall Update_h(void *bar, void *edx, float elapsed) {
}
if (!changed)
return;
LayOut(bar, state);
LayOut(bar, state, tiled);
Flags(bar) &= ~Offsets::VALUE_FLAG_CHANGED;
}
+8
View File
@@ -29,6 +29,7 @@
#include "Game.h"
#include "Offsets.h"
#include "debug/Log.h"
#include "texture/Wrap.h"
#include "xml/FrameLoad.h"
#include "xml/TypeLoad.h"
@@ -321,6 +322,11 @@ int __fastcall Script_SetAtlas(void *L) {
return 0;
}
// Retail's SetAtlas re-applies the atlas's own wrap mode, which clears
// tiling the texture had. An atlas never tiles here (the built-in ones are
// parts of their files), so that leaves it clamped.
Texture::Wrap::Clear(region);
// Reshaping the stack for each delegated handler leaves `info` untouched — it
// points into the registry, which none of these calls can reach.
Game::Lua::SetTop(L, 1); // (self)
@@ -570,6 +576,8 @@ const Xml::TypeLoad::AutoSubscribe _xmlSub{Xml::TypeLoad::TEXTURE, &OnTextureNod
} // namespace
bool Shows(void *region) { return LiveEntry(region) != nullptr; }
const Info *Find(const char *name) {
if (name == nullptr || *name == '\0')
return nullptr;
+4
View File
@@ -53,6 +53,10 @@ struct Info {
// The returned pointer stays valid for the life of the process.
const Info *Find(const char *name);
// True while `region` shows the atlas SetAtlas last gave it: its image has not
// been replaced since.
bool Shows(void *region);
// Records an unresolved atlas name for `_classicapi_DumpAtlasMisses()`. This is
// how the built-in table grows: load a real addon, read what it actually asked
// for, bind those names instead of guessing at thousands.
+6 -4
View File
@@ -71,10 +71,12 @@
// - 73 names repeat case-insensitively; keep the higher ID, the same rule
// `ui/ColorData.h` documents for duplicate color tags.
//
// `tilesHorizontally` / `tilesVertically` come from `CommittedFlags` bits 0 and 1.
// They are stored as resolved booleans rather than the raw flags word because the
// other set bits (4, 8, 16 appear in the data) have no known meaning and must not
// leak into the public contract.
// `tilesHorizontally` / `tilesVertically` come from `CommittedFlags` 4 and 2:
// 190 of the 194 members named `_...` (Blizzard's prefix for art that tiles
// across) carry 4, and 56 of the 60 named `!...` (tiles down) carry 2; 1 is
// set only on the nameless rows. They are stored as resolved booleans rather
// than the raw flags word because the other set bits (8, 16 appear in the data)
// have no known meaning and must not leak into the public contract.
namespace Texture::AtlasData {
+1 -1
View File
@@ -20,7 +20,7 @@
// address.
//
// MinHook allows ONE hook per address and more than one feature keeps state
// keyed by a texture region (Texture::Mask), so this module owns
// keyed by a texture region (Texture::Mask, Texture::Wrap), so this module owns
// the hook and fans out. Declare a file-scope
// static const Texture::Construct::AutoSubscribe _sub{&OnTextureConstructed};
namespace Texture::Construct {
+2 -2
View File
@@ -20,8 +20,8 @@
// Listeners run after the corners are written.
//
// MinHook allows ONE hook per address and more than one feature follows the
// quad (Texture::Transform's rotation), so this module owns the hook and fans
// out. Declare a file-scope
// quad (Texture::Transform's rotation, Texture::Tile's repeat count), so this
// module owns the hook and fans out. Declare a file-scope
// static const Texture::CornerStore::AutoSubscribe _sub{&OnCornersStored};
namespace Texture::CornerStore {
+9 -6
View File
@@ -55,14 +55,17 @@ void __fastcall LatchPixels(uint32_t command, uint32_t width, uint32_t /*height*
} // namespace
uint32_t DefaultFlags() {
uint32_t Flags(uint32_t filter, bool wrapU, bool wrapV) {
uint32_t flags = 0;
const uint32_t blend = Game::Read<uint32_t>(Offsets::VAR_TEXTURE_BLEND_DEFAULT);
reinterpret_cast<TexFlagsInit_t>(Offsets::FUN_GX_TEXFLAGS_INIT)(&flags, blend, 0, 0, 0, 0, 0,
1, 0);
reinterpret_cast<TexFlagsInit_t>(Offsets::FUN_GX_TEXFLAGS_INIT)(&flags, filter, wrapU ? 1 : 0,
wrapV ? 1 : 0, 0, 0, 0, 1, 0);
return flags;
}
uint32_t DefaultFlags() {
return Flags(Game::Read<uint32_t>(Offsets::VAR_TEXTURE_BLEND_DEFAULT), false, false);
}
void ReleaseHandle(void *handle) {
if (handle != nullptr)
reinterpret_cast<HandleRelease_t>(Offsets::FUN_HANDLE_RELEASE)(handle);
@@ -71,7 +74,7 @@ void ReleaseHandle(void *handle) {
// Same failure test and cleanup as SetTexture: a status level of 2 or more
// closes the green fallback and passes the status to the (silent)
// system-message printer; the status is destroyed either way.
void *LoadByPath(const char *path) {
void *LoadByPath(const char *path, uint32_t flags) {
TexLoadDesc desc;
desc.vtbl = reinterpret_cast<void *>(Offsets::PTR_TEXLOAD_DESC_VTBL);
desc.field4 = 8;
@@ -79,7 +82,7 @@ void *LoadByPath(const char *path) {
desc.fieldC = reinterpret_cast<uintptr_t>(&desc.self8) | 1u;
desc.field10 = 0;
void *handle = reinterpret_cast<void *>(reinterpret_cast<TextureLoad_t>(
Offsets::FUN_TEXTURE_LOAD_BY_PATH)(path, &desc, DefaultFlags(), 0, 1));
Offsets::FUN_TEXTURE_LOAD_BY_PATH)(path, &desc, flags, 0, 1));
if (desc.field10 >= 2) {
ReleaseHandle(handle);
handle = nullptr;
+8 -4
View File
@@ -19,14 +19,18 @@
namespace Texture {
// The loaded handle, or nullptr when the file does not load. Linear filter,
// clamped, the flags SetTexture's own call builds. The caller owns one
// reference and drops it with ReleaseHandle.
void *LoadByPath(const char *path);
// The texture flags word SetTexture's own call builds, with a filter and a
// repeat per axis (FUN_GX_TEXFLAGS_INIT).
uint32_t Flags(uint32_t filter, bool wrapU, bool wrapV);
// SetTexture's texture flags: the default filter, clamped, one mip level.
uint32_t DefaultFlags();
// The loaded handle, or nullptr when the file does not load, made with
// `flags` (SetTexture's own by default). The caller owns one reference and
// drops it with ReleaseHandle.
void *LoadByPath(const char *path, uint32_t flags = DefaultFlags());
// Drops one reference on a handle (FUN_HANDLE_RELEASE). Null is a no-op.
void ReleaseHandle(void *handle);
+262
View File
@@ -0,0 +1,262 @@
// This file is part of ClassicAPI.
//
// ClassicAPI 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.
//
// ClassicAPI 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
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
// `texture:SetHorizTile` / `GetHorizTile` / `SetVertTile` / `GetVertTile` and
// the XML `horizTile` / `vertTile` attributes: the image repeated at its own
// size across the texture, as 4.3.4 tiles it.
//
// 4.3.4 keeps a tile flag per axis. After a size change its layer batch build
// (CRenderBatch::QueueTexture) sets every non-zero coordinate on a tiled axis
// to the texture's length over the image's: the length in script units,
// DDCToNDCWidth(aspect * 1024 * length) / layoutScale, over the device
// texture's width or height in texels. One texel is one unit of GetWidth.
//
// 1.12's layer batch keeps a pointer to the eight coordinates and reads them
// on every draw (FUN_00772FD0), so the count is written straight into them
// whenever an input changes: after each corner store (every layout, through
// Texture::CornerStore), after each coordinate write (both SetTexCoord
// forms), on a tile change, and after the batch build's per-texture emit
// (FUN_SIMPLETEXTURE_EMIT), where the image is first loaded and its size
// known. The script units are the engine's own push of a script coordinate,
// DivideByScreenScaleX(aspect * 1024 * length), over the effective scale.
// Counting after a coordinate write goes past 4.3.4, which waits for the next
// size change: NineSlice calls SetTexCoord after SetHorizTile.
//
// A tiled axis also repeats (Texture::Wrap). Retail fixes the tiling SetAtlas
// clears with SetVertTile(true) alone (Blizzard_LegacyChallengeButton.lua), so
// the flag carries the wrap, and 4.3.4's CSimpleStatusBar::SetBarTexture
// passes the tile flags as the wrap.
//
// Not counted: a texture showing an atlas (an atlas here is part of its file,
// which a repeat cannot repeat alone) and one with SetTexCoordModifiesRect on
// (its coordinates size its rect). A StatusBar's tiled bar texture takes the
// 4.3.4 layout, which moves the texture instead of cropping its coordinates
// (StatusBar::Fill).
//
// XML: the attributes apply when present and non-empty, as in 4.3.4's loader.
// A <TexCoords> `left` / `right` other than 0 / 1 on a horizontally tiled
// texture, or `top` / `bottom` on a vertically tiled one, is 4.3.4's error
// "Invalid TexCoords value (horizTile is on)". 4.3.4 then ignores the element;
// here the engine has applied it already, so the coordinates go back to the
// whole image.
#include "Game.h"
#include "Offsets.h"
#include "texture/Atlas.h"
#include "texture/CornerStore.h"
#include "texture/Wrap.h"
#include "xml/FrameLoad.h"
#include "xml/TypeLoad.h"
#include <cstdint>
namespace Texture::Tile {
namespace {
using GetRect_t = int(__fastcall *)(void *anchor, void *edx, float *outRect);
using ScreenAspect_t = float(__cdecl *)();
using DivideByScreenScaleX_t = float(__stdcall *)(float value);
using SetTexCoord_t = void(__fastcall *)(void *texture, void *edx, const float *values);
using Emit_t = void(__fastcall *)(void *texture, void *edx, void *batch);
// UL, LL, UR, LR: the whole image.
constexpr float kWholeImage[8] = {0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f};
// A length in rect units as script units.
float ScriptUnits(float length) {
const auto aspect = reinterpret_cast<ScreenAspect_t>(Offsets::FUN_COORD_GET_SCALED_SCREEN_ASPECT);
const auto divide = reinterpret_cast<DivideByScreenScaleX_t>(Offsets::FUN_COORD_DIVIDE_BY_SCREEN_SCALE_X);
return divide(aspect() * Game::Read<float>(Offsets::FLOAT_SCRIPT_COORD_SCALE) * length);
}
// 4.3.4's rule on one axis (0 x, 1 y) of the four corner pairs.
void Count(float *coords, int axis, float length, uint32_t texels) {
if (texels == 0 || !(length > 0.0f))
return;
const float count = length / static_cast<float>(texels);
for (int i = 0; i < 4; ++i)
if (coords[i * 2 + axis] != 0.0f)
coords[i * 2 + axis] = count;
}
void Apply(void *texture) {
bool h, v;
if (!Texture::Wrap::Tiles(texture, h, v))
return;
if (Game::Read<int>(texture, Offsets::OFF_REGION_TEXCOORD_MODIFIES_RECT) != 0 || Texture::Atlas::Shows(texture))
return;
void *image = Game::Read<void *>(texture, Offsets::OFF_SIMPLETEXTURE_HTEXTURE);
const void *device = image != nullptr ? Game::Read<void *>(image, Offsets::OFF_HTEXTURE_DEVICE) : nullptr;
if (device == nullptr)
return; // the emit of the next batch build counts it
float rect[4]; // bottom, left, top, right
if (reinterpret_cast<GetRect_t>(Offsets::FUN_REGION_GET_RECT)(
Game::Ptr<uint8_t>(texture, Offsets::OFF_REGION_ANCHOR), nullptr, rect) == 0)
return;
const float scale = Game::Read<float>(texture, Offsets::OFF_REGION_EFFECTIVE_SCALE);
if (!(scale > 0.0f))
return;
float *coords = Game::Ptr<float>(texture, Offsets::OFF_SIMPLETEXTURE_TEXCOORDS);
if (h)
Count(coords, 0, ScriptUnits(rect[3] - rect[1]) / scale,
Game::Read<uint32_t>(device, Offsets::OFF_GXTEX_WIDTH));
if (v)
Count(coords, 1, ScriptUnits(rect[2] - rect[0]) / scale,
Game::Read<uint32_t>(device, Offsets::OFF_GXTEX_HEIGHT));
}
// --- what moves the count -----------------------------------------------------
void OnCornersStored(void *region) { Apply(region); }
const Texture::CornerStore::AutoSubscribe _cornerSub{&OnCornersStored};
SetTexCoord_t g_origSetRect = nullptr;
SetTexCoord_t g_origSetCorners = nullptr;
Emit_t g_origEmit = nullptr;
void __fastcall SetTexCoordRect_h(void *texture, void *edx, const float *rect) {
g_origSetRect(texture, edx, rect);
Apply(texture);
}
void __fastcall SetTexCoordCorners_h(void *texture, void *edx, const float *corners) {
g_origSetCorners(texture, edx, corners);
Apply(texture);
}
void __fastcall Emit_h(void *texture, void *edx, void *batch) {
g_origEmit(texture, edx, batch);
Apply(texture);
}
const Game::HookAutoRegister _setRectHook{Offsets::FUN_SIMPLETEXTURE_SET_TEXCOORD,
reinterpret_cast<void *>(&SetTexCoordRect_h),
reinterpret_cast<void **>(&g_origSetRect)};
const Game::HookAutoRegister _setCornersHook{Offsets::FUN_SIMPLETEXTURE_SET_TEXCOORD_CORNERS,
reinterpret_cast<void *>(&SetTexCoordCorners_h),
reinterpret_cast<void **>(&g_origSetCorners)};
const Game::HookAutoRegister _emitHook{Offsets::FUN_SIMPLETEXTURE_EMIT, reinterpret_cast<void *>(&Emit_h),
reinterpret_cast<void **>(&g_origEmit)};
// --- Lua -----------------------------------------------------------------------
// Counted against the held image before Settle swaps in the repeating copy of
// the same file, which has no size until it is drawn.
void SetAxis(void *texture, bool horizontal, bool tiling) {
bool h, v;
Texture::Wrap::Tiles(texture, h, v);
(horizontal ? h : v) = tiling;
Texture::Wrap::SetTiles(texture, h, v);
Apply(texture);
Texture::Wrap::Settle(texture);
}
int __fastcall Script_SetHorizTile(void *L) {
if (void *texture = Game::Lua::ResolveTexture(L))
SetAxis(texture, true, Game::Lua::ToFlag(L, 2));
return 0;
}
int __fastcall Script_SetVertTile(void *L) {
if (void *texture = Game::Lua::ResolveTexture(L))
SetAxis(texture, false, Game::Lua::ToFlag(L, 2));
return 0;
}
int __fastcall Script_GetHorizTile(void *L) {
void *texture = Game::Lua::ResolveTexture(L);
if (texture == nullptr)
return 0;
bool h, v;
Texture::Wrap::Tiles(texture, h, v);
Game::Lua::PushBool(L, h);
return 1;
}
int __fastcall Script_GetVertTile(void *L) {
void *texture = Game::Lua::ResolveTexture(L);
if (texture == nullptr)
return 0;
bool h, v;
Texture::Wrap::Tiles(texture, h, v);
Game::Lua::PushBool(L, v);
return 1;
}
const Game::Lua::FrameMethodEntry g_methods[] = {
{"SetHorizTile", &Script_SetHorizTile},
{"GetHorizTile", &Script_GetHorizTile},
{"SetVertTile", &Script_SetVertTile},
{"GetVertTile", &Script_GetVertTile},
};
void RegisterLuaFunctions() {
Game::Lua::RegisterFrameMethods(reinterpret_cast<void *>(Offsets::VAR_TEXTURE_METHOD_REGISTRY), g_methods,
static_cast<int>(sizeof(g_methods) / sizeof(g_methods[0])));
}
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
// --- XML -----------------------------------------------------------------------
// The tile attribute a node's <TexCoords> breaks, as 4.3.4's loader tests it,
// or null.
const char *Conflict(const void *node, bool h, bool v) {
for (const void *child = Xml::FirstChild(node); child != nullptr; child = Xml::NextSibling(child)) {
if (!Xml::TagIs(child, "TexCoords"))
continue;
float value = 0.0f;
if (h && ((Xml::FloatAttr(child, "left", value) && value != 0.0f) ||
(Xml::FloatAttr(child, "right", value) && value != 1.0f)))
return "horizTile";
if (v && ((Xml::FloatAttr(child, "top", value) && value != 0.0f) ||
(Xml::FloatAttr(child, "bottom", value) && value != 1.0f)))
return "vertTile";
}
return nullptr;
}
void OnTextureNode(void *object, const void *node, void *status) {
const char *h = Xml::Attr(node, "horizTile");
const char *v = Xml::Attr(node, "vertTile");
const bool hasH = h != nullptr && *h != '\0';
const bool hasV = v != nullptr && *v != '\0';
bool tileH, tileV;
Texture::Wrap::Tiles(object, tileH, tileV);
if (hasH)
tileH = Game::StringToFlag(h);
if (hasV)
tileV = Game::StringToFlag(v);
if (hasH || hasV)
Texture::Wrap::SetTiles(object, tileH, tileV);
if (tileH || tileV) {
if (const char *flag = Conflict(node, tileH, tileV)) {
const char *name = Game::Read<const char *>(object, Offsets::OFF_SCRIPT_REGION_NAME);
Xml::Error(status, "Texture %s: Invalid TexCoords value (%s is on)",
name != nullptr ? name : "<unnamed>", flag);
reinterpret_cast<SetTexCoord_t>(Offsets::FUN_SIMPLETEXTURE_SET_TEXCOORD_CORNERS)(object, nullptr,
kWholeImage);
}
Apply(object);
}
if (hasH || hasV)
Texture::Wrap::Settle(object);
}
const Xml::TypeLoad::AutoSubscribe _xmlSub{Xml::TypeLoad::TEXTURE, &OnTextureNode};
} // namespace
} // namespace Texture::Tile
+288
View File
@@ -0,0 +1,288 @@
// This file is part of ClassicAPI.
//
// ClassicAPI 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.
//
// ClassicAPI 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
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
// `texture:SetTexture(file, wrapModeHorizontal, wrapModeVertical)`, the XML
// `hWrapMode` / `vWrapMode` attributes, and the repeat a tiled axis needs
// (Texture::Tile).
//
// 1.12 fixes a texture's wrap when its file loads. CSimpleTexture::SetTexture
// (FUN_SIMPLETEXTURE_SET_TEXTURE) builds the texture flags word with ONE wrap
// argument for both axes, and TextureCreate caches the handle under the name
// and that word, so a repeating copy of a file is its own shared texture. The
// device samples with the word's two wrap bits, repeat or clamp per axis
// (FUN_GX_TEXFLAGS_INIT). Its callers pass 0, except the XML texture loader,
// which passes 1 when a <TexCoords> value lies outside 0..1.
//
// A texture with a mode or a tile flag loads through a co-hook on that
// SetTexture: its own body, with a repeat per axis built into the flags word -
// the engine's wrap argument, the mode, or a tile flag. The engine's same-file
// early-out (FUN_TEXTURE_NAME_MATCH) ignores flags, so the co-hook also
// compares the held image's wrap, and for the same file with another wrap it
// swaps in the other copy and keeps the pixel shader the early-out would have
// kept. A change of mode or tiling reloads the held file the same way.
//
// The wrap arguments follow retail: true or "REPEAT" repeats, and anything
// else clamps, nil included, so SetTexture(file) clamps again. The device has
// no mirror or border mode, so "MIRROR", "CLAMPTOBLACK", "CLAMPTOBLACKADDITIVE"
// and "CLAMPTOWHITE" clamp. Tile flags survive SetTexture, as 4.3.4's do;
// SetAtlas clears modes and tiling (Clear), and while a texture shows an atlas
// its image keeps the atlas's clamp: a reload would replace the image the
// atlas binding is tied to.
#include "texture/Wrap.h"
#include "Game.h"
#include "Offsets.h"
#include "texture/Atlas.h"
#include "texture/Construct.h"
#include "texture/Load.h"
#include "xml/FrameLoad.h"
#include "xml/TypeLoad.h"
#include <cstdint>
#include <cstring>
#include <unordered_map>
namespace Texture::Wrap {
namespace {
struct State {
bool baseH = false, baseV = false; // the engine's own wrap argument for the image
bool modeH = false, modeV = false;
bool tileH = false, tileV = false;
bool Any() const { return modeH || modeV || tileH || tileV; }
bool RepeatH() const { return baseH || modeH || tileH; }
bool RepeatV() const { return baseV || modeV || tileV; }
};
std::unordered_map<const void *, State> g_state;
constexpr uint32_t kWrapBits = Offsets::GXTEX_FLAG_WRAP_U | Offsets::GXTEX_FLAG_WRAP_V;
using SetTexture_t = uint32_t(__fastcall *)(void *texture, void *edx, const char *name, uint32_t wrap,
uint32_t filter, uint32_t shader);
using NameMatch_t = int(__fastcall *)(void *hTexture, const char *name);
using GetUiPixelShader_t = void *(__fastcall *)(uint32_t index);
using NotifyLayerChanged_t = void(__fastcall *)(void *region);
SetTexture_t g_origSetTexture = nullptr;
void *HeldImage(const void *texture) { return Game::Read<void *>(texture, Offsets::OFF_SIMPLETEXTURE_HTEXTURE); }
// The flags word the held image samples with: its device texture's, or for a
// BLP still loading, the word the handle was made with.
uint32_t HeldFlags(void *image) {
if (const void *device = Game::Read<void *>(image, Offsets::OFF_HTEXTURE_DEVICE))
return Game::Read<uint32_t>(device, Offsets::OFF_GXTEX_FLAGS);
return Game::Read<uint32_t>(image, Offsets::OFF_HTEXTURE_TEX_FLAGS);
}
// CSimpleTexture::SetTexture with a repeat per axis, and a same-file
// early-out that also compares the wrap. An empty name is the engine's clear.
uint32_t Load(void *texture, const char *name, bool repeatH, bool repeatV, uint32_t filter, uint32_t shader) {
if (name == nullptr || *name == '\0')
return g_origSetTexture(texture, nullptr, name, 0, filter, shader);
void *held = HeldImage(texture);
const uint32_t flags = Texture::Flags(filter, repeatH, repeatV);
const bool sameFile =
held != nullptr && reinterpret_cast<NameMatch_t>(Offsets::FUN_TEXTURE_NAME_MATCH)(held, name) != 0;
if (sameFile && (HeldFlags(held) & kWrapBits) == (flags & kWrapBits))
return 1;
void *image = Texture::LoadByPath(name, flags);
if (image == nullptr)
return 0;
if (!sameFile)
Game::Ref<void *>(texture, Offsets::OFF_SIMPLETEXTURE_SHADER) =
reinterpret_cast<GetUiPixelShader_t>(Offsets::FUN_UI_GET_PIXEL_SHADER)(shader);
Texture::ReleaseHandle(held);
Game::Ref<void *>(texture, Offsets::OFF_SIMPLETEXTURE_HTEXTURE) = image;
reinterpret_cast<NotifyLayerChanged_t>(Offsets::FUN_REGION_NOTIFY_LAYER_CHANGED)(texture);
return 1;
}
uint32_t __fastcall SetTexture_h(void *texture, void *edx, const char *name, uint32_t wrap, uint32_t filter,
uint32_t shader) {
const auto it = g_state.find(texture);
if (it == g_state.end())
return g_origSetTexture(texture, edx, name, wrap, filter, shader);
State next = it->second;
next.baseH = next.baseV = wrap != 0;
const uint32_t loaded = Load(texture, name, next.RepeatH(), next.RepeatV(), filter, shader);
if (loaded != 0)
it->second = next;
return loaded;
}
const Game::HookAutoRegister _setTextureHook{Offsets::FUN_SIMPLETEXTURE_SET_TEXTURE,
reinterpret_cast<void *>(&SetTexture_h),
reinterpret_cast<void **>(&g_origSetTexture)};
// The held file again with the state's wrap. A solid colour or a pixel source
// has no file to load, and an atlas keeps its image (see the header).
void Reconcile(void *texture, const State &state) {
void *held = HeldImage(texture);
if (held == nullptr ||
(Game::Read<uint32_t>(held, Offsets::OFF_HTEXTURE_SOURCE) & Offsets::HTEXTURE_SOURCE_FILE) == 0 ||
Texture::Atlas::Shows(texture))
return;
char name[0x104];
std::memcpy(name, Game::Ptr<const char>(held, Offsets::OFF_HTEXTURE_NAME), sizeof(name));
name[sizeof(name) - 1] = '\0';
Load(texture, name, state.RepeatH(), state.RepeatV(), HeldFlags(held) & Offsets::GXTEX_FLAG_FILTER_MASK, 0);
}
// The texture's state, made on first use with the held image's wrap as the
// engine's own: without state, the engine loaded it.
State &Touch(void *texture) {
const auto it = g_state.find(texture);
if (it != g_state.end())
return it->second;
State state;
if (void *held = HeldImage(texture)) {
const uint32_t flags = HeldFlags(held);
state.baseH = (flags & Offsets::GXTEX_FLAG_WRAP_U) != 0;
state.baseV = (flags & Offsets::GXTEX_FLAG_WRAP_V) != 0;
}
return g_state.emplace(texture, state).first->second;
}
// Retail's wrap mode argument: true or "REPEAT" repeats; nil, false and the
// other modes clamp.
bool RepeatsArg(void *L, int index) {
if (Game::Lua::Type(L, index) == Game::Lua::TYPE_STRING)
return Game::StrCmpI(Game::Lua::ToString(L, index), "REPEAT") == 0;
return Game::Lua::ToBoolean(L, index) != 0;
}
// texture:SetTexture(file[, wrapModeHorizontal, wrapModeVertical]): the engine
// method, with the modes stored first so its load takes them. The colour form
// keeps the modes.
int __fastcall Script_SetTexture(void *L) {
void *texture = Game::Lua::IsNumber(L, 2) ? nullptr : Game::Lua::ResolveTexture(L, 1, false);
const bool repeatH = texture != nullptr && RepeatsArg(L, 3);
const bool repeatV = texture != nullptr && RepeatsArg(L, 4);
if (texture != nullptr && (repeatH || repeatV || g_state.count(texture) != 0)) {
State &state = Touch(texture);
state.modeH = repeatH;
state.modeV = repeatV;
}
const int results = reinterpret_cast<Game::Lua::CFunction>(Offsets::FUN_SCRIPT_TEXTURE_SET_TEXTURE)(L);
if (texture != nullptr)
Settle(texture); // a file that did not load leaves the old image to match
return results;
}
// The value of a wrap mode attribute, warning on a name retail does not have.
bool RepeatsAttr(const char *value, const void *node, void *status) {
static const char *const kClamps[] = {"CLAMP", "CLAMPTOBLACK", "CLAMPTOBLACKADDITIVE", "CLAMPTOWHITE", "MIRROR"};
if (Game::StrCmpI(value, "REPEAT") == 0)
return true;
for (const char *mode : kClamps)
if (Game::StrCmpI(value, mode) == 0)
return false;
Xml::Warn(status, "Unknown wrap mode %s in element %s", value, Xml::Tag(node));
return false;
}
// Retail's `hWrapMode` / `vWrapMode`, applied when present and non-empty.
void OnTextureNode(void *object, const void *node, void *status) {
const char *h = Xml::Attr(node, "hWrapMode");
const char *v = Xml::Attr(node, "vWrapMode");
const bool hasH = h != nullptr && *h != '\0';
const bool hasV = v != nullptr && *v != '\0';
if (!hasH && !hasV)
return;
State &state = Touch(object);
if (hasH)
state.modeH = RepeatsAttr(h, node, status);
if (hasV)
state.modeV = RepeatsAttr(v, node, status);
Settle(object);
}
const Xml::TypeLoad::AutoSubscribe _xmlSub{Xml::TypeLoad::TEXTURE, &OnTextureNode};
void OnTextureConstructed(void *region) { g_state.erase(region); }
const Texture::Construct::AutoSubscribe _constructSub{&OnTextureConstructed};
void PrepareForReload() { g_state.clear(); }
const Game::ReloadAutoRegister _reloadReg{&PrepareForReload};
const Game::Lua::FrameMethodEntry g_methods[] = {
{"SetTexture", &Script_SetTexture},
};
void RegisterLuaFunctions() {
Game::Lua::RegisterFrameMethods(reinterpret_cast<void *>(Offsets::VAR_TEXTURE_METHOD_REGISTRY), g_methods,
static_cast<int>(sizeof(g_methods) / sizeof(g_methods[0])));
}
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
} // namespace
// The image back in step with the state, and the state dropped once it holds
// nothing beyond the engine's own wrap.
void Settle(void *texture) {
const auto it = g_state.find(texture);
if (it == g_state.end())
return;
const State state = it->second;
Reconcile(texture, state);
if (!state.Any())
g_state.erase(texture);
}
void SetModes(void *texture, bool repeatH, bool repeatV) {
State &state = Touch(texture);
state.modeH = repeatH;
state.modeV = repeatV;
Settle(texture);
}
void SetTiles(void *texture, bool h, bool v) {
State &state = Touch(texture);
state.tileH = h;
state.tileV = v;
}
bool Tiles(const void *texture, bool &h, bool &v) {
h = v = false;
if (g_state.empty())
return false;
const auto it = g_state.find(texture);
if (it == g_state.end())
return false;
h = it->second.tileH;
v = it->second.tileV;
return h || v;
}
bool Tiles(const void *texture) {
bool h, v;
return Tiles(texture, h, v);
}
void Clear(void *texture) {
if (g_state.find(texture) == g_state.end())
return;
State &state = g_state[texture];
state.modeH = state.modeV = state.tileH = state.tileV = false;
Settle(texture);
}
} // namespace Texture::Wrap
+41
View File
@@ -0,0 +1,41 @@
// This file is part of ClassicAPI.
//
// ClassicAPI 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.
//
// ClassicAPI 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
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
#pragma once
// A texture's wrap mode per axis, and its tile flags, which repeat an axis
// too. See Wrap.cpp.
namespace Texture::Wrap {
// Repeat or clamp per axis: SetTexture's wrap arguments and the XML
// `hWrapMode` / `vWrapMode` attributes.
void SetModes(void *texture, bool repeatH, bool repeatV);
// The tile flags, recorded without touching the image. Texture::Tile owns what
// they do to the coordinates: it counts against the held image, then Settle
// swaps in a copy of that file with the new repeat, which loads only when next
// drawn.
void SetTiles(void *texture, bool h, bool v);
// Reloads the held image with the repeat the modes and tile flags ask for.
void Settle(void *texture);
// The tile flags; true when either is on.
bool Tiles(const void *texture, bool &h, bool &v);
bool Tiles(const void *texture);
// No modes and no tile flags, the image back on the engine's own wrap, as
// SetAtlas leaves a texture.
void Clear(void *texture);
} // namespace Texture::Wrap
+12 -5
View File
@@ -30,6 +30,13 @@ using Hash_t = uint32_t(__stdcall *)(const char *s);
using StatusAdd_t = void(__cdecl *)(void *status, int level, const char *fmt, ...);
using ToFloat_t = float(__stdcall *)(const char *s);
void Report(void *status, int level, const char *fmt, const char *a, const char *b, const char *c) {
if (status == nullptr)
return;
const void *vtable = Game::Read<const void *>(status, 0);
Game::Read<StatusAdd_t>(vtable, Offsets::VTBL_XML_STATUS_ADD)(status, level, fmt, a, b, c);
}
} // namespace
const void *FirstChild(const void *node) {
@@ -95,11 +102,11 @@ bool FloatAttr(const void *node, const char *name, float &out) {
}
void Warn(void *status, const char *fmt, const char *a, const char *b, const char *c) {
if (status == nullptr)
return;
const void *vtable = Game::Read<const void *>(status, 0);
Game::Read<StatusAdd_t>(vtable, Offsets::VTBL_XML_STATUS_ADD)(
status, Offsets::XML_STATUS_WARNING, fmt, a, b, c);
Report(status, Offsets::XML_STATUS_WARNING, fmt, a, b, c);
}
void Error(void *status, const char *fmt, const char *a, const char *b, const char *c) {
Report(status, Offsets::XML_STATUS_ERROR, fmt, a, b, c);
}
bool PushWrapper(void *L, void *object) {
+3
View File
@@ -58,6 +58,9 @@ void LoadNode(void *object, const void *node, void *status);
// the same warning the loaders log ("Couldn't find inherited node: %s").
void Warn(void *status, const char *fmt, const char *a, const char *b = nullptr,
const char *c = nullptr);
// The same at STATUS_ERROR, the level 4.3.4's loaders give a value they reject.
void Error(void *status, const char *fmt, const char *a, const char *b = nullptr,
const char *c = nullptr);
// Pushes `object`'s Lua wrapper and returns true, registering an unnamed,
// never-exposed object the way the engine's own lazy path does. Pushes