mirror of
https://github.com/bryanthaboi/gen1recomp.git
synced 2026-08-25 15:01:11 +02:00
Merge pull request #1736 from thibautbus/fix/gold-ttf-printthrough-invisible-text
Stop drawing invisible TTF text on Gold's palette-shaded screens
This commit is contained in:
bryanthaboi
GitHub
+31
-3
@@ -138,11 +138,39 @@ function Chrome.printThrough(text, tx, ty, palette, invert)
|
||||
local paper = pal[1] or { 255, 255, 255 }
|
||||
love.graphics.setColor(paper[1] / 255, paper[2] / 255, paper[3] / 255, 1)
|
||||
love.graphics.rectangle("fill", tx * 8, ty * 8, width, 8)
|
||||
love.graphics.setColor(1, 1, 1, 1)
|
||||
-- Per glyph, not per string: a TTF-mod build still keeps the multi-byte
|
||||
-- charmap sequences (the naming screen's <PK>/<MN>, the 'd/'l/'s ligatures)
|
||||
-- and anything the mod names in ttf.tiles (Font.lua's own note on keeping
|
||||
-- digits tile-based for column alignment) on their ROM tiles, so a string
|
||||
-- can freely mix the two kinds of glyph.
|
||||
local ink = pal[4] or { 0, 0, 0 }
|
||||
local previous = love.graphics.getShader()
|
||||
local shaded = false
|
||||
local pen = tx * 8
|
||||
for _, code in ipairs(Font.encode(text)) do
|
||||
if code >= Font.TTF_BASE then
|
||||
-- The shader below recovers a shade from the RED CHANNEL of an already
|
||||
-- flat-shaded 2bpp tile sheet -- exactly what a TTF glyph is not.
|
||||
-- LÖVE's font rasterizer stores glyph coverage as alpha over a plain
|
||||
-- white texture, which this shader reads back as shade 0 no matter how
|
||||
-- solid the glyph looks, painting the character the SAME colour as the
|
||||
-- paper rect just drawn above it: invisible (reported against a real
|
||||
-- Gold build with a TTF translation mod active, gen1recomp#1642). A TTF
|
||||
-- glyph has no discrete shade to recover in the first place, so skip
|
||||
-- the shader for it and tint it with the palette's own ink colour
|
||||
-- (shade 3, the same entry `rgb = pal3` would have mapped a black tile
|
||||
-- pixel to) directly.
|
||||
if shaded then love.graphics.setShader(previous); shaded = false end
|
||||
love.graphics.setColor(ink[1] / 255, ink[2] / 255, ink[3] / 255, 1)
|
||||
elseif not shaded then
|
||||
love.graphics.setColor(1, 1, 1, 1)
|
||||
GbcPalette.useRaw(pal)
|
||||
Font.draw(text, tx * 8, ty * 8)
|
||||
love.graphics.setShader(previous)
|
||||
shaded = true
|
||||
end
|
||||
Font.drawCode(code, pen, ty * 8)
|
||||
pen = pen + Font.advanceOf(code)
|
||||
end
|
||||
if shaded then love.graphics.setShader(previous) end
|
||||
love.graphics.setColor(0, 0, 0, 1)
|
||||
return width
|
||||
end
|
||||
|
||||
@@ -0,0 +1,133 @@
|
||||
-- Chrome.printThrough (src/ui/gen2/Chrome.lua) used to run every string
|
||||
-- through the GbcPalette shade-remap shader whenever a palette was given,
|
||||
-- with no regard for whether the glyph it was about to draw came from a
|
||||
-- tile page or from a TTF. The shader recovers a shade by reading the
|
||||
-- RED CHANNEL of an already-rasterized 2bpp tile pixel (SHADER_SOURCE in
|
||||
-- src/render/GbcPalette.lua); a TTF glyph is LÖVE's own anti-aliased
|
||||
-- coverage mask, drawn as plain white with the current tint carrying the
|
||||
-- ink colour, which that same channel read always reports as shade 0 --
|
||||
-- painting every character the SAME colour as the paper rect printThrough
|
||||
-- had just drawn behind it, i.e. invisible. Reported against a real Gold
|
||||
-- build running a TTF translation mod: the naming screen's keyboard,
|
||||
-- Diploma and Pokegear text all vanish, since all three draw through this
|
||||
-- one routine (gen1recomp#1642).
|
||||
--
|
||||
-- The switch is per GLYPH, not per string: a TTF-mod build still keeps
|
||||
-- multi-byte charmap sequences (the naming screen's own <PK>/<MN> cells,
|
||||
-- the 'd/'l/'s ligatures) and anything a mod names in ttf.tiles on their ROM
|
||||
-- tiles (src/render/Font.lua's Font.split), so one call can mix both kinds
|
||||
-- of glyph and each must take its own path.
|
||||
--
|
||||
-- No real shader runs headless (love_stub does not stub newShader), so this
|
||||
-- cannot check a rendered pixel. Font.encode/drawCode/advanceOf/width are
|
||||
-- replaced with fakes that hand printThrough a fixed list of glyph codes,
|
||||
-- so what is checked is the two things that decide the outcome: which
|
||||
-- glyphs skip the shader, and what colour is active when each one draws.
|
||||
package.path = "./?.lua;./?/init.lua;" .. package.path
|
||||
|
||||
local T = require("tests.harness")
|
||||
|
||||
love = require("tests.love_stub")
|
||||
|
||||
require("src.core.Logger").warn = function() end
|
||||
|
||||
local Chrome = require("src.ui.gen2.Chrome")
|
||||
local GbcPalette = require("src.render.GbcPalette")
|
||||
local Font = require("src.render.Font")
|
||||
|
||||
-- Palette arrays are 1-indexed shade 0..3, same order GbcPalette.useRaw
|
||||
-- reads (src/render/GbcPalette.lua channel()).
|
||||
local PALETTE = { { 200, 220, 255 }, { 150, 170, 220 }, { 90, 100, 160 }, { 10, 10, 30 } }
|
||||
|
||||
local TILE_CODE = 0x80
|
||||
local TTF_CODE = Font.TTF_BASE + 65 -- 'A', were it decoded
|
||||
|
||||
-- "text" is a plain list of glyph codes for this suite; Font.width/encode
|
||||
-- pass it straight through, matching how a real caller's string would
|
||||
-- decode to a list of codes.
|
||||
Font.width = function(codes) return #codes * 8 end
|
||||
Font.encode = function(codes) return codes end
|
||||
Font.advanceOf = function(_code) return 8 end
|
||||
|
||||
local drawn
|
||||
Font.drawCode = function(code, x, y)
|
||||
drawn[#drawn + 1] = { code = code, x = x, y = y, color = { love.graphics.getColor() } }
|
||||
end
|
||||
|
||||
local useRawCalls
|
||||
local realUseRaw = GbcPalette.useRaw
|
||||
GbcPalette.useRaw = function(...)
|
||||
useRawCalls = useRawCalls + 1
|
||||
return realUseRaw(...)
|
||||
end
|
||||
|
||||
GbcPalette.available = function() return true end
|
||||
|
||||
local function colorsEq(a, b)
|
||||
return math.abs(a[1] - b[1]) < 1e-9 and math.abs(a[2] - b[2]) < 1e-9
|
||||
and math.abs(a[3] - b[3]) < 1e-9
|
||||
end
|
||||
|
||||
-- ------------------------------------------------------- all tile glyphs
|
||||
do
|
||||
useRawCalls = 0
|
||||
drawn = {}
|
||||
Chrome.printThrough({ TILE_CODE, TILE_CODE }, 0, 0, PALETTE)
|
||||
T.eq(useRawCalls, 1, "one shaded run binds the shader once, not per glyph")
|
||||
T.eq(#drawn, 2, "both glyphs drew")
|
||||
for i, d in ipairs(drawn) do
|
||||
T.check(colorsEq(d.color, { 1, 1, 1, 1 }),
|
||||
("tile glyph %d is tinted white, letting the shader pick the colour"):format(i))
|
||||
end
|
||||
end
|
||||
|
||||
-- -------------------------------------------------------- all TTF glyphs
|
||||
do
|
||||
useRawCalls = 0
|
||||
drawn = {}
|
||||
Chrome.printThrough({ TTF_CODE, TTF_CODE }, 0, 0, PALETTE)
|
||||
T.eq(useRawCalls, 0, "a TTF glyph never binds the shade-remap shader")
|
||||
T.eq(#drawn, 2, "both glyphs drew")
|
||||
local ink = Chrome.throughPalette(PALETTE, false)[4]
|
||||
for i, d in ipairs(drawn) do
|
||||
T.check(colorsEq(d.color, { ink[1] / 255, ink[2] / 255, ink[3] / 255, 1 }),
|
||||
("TTF glyph %d is tinted with the palette's own ink colour"):format(i))
|
||||
end
|
||||
end
|
||||
|
||||
-- --------------------------------------------- mixed: tile, TTF, then tile
|
||||
do
|
||||
useRawCalls = 0
|
||||
drawn = {}
|
||||
Chrome.printThrough({ TILE_CODE, TTF_CODE, TILE_CODE }, 0, 0, PALETTE)
|
||||
T.eq(useRawCalls, 2,
|
||||
"the shader re-binds once per return to a tile glyph, not once for the whole string")
|
||||
T.eq(#drawn, 3, "all three glyphs drew")
|
||||
local ink = Chrome.throughPalette(PALETTE, false)[4]
|
||||
T.check(colorsEq(drawn[1].color, { 1, 1, 1, 1 }), "1st (tile) glyph: white/shaded")
|
||||
T.check(colorsEq(drawn[2].color, { ink[1] / 255, ink[2] / 255, ink[3] / 255, 1 }),
|
||||
"2nd (TTF) glyph, mid-string, still gets the ink tint")
|
||||
T.check(colorsEq(drawn[3].color, { 1, 1, 1, 1 }), "3rd (tile) glyph: shaded again")
|
||||
end
|
||||
|
||||
-- ---------------------------------------------------- inverted TTF ink
|
||||
do
|
||||
drawn = {}
|
||||
Chrome.printThrough({ TTF_CODE }, 0, 0, PALETTE, true)
|
||||
local ink = Chrome.throughPalette(PALETTE, true)[4]
|
||||
T.check(colorsEq(drawn[1].color, { ink[1] / 255, ink[2] / 255, ink[3] / 255, 1 }),
|
||||
"an inverted call tints TTF ink with the inverted palette's own shade-3 entry")
|
||||
end
|
||||
|
||||
-- ---------------------------------------------- DMG mode's own TTF ink
|
||||
do
|
||||
GbcPalette.setMode("dmg")
|
||||
drawn = {}
|
||||
Chrome.printThrough({ TTF_CODE }, 0, 0, PALETTE)
|
||||
local ink = Chrome.throughPalette(PALETTE, false)[4]
|
||||
T.check(colorsEq(drawn[1].color, { ink[1] / 255, ink[2] / 255, ink[3] / 255, 1 }),
|
||||
"DMG mode's own resolved palette (four grey hardware shades) still reaches the TTF ink")
|
||||
GbcPalette.setMode("gbc")
|
||||
end
|
||||
|
||||
T.finish("gen2_chrome_print_through_ttf_test")
|
||||
Reference in New Issue
Block a user