jose/itchio-opengamepadui-artprovider-plugin
1
0
Fork 0
Code Issues Pull requests Projects Releases 20 Packages Wiki Activity Actions

refactor: remove animated GIF feature, keep static first-frame extraction
Some checks failed
Build plugin / build (push) Has been cancelled
Details

Browse source 
AnimatedTexture is deprecated and broken in Godot 4.4. Strip all animated
GIF infrastructure (frame cycling, focus handler, settings UI, frame delay
parsing). GIFs are now always converted to a static first-frame PNG cached
to disk. Banner stitching disk cache and format detection fallback retained.
This commit is contained in:
Jose Falanga 2026-08-20 01:09:02 -03:00
parent 494a00bb2a
commit dfe94b92be
3 changed files with 28 additions and 398 deletions
Download patch file Download diff file Expand all files Collapse all files

419
core/boxart_itch.gd
View file

@ -19,21 +19,14 @@ const FFMPEG_BUILDS_URL := "https://github.com/BtbN/FFmpeg-Builds/releases/downl
const CONNECT_POLL_DELAY_MS := 50
const READ_POLL_DELAY_MS := 10
const LOG_URL_MAX_LEN := 80
const SETTING_SECTION := "plugin.artprovider"
const SETTING_ANIMATED_GIFS := "animated_gifs"
const GIF_DEFAULT_FRAME_DELAY_MS := 100
const CACHE_DIR := "images"
const ANIM_FRAMES_DIR := "anim_frames"
const BANNER_CACHE_DIR := "banners"
const GIF_STATIC_DIR := "gif_static"
@export var use_caching: bool = true
var http_image := HTTPImageFetcher.new()
var _meta_cache_dir := "itch_art"
var _enriched_meta: Dictionary = {}
var settings_manager := load("res://core/global/settings_manager.tres") as SettingsManager
var _animated_texture_cache: Dictionary = {}
var _last_animated_setting: bool = false
var _focused_animated_texture: AnimatedTexture = null
var layout_map: Dictionary = {
LAYOUT.GRID_PORTRAIT: "-portrait",
@ -50,7 +43,6 @@ func _init() -> void:
super()
var globalized := ProjectSettings.globalize_path(BOXART_DIR)
DirAccess.make_dir_recursive_absolute(globalized)
DirAccess.make_dir_recursive_absolute(globalized + "/" + ANIM_FRAMES_DIR)
provider_id = "itch"
logger_name = "BoxArtItch"
@ -58,78 +50,23 @@ func _init() -> void:
func _ready() -> void:
super()
_enriched_meta = _load_enriched_meta()
_last_animated_setting = _is_animated_gifs_enabled()
logger.info("itch.io Art Provider loaded (animated_gifs=%s)" % str(_last_animated_setting))
logger.info("itch.io Art Provider loaded")
add_child(http_image)
get_viewport().gui_focus_changed.connect(_on_focus_changed)
logger.info("Connected gui_focus_changed signal on viewport: %s" % str(get_viewport()))
## Returns whether animated GIF covers are enabled in settings.
func _is_animated_gifs_enabled() -> bool:
return settings_manager.get_value(SETTING_SECTION, SETTING_ANIMATED_GIFS, false) as bool
## Handles focus changes across the UI. Pauses the previously focused
## card's AnimatedTexture and unpauses the newly focused one.
func _on_focus_changed(control: Control) -> void:
# Pause the previously focused animation.
if _focused_animated_texture != null:
if is_instance_valid(_focused_animated_texture):
logger.info("Focus: pausing previous AnimatedTexture")
_focused_animated_texture.pause = true
_focused_animated_texture = null
if control == null:
logger.info("Focus: control is null")
return
logger.info("Focus: control=%s (%s)" % [control.name, control.get_class()])
# Walk up the tree to find the GameCard parent.
var card: Control = control
while card != null:
if not is_instance_valid(card):
logger.info("Focus: invalid node while walking up")
return
if card is GameCard:
break
card = card.get_parent()
if card == null:
logger.info("Focus: no GameCard ancestor found for %s" % control.name)
return
# Check if the card's TextureRect has an AnimatedTexture.
var texture_rect := card.get_node_or_null("%TextureRect") as TextureRect
if texture_rect == null:
logger.info("Focus: %%TextureRect not found in card %s" % card.name)
return
if texture_rect.texture is AnimatedTexture:
_focused_animated_texture = texture_rect.texture as AnimatedTexture
_focused_animated_texture.pause = false
logger.info("Focus: unpaused AnimatedTexture on %s (%d frames)" % [card.name, _focused_animated_texture.frames_count])
else:
logger.info("Focus: texture on %s is %s (not AnimatedTexture)" % [card.name, str(texture_rect.texture)])
## Strips HTML srcset artifacts from a URL. Butlerd sometimes passes through
## itch.io cover URLs with trailing srcset descriptors like " 1x, h" or " 2x".
## These cause HTTPImageFetcher to fail because the URL is no longer valid.
func _sanitize_url(url: String) -> String:
if url.is_empty():
return url
# Srcset descriptors are separated by spaces — take only the URL portion.
var clean: String = url.split(" ")[0]
# Validate that the cleaned URL ends with a known image extension.
var ext: String = clean.get_extension().to_lower()
if ext not in IMAGE_EXTS:
logger.warn("Sanitized URL has unexpected extension '%s': %s" % [ext, clean.left(LOG_URL_MAX_LEN)])
return clean
## Returns whether a URL points to a GIF image. Handles both clean URLs and
## URLs contaminated with srcset artifacts (e.g. "image.gif 1x, h").
## Returns whether a URL points to a GIF image.
func _is_gif_url(url: String) -> bool:
return _sanitize_url(url).to_lower().ends_with(".gif")
@ -168,7 +105,6 @@ func _fetch_image_with_format_detection(url: String, cache_flags: int) -> Textur
if result != HTTPRequest.RESULT_SUCCESS or response_code != 200:
return null
# Detect actual format from Content-Type header.
var content_type := ""
for h in headers:
if h.to_lower().begins_with("content-type:"):
@ -184,7 +120,6 @@ func _fetch_image_with_format_detection(url: String, cache_flags: int) -> Textur
elif content_type.find("webp") != -1:
err = image.load_webp_from_buffer(body)
else:
# Unknown type — try PNG first, then JPEG.
err = image.load_png_from_buffer(body)
if err != OK:
err = image.load_jpg_from_buffer(body)
@ -228,7 +163,6 @@ func get_boxart(item: LibraryItem, kind: LAYOUT) -> Texture2D:
if use_caching:
cache_flags = Cache.FLAGS.LOAD | Cache.FLAGS.SAVE
# Banner: combine two screenshots side-by-side when available.
if kind == LAYOUT.BANNER and screenshots.size() >= 2:
return await _fetch_banner_textures(item, screenshots, cache_flags)
@ -245,13 +179,11 @@ func get_boxart(item: LibraryItem, kind: LAYOUT) -> Texture2D:
## Enriches game metadata by scraping the itch.io page for screenshots.
## Uses cached results when available.
func _enrich_metadata(game: Dictionary, game_id: int, title: String) -> Dictionary:
var meta: Dictionary = _enriched_meta.get(game_id, {})
if meta.is_empty() and game.has("url"):
logger.info("Enriching metadata for: %s (url=%s)" % [title, game.get("url", "")])
meta = await _fetch_game_page_metadata(game)
# Cache both successes and failures to avoid repeated requests.
_enriched_meta[game_id] = meta
_save_enriched_meta(game_id, meta)
if meta.is_empty():
@ -266,14 +198,9 @@ func _enrich_metadata(game: Dictionary, game_id: int, title: String) -> Dictiona
## Fetches two screenshots and combines them side-by-side for banner layout.
## The combined result is cached to disk via OGPU's Cache system so it is
## not re-stitched on every load. Falls back to individual screenshots if
## the combine fails.
func _fetch_banner_textures(item: LibraryItem, screenshots: Array, cache_flags: int) -> Texture2D:
# Build a synthetic cache key from both screenshot URLs.
var banner_key: String = screenshots[0] + "||" + screenshots[1]
# Check disk cache for a previously stitched banner.
if cache_flags & Cache.FLAGS.LOAD and Cache.is_cached(BANNER_CACHE_DIR, banner_key):
var cached := Cache.get_image(BANNER_CACHE_DIR, banner_key)
if cached != null:
@ -285,11 +212,9 @@ func _fetch_banner_textures(item: LibraryItem, screenshots: Array, cache_flags:
var tex_b := await _fetch_image(screenshots[1], cache_flags)
if tex_a != null and tex_b != null:
var stitched := _combine_side_by_side(tex_a, tex_b)
# Persist the stitched result to disk.
if cache_flags & Cache.FLAGS.SAVE and stitched != null:
Cache.save_image(BANNER_CACHE_DIR, banner_key, stitched)
return stitched
# Banner combine failed — fall back to single-image path.
logger.warn("Banner screenshot fetch failed: tex_a=%s tex_b=%s" % [str(tex_a != null), str(tex_b != null)])
if tex_a != null:
return tex_a
@ -323,7 +248,6 @@ func _url_for_layout(kind: LAYOUT, cover_url: String, screenshots: Array) -> Str
LAYOUT.GRID_LANDSCAPE:
return screenshots[0] if not screenshots.is_empty() else cover_url
LAYOUT.BANNER:
# Single screenshot fallback (two-screenshot case handled in get_boxart).
return screenshots[0] if not screenshots.is_empty() else cover_url
return ""
@ -339,25 +263,21 @@ func _best_portrait_url(game: Dictionary, _screenshots: Array) -> String:
## Ensures an ffmpeg binary is available. Checks the system PATH first,
## then falls back to a bundled copy under user://boxart/itch/. Downloads
## the static build on first use if neither is found.
## then falls back to a bundled copy under user://boxart/itch/.
func _ensure_ffmpeg() -> String:
if not _ffmpeg_bin.is_empty():
return _ffmpeg_bin
# 1. Check system PATH by probing directly.
var probe: Array = []
OS.execute("ffmpeg", ["-version"], probe, true)
if probe.size() > 0 and probe[0].find("ffmpeg version") != -1:
_ffmpeg_bin = "ffmpeg"
logger.info("Using system ffmpeg")
return _ffmpeg_bin
# 2. Check bundled location.
var bundled: String = ProjectSettings.globalize_path(BOXART_DIR) + "/ffmpeg"
if FileAccess.file_exists(bundled):
_ffmpeg_bin = bundled
logger.info("Using bundled ffmpeg: " + _ffmpeg_bin)
return _ffmpeg_bin
# 3. Download.
logger.info("ffmpeg not found — downloading static build")
if await _install_ffmpeg():
_ffmpeg_bin = ProjectSettings.globalize_path(BOXART_DIR) + "/ffmpeg"
@ -366,9 +286,7 @@ func _ensure_ffmpeg() -> String:
return ""
## Downloads a static ffmpeg build. Detects the platform and architecture
## the same way the itch plugin's butler installer does, then fetches
## the matching BtbN pre-built binary.
## Downloads a static ffmpeg build.
func _install_ffmpeg() -> bool:
var os_name := _detect_os()
var arch_name := _detect_arch()
@ -379,7 +297,6 @@ func _install_ffmpeg() -> bool:
return _extract_ffmpeg(body, os_name)
## Detects the current OS as a short name for ffmpeg builds.
func _detect_os() -> String:
if OS.get_name() == "Windows":
return "win"
@ -388,7 +305,6 @@ func _detect_os() -> String:
return "linux"
## Detects the CPU architecture as a short name for ffmpeg builds.
func _detect_arch() -> String:
if Engine.has_method("get_architecture_name"):
var arch: String = Engine.get_architecture_name()
@ -397,7 +313,6 @@ func _detect_arch() -> String:
return "64"
## Builds the download URL for the ffmpeg archive matching the given platform.
func _build_ffmpeg_url(os_name: String, arch_name: String) -> String:
var platform_slug := os_name + arch_name
var archive_name := "ffmpeg-master-latest-%s-gpl" % platform_slug
@ -408,7 +323,7 @@ func _build_ffmpeg_url(os_name: String, arch_name: String) -> String:
## Downloads bytes from a URL. Returns empty PackedByteArray on failure.
func _download_url_bytes(url: String) -> PackedByteArray:
var http := HTTPRequest.new()
http.timeout = HTTP_TIMEOUT_MS / 1000.0 # HTTPRequest uses seconds.
http.timeout = HTTP_TIMEOUT_MS / 1000.0
add_child.call_deferred(http)
await http.ready
@ -458,72 +373,44 @@ func _extract_ffmpeg(body: PackedByteArray, os_name: String) -> bool:
return true
## Unified image fetch that routes GIF URLs through ffmpeg and non-GIF URLs
## through the normal HTTPImageFetcher path. Checks the animated GIF setting
## on each call so toggling takes effect immediately.
## Unified image fetch. GIFs go through ffmpeg for first-frame extraction.
## Non-GIF URLs go through HTTPImageFetcher, with a format-detection
## fallback for .jpg URLs that are actually served as PNG by itch.zone.
func _fetch_image(url: String, cache_flags: int) -> Texture2D:
if _is_gif_url(url):
# Invalidate cache when the animated setting changes.
var animated: bool = _is_animated_gifs_enabled()
if animated != _last_animated_setting:
_animated_texture_cache.clear()
_last_animated_setting = animated
logger.info("Animated GIF setting changed to %s — cache cleared" % str(animated))
return await _fetch_gif_as_texture(url, cache_flags)
# HTTPImageFetcher uses the URL extension to pick the decoder, but
# itch.zone often serves PNG data for .jpg URLs. If the normal fetch
# fails for a .jpg/.jpeg URL, retry by detecting the actual format.
var texture := await http_image.fetch(url, cache_flags)
if texture == null and _is_jpg_url(url):
texture = await _fetch_image_with_format_detection(url, cache_flags)
return texture
## Downloads a GIF and converts it to a Godot texture. When animated GIFs
## are enabled, extracts all frames and returns an AnimatedTexture. Otherwise
## extracts only the first frame and returns a static ImageTexture.
## Results are cached in _animated_texture_cache keyed by URL. Animated frames
## are also persisted to disk under user://boxart/itch/anim_frames/<hash>/
## so subsequent loads skip ffmpeg extraction.
## Downloads a GIF and extracts the first frame as a static ImageTexture.
## Results are cached on disk under user://boxart/itch/gif_static/<hash>.png
## and in memory for the session.
func _fetch_gif_as_texture(url: String, cache_flags: int) -> Texture2D:
# Return cached result if available.
if _animated_texture_cache.has(url):
return _animated_texture_cache[url]
var animated: bool = _is_animated_gifs_enabled()
var url_hash := url.sha256_text().left(16)
var globalized_dir := ProjectSettings.globalize_path(BOXART_DIR)
var cached_frames_dir := globalized_dir + "/" + ANIM_FRAMES_DIR + "/" + url_hash
DirAccess.make_dir_recursive_absolute(globalized_dir + "/" + GIF_STATIC_DIR)
var url_hash := url.sha256_text().left(16)
var cached_png := globalized_dir + "/" + GIF_STATIC_DIR + "/" + url_hash + ".png"
# Check for disk-cached frames (animated) or PNG (static).
if animated and _has_cached_frames(cached_frames_dir):
logger.info("GIF fetch: loading %d cached frames from disk for %s" % [
_count_cached_frames(cached_frames_dir), url.left(LOG_URL_MAX_LEN)])
var delays := _load_cached_delays(cached_frames_dir)
return _assemble_from_disk_cache(cached_frames_dir, delays, url)
var cached_png := cached_frames_dir + ".png"
if not animated and FileAccess.file_exists(cached_png):
logger.info("GIF fetch: loading cached static frame from %s" % url.left(LOG_URL_MAX_LEN))
# Check disk cache.
if cache_flags & Cache.FLAGS.LOAD and FileAccess.file_exists(cached_png):
var image := Image.load_from_file(cached_png)
if image != null:
var texture := ImageTexture.create_from_image(image)
_animated_texture_cache[url] = texture
return texture
logger.info("GIF fetch: loaded cached static frame for %s" % url.left(LOG_URL_MAX_LEN))
return ImageTexture.create_from_image(image)
# Need to download and process the GIF.
var ffmpeg_bin := await _ensure_ffmpeg()
if ffmpeg_bin.is_empty():
return null
var gif_path := globalized_dir + "/_tmp_%s.gif" % url_hash
# Download the GIF bytes via HTTPClient.
var body := await _download_gif_bytes(url)
var body := await _download_url_bytes(url)
if body.is_empty():
return null
# Write GIF to temp file.
var gif_file := FileAccess.open(gif_path, FileAccess.WRITE)
if gif_file == null:
logger.warn("GIF fetch: cannot write temp gif")
@ -531,120 +418,22 @@ func _fetch_gif_as_texture(url: String, cache_flags: int) -> Texture2D:
gif_file.store_buffer(body)
gif_file.close()
var result: Texture2D
if animated:
result = await _build_animated_gif_texture(ffmpeg_bin, gif_path, cached_frames_dir, body, url)
else:
result = await _build_static_gif_texture(ffmpeg_bin, gif_path, cached_png, url)
# Clean up.
DirAccess.remove_absolute(gif_path)
# Cache the result in memory.
if result != null:
_animated_texture_cache[url] = result
return result
## Downloads GIF bytes from the given URL. Returns empty PackedByteArray on failure.
func _download_gif_bytes(url: String) -> PackedByteArray:
return await _download_url_bytes(url)
## Returns true if the given directory contains cached frame PNGs.
func _has_cached_frames(frames_dir: String) -> bool:
var dir := DirAccess.open(frames_dir)
if dir == null:
return false
dir.list_dir_begin()
var fname := dir.get_next()
var has_frames := false
while fname != "":
if fname.begins_with("frame_") and fname.ends_with(".png"):
has_frames = true
break
fname = dir.get_next()
dir.list_dir_end()
return has_frames
## Counts the number of cached frame PNGs in a directory.
func _count_cached_frames(frames_dir: String) -> int:
var dir := DirAccess.open(frames_dir)
if dir == null:
return 0
dir.list_dir_begin()
var count := 0
var fname := dir.get_next()
while fname != "":
if fname.begins_with("frame_") and fname.ends_with(".png"):
count += 1
fname = dir.get_next()
dir.list_dir_end()
return count
## Loads cached frame delays from a JSON file in the frames directory.
func _load_cached_delays(frames_dir: String) -> Array:
var delays_path := frames_dir + "/delays.json"
var file := FileAccess.open(delays_path, FileAccess.READ)
if file == null:
return []
var json := JSON.new()
var err := json.parse(file.get_as_text())
file.close()
if err != OK:
return []
if json.data is Array:
return json.data
return []
## Saves frame delays to a JSON file in the frames directory.
func _save_cached_delays(frames_dir: String, delays: Array) -> void:
var delays_path := frames_dir + "/delays.json"
var file := FileAccess.open(delays_path, FileAccess.WRITE)
if file == null:
return
file.store_string(JSON.stringify(delays))
file.close()
## Builds an AnimatedTexture from disk-cached frame PNGs.
func _assemble_from_disk_cache(frames_dir: String, delays: Array, url: String) -> AnimatedTexture:
var dir := DirAccess.open(frames_dir)
if dir == null:
return null
dir.list_dir_begin()
var frame_files: PackedStringArray = []
var fname := dir.get_next()
while fname != "":
if fname.begins_with("frame_") and fname.ends_with(".png"):
frame_files.append(fname)
fname = dir.get_next()
dir.list_dir_end()
frame_files.sort()
return _assemble_animated_texture(frame_files, frames_dir, delays, url)
## Extracts the first frame of a GIF using ffmpeg. Returns a static ImageTexture.
func _build_static_gif_texture(ffmpeg_bin: String, gif_path: String, png_path: String, url: String) -> Texture2D:
# Extract first frame via ffmpeg.
var ffmpeg_args: PackedStringArray = [
"-y", "-i", gif_path,
"-frames:v", "1",
"-f", "image2", png_path,
"-f", "image2", cached_png,
]
var ret: Array = []
OS.execute(ffmpeg_bin, ffmpeg_args, ret)
if not FileAccess.file_exists(png_path):
DirAccess.remove_absolute(gif_path)
if not FileAccess.file_exists(cached_png):
logger.warn("GIF fetch: ffmpeg did not produce output for %s" % url.left(LOG_URL_MAX_LEN))
return null
var image := Image.load_from_file(png_path)
var image := Image.load_from_file(cached_png)
if image == null:
logger.warn("GIF fetch: failed to load extracted PNG")
return null
@ -653,164 +442,13 @@ func _build_static_gif_texture(ffmpeg_bin: String, gif_path: String, png_path: S
return ImageTexture.create_from_image(image)
## Extracts all frames from a GIF using ffmpeg and builds an AnimatedTexture.
## The animation is paused by default — the focus handler unpauses it.
func _build_animated_gif_texture(ffmpeg_bin: String, gif_path: String, frames_dir: String, gif_bytes: PackedByteArray, url: String) -> AnimatedTexture:
var delays: Array = _parse_gif_frame_delays(gif_bytes)
var frame_files: PackedStringArray = _extract_gif_frames(ffmpeg_bin, gif_path, frames_dir)
if frame_files.is_empty():
return null
return _assemble_animated_texture(frame_files, frames_dir, delays, url)
## Extracts all frames from a GIF file using ffmpeg. Returns sorted frame filenames.
func _extract_gif_frames(ffmpeg_bin: String, gif_path: String, frames_dir: String) -> PackedStringArray:
DirAccess.make_dir_recursive_absolute(frames_dir)
var ffmpeg_args: PackedStringArray = [
"-y", "-i", gif_path,
"-vsync", "0",
frames_dir + "/frame_%04d.png",
]
var ret: Array = []
OS.execute(ffmpeg_bin, ffmpeg_args, ret)
var dir := DirAccess.open(frames_dir)
if dir == null:
logger.warn("GIF fetch: cannot open frames dir")
return PackedStringArray()
dir.list_dir_begin()
var frame_files: PackedStringArray = []
var fname := dir.get_next()
while fname != "":
if fname.begins_with("frame_") and fname.ends_with(".png"):
frame_files.append(fname)
fname = dir.get_next()
dir.list_dir_end()
frame_files.sort()
return frame_files
## Loads extracted frame images and assembles them into an AnimatedTexture.
## When frames_dir is a persistent cache dir, frames are kept on disk.
func _assemble_animated_texture(frame_files: PackedStringArray, frames_dir: String, delays: Array, url: String) -> AnimatedTexture:
var anim_tex := AnimatedTexture.new()
anim_tex.frames_count = frame_files.size()
anim_tex.pause = true # Start paused — focus handler unpauses.
var is_persistent := frames_dir.find("/" + ANIM_FRAMES_DIR + "/") != -1
var did_persist := false
for i in frame_files.size():
var frame_path := frames_dir + "/" + frame_files[i]
var image := Image.load_from_file(frame_path)
if not is_persistent:
DirAccess.remove_absolute(frame_path)
if image == null:
logger.warn("GIF fetch: failed to load frame %d" % i)
continue
anim_tex.set_frame_texture(i, ImageTexture.create_from_image(image))
var delay_ms: int = delays[i] if i < delays.size() else GIF_DEFAULT_FRAME_DELAY_MS
anim_tex.set_frame_delay(i, delay_ms / 1000.0) # AnimatedTexture uses seconds.
if not is_persistent:
DirAccess.remove_absolute(frames_dir)
else:
# Persist delays to disk for future reloads.
if not delays.is_empty():
_save_cached_delays(frames_dir, delays)
did_persist = true
logger.info("GIF fetch: built AnimatedTexture with %d frames from %s%s" % [
frame_files.size(), url.left(LOG_URL_MAX_LEN),
" (cached to disk)" if did_persist else ""])
return anim_tex
## Parses frame delays from a GIF89a binary. Returns an array of delays
## in milliseconds, one per frame. Falls back to GIF_DEFAULT_FRAME_DELAY_MS
## for frames without a Graphics Control Extension.
func _parse_gif_frame_delays(data: PackedByteArray) -> Array:
var delays: Array = []
if data.size() < 13:
return delays
var pos := _skip_gif_header(data)
while pos < data.size() - 1:
var byte: int = data[pos]
if byte == 0x21:
var result: Array = _parse_gif_extension(data, pos)
if result[0] >= 0:
delays.append(result[0])
pos = result[1]
elif byte == 0x2C:
pos = _skip_gif_image_descriptor(data, pos)
elif byte == 0x3B:
break
else:
pos += 1
return delays
## Skips the GIF header, Logical Screen Descriptor, and Global Color Table.
## Returns the byte offset past all header data.
func _skip_gif_header(data: PackedByteArray) -> int:
if data.size() < 13:
return data.size()
var pos := 13 # Header (6) + Logical Screen Descriptor (7).
var packed_byte: int = data[10]
if packed_byte & 0x80 != 0:
var gct_size := 3 * (1 << ((packed_byte & 0x07) + 1))
pos += gct_size
return pos
## Parses an extension block starting at `pos`. Returns [delay_ms, new_pos].
## If the extension is not a Graphics Control Extension, returns [-1, new_pos].
func _parse_gif_extension(data: PackedByteArray, pos: int) -> Array:
if pos + 2 >= data.size():
return [-1, data.size()]
var label: int = data[pos + 1]
var delay_ms := -1
if label == 0xF9 and pos + 5 < data.size():
var delay_cs: int = data[pos + 4] | (data[pos + 5] << 8)
delay_ms = delay_cs * 10 if delay_cs > 0 else GIF_DEFAULT_FRAME_DELAY_MS
pos += 2
while pos < data.size():
var block_size: int = data[pos]
pos += 1
if block_size == 0:
break
pos += block_size
return [delay_ms, pos]
## Skips an image descriptor and its associated data at `pos`.
func _skip_gif_image_descriptor(data: PackedByteArray, pos: int) -> int:
pos += 10
var img_packed: int = data[pos - 1]
if img_packed & 0x80 != 0:
var lct_size := 3 * (1 << ((img_packed & 0x07) + 1))
pos += lct_size
pos += 1 # LZW Minimum Code Size.
while pos < data.size():
var block_size: int = data[pos]
pos += 1
if block_size == 0:
break
pos += block_size
return pos
## Combines two textures side-by-side into a single banner image.
## Both images are scaled to the same height, then placed left and right.
func _combine_side_by_side(left: Texture2D, right: Texture2D) -> Texture2D:
var img_a := left.get_image()
var img_b := right.get_image()
if img_a == null or img_b == null:
return left
# Scale both to the same height (use the taller one).
var target_h: int = max(img_a.get_height(), img_b.get_height())
if img_a.get_height() != target_h:
var scale: float = float(target_h) / float(img_a.get_height())
@ -826,8 +464,7 @@ func _combine_side_by_side(left: Texture2D, right: Texture2D) -> Texture2D:
return ImageTexture.create_from_image(combined)
## Scrapes the itch.io game page for screenshots. The itch.io API does not
## expose screenshots, so the page HTML is the only source.
## Scrapes the itch.io game page for screenshots.
func _fetch_game_page_metadata(game: Dictionary) -> Dictionary:
var page_url: String = game.get("url", "")
if page_url.is_empty():
@ -848,12 +485,10 @@ func _fetch_game_page_metadata(game: Dictionary) -> Dictionary:
return _extract_screenshots_from_html(html, page_url)
## Returns true if the HTML contains a Cloudflare challenge page.
func _is_cloudflare_challenge(html: String) -> bool:
return html.find("challenge-platform") != -1 or html.find("cf-browser-verification") != -1
## Extracts screenshot URLs from the itch.io page HTML using regex.
func _extract_screenshots_from_html(html: String, page_url: String) -> Dictionary:
var shot_re := RegEx.new()
shot_re.compile(SCREENSHOT_REGEX_PATTERN)