Compare commits
No commits in common. "trunk" and "v0.1.9" have entirely different histories.
4 changed files with 134 additions and 370 deletions
|
|
@ -1,25 +0,0 @@
|
|||
extends VBoxContainer
|
||||
|
||||
## Settings screen for the itch.io art provider.
|
||||
##
|
||||
## Provides a toggle for animated GIF covers. When enabled, GIF cover art
|
||||
## is extracted frame-by-frame and displayed as an AnimatedTexture that
|
||||
## pauses when the card loses focus.
|
||||
|
||||
var settings_manager := load("res://core/global/settings_manager.tres") as SettingsManager
|
||||
|
||||
const SETTING_SECTION := "plugin.artprovider"
|
||||
const SETTING_ANIMATED_GIFS := "animated_gifs"
|
||||
|
||||
@onready var animated_toggle: Toggle = $%AnimatedGifsToggle
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
animated_toggle.button_pressed = settings_manager.get_value(
|
||||
SETTING_SECTION, SETTING_ANIMATED_GIFS, false
|
||||
) as bool
|
||||
animated_toggle.toggled.connect(_on_animated_gifs_toggled)
|
||||
|
||||
|
||||
func _on_animated_gifs_toggled(pressed: bool) -> void:
|
||||
settings_manager.set_value(SETTING_SECTION, SETTING_ANIMATED_GIFS, pressed)
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
[gd_scene load_steps=3 format=3]
|
||||
|
||||
[ext_resource type="Script" path="res://plugins/itch-artprovider/core/artprovider_settings.gd" id="1"]
|
||||
[ext_resource type="PackedScene" uid="uid://d1qb7euwlu7bh" path="res://core/ui/components/toggle.tscn" id="2"]
|
||||
|
||||
[node name="ArtProviderSettings" type="VBoxContainer"]
|
||||
anchors_preset = 15
|
||||
anchor_right = 1.0
|
||||
anchor_bottom = 1.0
|
||||
grow_horizontal = 2
|
||||
grow_vertical = 2
|
||||
theme_override_constants/separation = 10
|
||||
script = ExtResource("1")
|
||||
|
||||
[node name="AnimatedGifsToggle" parent="." instance=ExtResource("2")]
|
||||
unique_name_in_owner = true
|
||||
layout_mode = 2
|
||||
text = "Animate GIF covers"
|
||||
description = "Extract all frames from animated GIF covers. Uses more memory but shows the full animation. Pauses when the card is not focused."
|
||||
button_pressed = false
|
||||
|
|
@ -15,13 +15,9 @@ const META_CACHE_FILE := "itch_art_meta.json"
|
|||
const HTTP_TIMEOUT_MS := 15000
|
||||
const SCREENSHOT_REGEX_PATTERN := "https://img\\.itch\\.zone/aW1hZ2Uv[\\w+/=]*/original/[\\w+/=]*\\.[a-z]+"
|
||||
const IMAGE_EXTS := ["png", "jpg", "jpeg", "gif", "webp", "bmp"]
|
||||
const FFMPEG_BUILDS_URL := "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest"
|
||||
const CONNECT_POLL_DELAY_MS := 50
|
||||
const READ_POLL_DELAY_MS := 10
|
||||
const LOG_URL_MAX_LEN := 80
|
||||
const CACHE_DIR := "images"
|
||||
const BANNER_CACHE_DIR := "banners"
|
||||
const GIF_STATIC_DIR := "gif_static"
|
||||
|
||||
@export var use_caching: bool = true
|
||||
var http_image := HTTPImageFetcher.new()
|
||||
|
|
@ -35,14 +31,10 @@ var layout_map: Dictionary = {
|
|||
LAYOUT.LOGO: "-logo",
|
||||
}
|
||||
|
||||
## Resolved path to the ffmpeg binary (system or bundled). Populated lazily.
|
||||
var _ffmpeg_bin: String = ""
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
super()
|
||||
var globalized := ProjectSettings.globalize_path(BOXART_DIR)
|
||||
DirAccess.make_dir_recursive_absolute(globalized)
|
||||
DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(BOXART_DIR))
|
||||
provider_id = "itch"
|
||||
logger_name = "BoxArtItch"
|
||||
|
||||
|
|
@ -56,84 +48,25 @@ func _ready() -> void:
|
|||
|
||||
## 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.
|
||||
## 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").
|
||||
func _is_gif_url(url: String) -> bool:
|
||||
return _sanitize_url(url).to_lower().ends_with(".gif")
|
||||
|
||||
|
||||
## Returns whether a URL points to a JPEG image.
|
||||
func _is_jpg_url(url: String) -> bool:
|
||||
var clean := _sanitize_url(url).to_lower()
|
||||
return clean.ends_with(".jpg") or clean.ends_with(".jpeg")
|
||||
|
||||
|
||||
## Removes and frees an HTTPRequest node.
|
||||
func _remove_http(http: HTTPRequest) -> void:
|
||||
remove_child(http)
|
||||
http.queue_free()
|
||||
|
||||
|
||||
## Downloads an image and detects the actual format from content-type headers.
|
||||
## Used as a fallback when HTTPImageFetcher fails due to extension mismatch.
|
||||
func _fetch_image_with_format_detection(url: String, cache_flags: int) -> Texture2D:
|
||||
var http := HTTPRequest.new()
|
||||
http.timeout = HTTP_TIMEOUT_MS / 1000.0
|
||||
add_child.call_deferred(http)
|
||||
await http.ready
|
||||
|
||||
if http.request(url) != OK:
|
||||
_remove_http(http)
|
||||
return null
|
||||
|
||||
var args: Array = await http.request_completed
|
||||
var result: int = args[0]
|
||||
var response_code: int = args[1]
|
||||
var headers: PackedStringArray = args[2]
|
||||
var body: PackedByteArray = args[3]
|
||||
_remove_http(http)
|
||||
|
||||
if result != HTTPRequest.RESULT_SUCCESS or response_code != 200:
|
||||
return null
|
||||
|
||||
var content_type := ""
|
||||
for h in headers:
|
||||
if h.to_lower().begins_with("content-type:"):
|
||||
content_type = h.split(":", true, 1)[1].strip_edges().to_lower()
|
||||
break
|
||||
|
||||
var image := Image.new()
|
||||
var err: int = ERR_INVALID_DATA
|
||||
if content_type.find("png") != -1:
|
||||
err = image.load_png_from_buffer(body)
|
||||
elif content_type.find("jpeg") != -1 or content_type.find("jpg") != -1:
|
||||
err = image.load_jpg_from_buffer(body)
|
||||
elif content_type.find("webp") != -1:
|
||||
err = image.load_webp_from_buffer(body)
|
||||
else:
|
||||
err = image.load_png_from_buffer(body)
|
||||
if err != OK:
|
||||
err = image.load_jpg_from_buffer(body)
|
||||
|
||||
if err != OK:
|
||||
logger.warn("Format detection failed for %s (content-type: %s)" % [url.left(LOG_URL_MAX_LEN), content_type])
|
||||
return null
|
||||
|
||||
var texture := ImageTexture.create_from_image(image)
|
||||
if cache_flags & Cache.FLAGS.SAVE:
|
||||
Cache.save_image(CACHE_DIR, url, texture)
|
||||
return texture
|
||||
|
||||
|
||||
func get_boxart(item: LibraryItem, kind: LAYOUT) -> Texture2D:
|
||||
if not kind in layout_map:
|
||||
logger.error("Unsupported boxart layout: {0}".format([kind]))
|
||||
|
|
@ -151,39 +84,14 @@ func get_boxart(item: LibraryItem, kind: LAYOUT) -> Texture2D:
|
|||
logger.warn("Game title is empty for id %d" % game_id)
|
||||
return null
|
||||
|
||||
var meta := await _enrich_metadata(game, game_id, title)
|
||||
var screenshots: Array = meta.get("screenshots", []).map(_sanitize_url)
|
||||
var cover_url := _sanitize_url(_best_portrait_url(game, screenshots))
|
||||
if cover_url.is_empty():
|
||||
logger.warn("No cover URL for: %s (id=%d)" % [title, game_id])
|
||||
return null
|
||||
logger.info("cover_url=%s" % cover_url.left(LOG_URL_MAX_LEN))
|
||||
|
||||
var cache_flags := Cache.FLAGS.NONE
|
||||
if use_caching:
|
||||
cache_flags = Cache.FLAGS.LOAD | Cache.FLAGS.SAVE
|
||||
|
||||
if kind == LAYOUT.BANNER and screenshots.size() >= 2:
|
||||
return await _fetch_banner_textures(item, screenshots, cache_flags)
|
||||
|
||||
var url := _url_for_layout(kind, cover_url, screenshots)
|
||||
if url.is_empty():
|
||||
logger.warn("URL for layout %s is empty (cover=%s)" % [str(kind), cover_url])
|
||||
return null
|
||||
|
||||
logger.info("Fetching itch.io box art for: %s layout=%s url=%s" % [item.name, str(kind), url.left(LOG_URL_MAX_LEN)])
|
||||
var texture: Texture2D = await _fetch_image(url, cache_flags)
|
||||
if texture == null:
|
||||
logger.warn("Image download returned null for: %s url=%s" % [item.name, url.left(LOG_URL_MAX_LEN)])
|
||||
return texture
|
||||
|
||||
|
||||
## Enriches game metadata by scraping the itch.io page for screenshots.
|
||||
func _enrich_metadata(game: Dictionary, game_id: int, title: String) -> Dictionary:
|
||||
# Enrich on first access: scrape the itch.io page for screenshots.
|
||||
# Cached failures (empty screenshots) are stored to avoid repeated
|
||||
# requests against Cloudflare-protected pages.
|
||||
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)
|
||||
meta = _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():
|
||||
|
|
@ -194,33 +102,49 @@ func _enrich_metadata(game: Dictionary, game_id: int, title: String) -> Dictiona
|
|||
logger.info("Using cached metadata for: %s (%d screenshots)" % [title, meta.get("screenshots", []).size()])
|
||||
else:
|
||||
logger.warn("No URL in game dict for: %s" % title)
|
||||
return meta
|
||||
|
||||
var screenshots: Array = meta.get("screenshots", []).map(_sanitize_url)
|
||||
# Filter out GIF screenshots — Godot can't decode them.
|
||||
var non_gif_screenshots: Array = screenshots.filter(
|
||||
func(url): return not _is_gif_url(url)
|
||||
)
|
||||
if screenshots.size() != non_gif_screenshots.size():
|
||||
logger.info("Filtered %d GIF screenshots for: %s" % [screenshots.size() - non_gif_screenshots.size(), title])
|
||||
|
||||
## Fetches two screenshots and combines them side-by-side for banner layout.
|
||||
func _fetch_banner_textures(item: LibraryItem, screenshots: Array, cache_flags: int) -> Texture2D:
|
||||
var banner_key: String = screenshots[0] + "||" + screenshots[1]
|
||||
var cover_url := _sanitize_url(_best_portrait_url(game, non_gif_screenshots))
|
||||
if cover_url.is_empty():
|
||||
logger.warn("No cover URL for: %s (id=%d)" % [title, game_id])
|
||||
return null
|
||||
logger.info("cover_url=%s" % cover_url.left(LOG_URL_MAX_LEN))
|
||||
|
||||
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:
|
||||
logger.info("Banner: loaded cached stitched banner for %s" % item.name)
|
||||
return cached
|
||||
var cache_flags := Cache.FLAGS.NONE
|
||||
if use_caching:
|
||||
cache_flags = Cache.FLAGS.LOAD | Cache.FLAGS.SAVE
|
||||
|
||||
logger.info("Fetching itch.io banner (2 screenshots) for: " + item.name)
|
||||
var tex_a := await _fetch_image(screenshots[0], 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)
|
||||
if cache_flags & Cache.FLAGS.SAVE and stitched != null:
|
||||
Cache.save_image(BANNER_CACHE_DIR, banner_key, stitched)
|
||||
return stitched
|
||||
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
|
||||
if tex_b != null:
|
||||
return tex_b
|
||||
return null
|
||||
# Banner: combine two screenshots side-by-side when available.
|
||||
if kind == LAYOUT.BANNER and non_gif_screenshots.size() >= 2:
|
||||
logger.info("Fetching itch.io banner (2 screenshots) for: " + item.name)
|
||||
var tex_a := await http_image.fetch(non_gif_screenshots[0], cache_flags)
|
||||
var tex_b := await http_image.fetch(non_gif_screenshots[1], cache_flags)
|
||||
if tex_a != null and tex_b != null:
|
||||
return _combine_side_by_side(tex_a, tex_b)
|
||||
# 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
|
||||
if tex_b != null:
|
||||
return tex_b
|
||||
|
||||
var url := _url_for_layout(kind, cover_url, non_gif_screenshots)
|
||||
if url.is_empty():
|
||||
logger.warn("URL for layout %s is empty (cover=%s)" % [str(kind), cover_url])
|
||||
return null
|
||||
|
||||
logger.info("Fetching itch.io box art for: %s layout=%s url=%s" % [item.name, str(kind), url.left(LOG_URL_MAX_LEN)])
|
||||
var texture: Texture2D = await http_image.fetch(url, cache_flags)
|
||||
if texture == null:
|
||||
logger.warn("Image download returned null for: %s url=%s" % [item.name, url.left(LOG_URL_MAX_LEN)])
|
||||
return texture
|
||||
|
||||
|
||||
## Finds the itch.io game dict from the library item's launch items.
|
||||
|
|
@ -246,209 +170,53 @@ func _url_for_layout(kind: LAYOUT, cover_url: String, screenshots: Array) -> Str
|
|||
LAYOUT.GRID_PORTRAIT, LAYOUT.LOGO:
|
||||
return cover_url
|
||||
LAYOUT.GRID_LANDSCAPE:
|
||||
return screenshots[0] if not screenshots.is_empty() else cover_url
|
||||
# Prefer a non-GIF screenshot
|
||||
for url in screenshots:
|
||||
if not _is_gif_url(url):
|
||||
return url
|
||||
# cover_url is already sanitized and non-GIF by the time it reaches here
|
||||
return cover_url
|
||||
LAYOUT.BANNER:
|
||||
return screenshots[0] if not screenshots.is_empty() else cover_url
|
||||
# Single screenshot fallback (two-screenshot case handled in get_boxart).
|
||||
# Prefer a non-GIF screenshot.
|
||||
for url in screenshots:
|
||||
if not _is_gif_url(url):
|
||||
return url
|
||||
return cover_url
|
||||
return ""
|
||||
|
||||
|
||||
## Returns the best portrait/logo URL from the game data.
|
||||
## Prefers stillCoverUrl (the still/non-animated version of the cover),
|
||||
## then coverUrl. Screenshots are never used as capsule art.
|
||||
func _best_portrait_url(game: Dictionary, _screenshots: Array) -> String:
|
||||
## Returns a non-GIF URL suitable for portrait/logo from the game data.
|
||||
## Falls back through: stillCoverUrl → coverUrl (non-GIF) → first non-GIF
|
||||
## screenshot. Returns empty if only GIFs are available, since
|
||||
## HTTPImageFetcher cannot decode GIF images.
|
||||
func _best_portrait_url(game: Dictionary, screenshots: Array) -> String:
|
||||
# Prefer stillCoverUrl if it's not a GIF
|
||||
var still: String = game.get("stillCoverUrl", "")
|
||||
if not still.is_empty():
|
||||
if not still.is_empty() and not _is_gif_url(still):
|
||||
return still
|
||||
return game.get("coverUrl", "")
|
||||
|
||||
|
||||
## Ensures an ffmpeg binary is available. Checks the system PATH first,
|
||||
## then falls back to a bundled copy under user://boxart/itch/.
|
||||
func _ensure_ffmpeg() -> String:
|
||||
if not _ffmpeg_bin.is_empty():
|
||||
return _ffmpeg_bin
|
||||
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
|
||||
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
|
||||
logger.info("ffmpeg not found — downloading static build")
|
||||
if await _install_ffmpeg():
|
||||
_ffmpeg_bin = ProjectSettings.globalize_path(BOXART_DIR) + "/ffmpeg"
|
||||
return _ffmpeg_bin
|
||||
logger.warn("ffmpeg unavailable — GIF covers will not load")
|
||||
# Try coverUrl if it's not a GIF
|
||||
var cover: String = game.get("coverUrl", "")
|
||||
if not cover.is_empty() and not _is_gif_url(cover):
|
||||
return cover
|
||||
# Try the first non-GIF screenshot
|
||||
for url in screenshots:
|
||||
if not _is_gif_url(url):
|
||||
return url
|
||||
# All available URLs are GIFs — return empty so the caller gets null
|
||||
# instead of attempting a doomed fetch.
|
||||
return ""
|
||||
|
||||
|
||||
## Downloads a static ffmpeg build.
|
||||
func _install_ffmpeg() -> bool:
|
||||
var os_name := _detect_os()
|
||||
var arch_name := _detect_arch()
|
||||
var archive_url := _build_ffmpeg_url(os_name, arch_name)
|
||||
var body := await _download_url_bytes(archive_url)
|
||||
if body.is_empty():
|
||||
return false
|
||||
return _extract_ffmpeg(body, os_name)
|
||||
|
||||
|
||||
func _detect_os() -> String:
|
||||
if OS.get_name() == "Windows":
|
||||
return "win"
|
||||
if OS.get_name() == "macOS":
|
||||
return "macos"
|
||||
return "linux"
|
||||
|
||||
|
||||
func _detect_arch() -> String:
|
||||
if Engine.has_method("get_architecture_name"):
|
||||
var arch: String = Engine.get_architecture_name()
|
||||
if "arm64" in arch or "aarch64" in arch:
|
||||
return "arm64"
|
||||
return "64"
|
||||
|
||||
|
||||
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
|
||||
var ext := "zip" if os_name == "win" else "tar.xz"
|
||||
return "%s/%s.%s" % [FFMPEG_BUILDS_URL, archive_name, ext]
|
||||
|
||||
|
||||
## 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
|
||||
add_child.call_deferred(http)
|
||||
await http.ready
|
||||
|
||||
if http.request(url) != OK:
|
||||
logger.error("Error requesting: " + url)
|
||||
remove_child(http)
|
||||
http.queue_free()
|
||||
return PackedByteArray()
|
||||
|
||||
var args: Array = await http.request_completed
|
||||
var result: int = args[0]
|
||||
var response_code: int = args[1]
|
||||
var body: PackedByteArray = args[3]
|
||||
remove_child(http)
|
||||
http.queue_free()
|
||||
|
||||
if result != HTTPRequest.RESULT_SUCCESS or response_code != 200:
|
||||
logger.error("Download failed: HTTP %d for %s" % [response_code, url])
|
||||
return PackedByteArray()
|
||||
return body
|
||||
|
||||
|
||||
## Extracts the ffmpeg binary from the downloaded archive.
|
||||
func _extract_ffmpeg(body: PackedByteArray, os_name: String) -> bool:
|
||||
var globalized_dir := ProjectSettings.globalize_path(BOXART_DIR)
|
||||
DirAccess.make_dir_recursive_absolute(globalized_dir)
|
||||
var is_win: bool = os_name == "win"
|
||||
var ext := "zip" if is_win else "tar.xz"
|
||||
var archive_path := globalized_dir + "/ffmpeg." + ext
|
||||
var file := FileAccess.open(archive_path, FileAccess.WRITE)
|
||||
if file == null:
|
||||
logger.error("Cannot write ffmpeg archive to " + archive_path)
|
||||
return false
|
||||
file.store_buffer(body)
|
||||
file.close()
|
||||
|
||||
var out := []
|
||||
if is_win:
|
||||
OS.execute("unzip", ["-o", archive_path, "-d", globalized_dir], out)
|
||||
OS.execute("chmod", ["+x", globalized_dir + "/ffmpeg.exe"], out)
|
||||
else:
|
||||
OS.execute("tar", ["xf", archive_path, "-C", globalized_dir,
|
||||
"--strip-components=1", "--wildcards", "*/ffmpeg"], out)
|
||||
OS.execute("chmod", ["+x", globalized_dir + "/ffmpeg"], out)
|
||||
DirAccess.remove_absolute(archive_path)
|
||||
logger.info("ffmpeg installed to " + globalized_dir)
|
||||
return true
|
||||
|
||||
|
||||
## 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):
|
||||
return await _fetch_gif_as_texture(url, cache_flags)
|
||||
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 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:
|
||||
var globalized_dir := ProjectSettings.globalize_path(BOXART_DIR)
|
||||
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 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:
|
||||
logger.info("GIF fetch: loaded cached static frame for %s" % url.left(LOG_URL_MAX_LEN))
|
||||
return ImageTexture.create_from_image(image)
|
||||
|
||||
var ffmpeg_bin := await _ensure_ffmpeg()
|
||||
if ffmpeg_bin.is_empty():
|
||||
return null
|
||||
|
||||
var gif_path := globalized_dir + "/_tmp_%s.gif" % url_hash
|
||||
|
||||
var body := await _download_url_bytes(url)
|
||||
if body.is_empty():
|
||||
return null
|
||||
|
||||
var gif_file := FileAccess.open(gif_path, FileAccess.WRITE)
|
||||
if gif_file == null:
|
||||
logger.warn("GIF fetch: cannot write temp gif")
|
||||
return null
|
||||
gif_file.store_buffer(body)
|
||||
gif_file.close()
|
||||
|
||||
# Extract first frame via ffmpeg.
|
||||
var ffmpeg_args: PackedStringArray = [
|
||||
"-y", "-i", gif_path,
|
||||
"-frames:v", "1",
|
||||
"-f", "image2", cached_png,
|
||||
]
|
||||
var ret: Array = []
|
||||
OS.execute(ffmpeg_bin, ffmpeg_args, ret)
|
||||
|
||||
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(cached_png)
|
||||
if image == null:
|
||||
logger.warn("GIF fetch: failed to load extracted PNG")
|
||||
return null
|
||||
|
||||
logger.info("GIF fetch: extracted first frame from %s" % url.left(LOG_URL_MAX_LEN))
|
||||
return ImageTexture.create_from_image(image)
|
||||
|
||||
|
||||
## 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())
|
||||
|
|
@ -464,7 +232,8 @@ func _combine_side_by_side(left: Texture2D, right: Texture2D) -> Texture2D:
|
|||
return ImageTexture.create_from_image(combined)
|
||||
|
||||
|
||||
## Scrapes the itch.io game page for screenshots.
|
||||
## Scrapes the itch.io game page for screenshots. The itch.io API does not
|
||||
## expose screenshots, so the page HTML is the only source.
|
||||
func _fetch_game_page_metadata(game: Dictionary) -> Dictionary:
|
||||
var page_url: String = game.get("url", "")
|
||||
if page_url.is_empty():
|
||||
|
|
@ -472,30 +241,70 @@ func _fetch_game_page_metadata(game: Dictionary) -> Dictionary:
|
|||
return {}
|
||||
|
||||
logger.info("Scraping page for screenshots: " + page_url)
|
||||
var body := await _download_url_bytes(page_url)
|
||||
if body.is_empty():
|
||||
var http := HTTPClient.new()
|
||||
var parts := page_url.split("/")
|
||||
var use_tls := parts[0] == "https:"
|
||||
var err := http.connect_to_host(parts[2], 443 if use_tls else 80, TLSOptions.client() if use_tls else null)
|
||||
if err != OK:
|
||||
logger.warn("HTTP connect failed for %s: %d" % [page_url, err])
|
||||
return {}
|
||||
var deadline := Time.get_ticks_msec() + HTTP_TIMEOUT_MS
|
||||
while http.get_status() == HTTPClient.STATUS_CONNECTING or http.get_status() == HTTPClient.STATUS_RESOLVING:
|
||||
http.poll()
|
||||
if Time.get_ticks_msec() > deadline:
|
||||
http.close()
|
||||
logger.warn("HTTP connect timed out for: " + page_url)
|
||||
return {}
|
||||
OS.delay_msec(CONNECT_POLL_DELAY_MS)
|
||||
if http.get_status() != HTTPClient.STATUS_CONNECTED:
|
||||
logger.warn("HTTP not connected for %s: status=%d" % [page_url, http.get_status()])
|
||||
http.close()
|
||||
return {}
|
||||
|
||||
http.request(HTTPClient.METHOD_GET, "/" + "/".join(parts.slice(3)), PackedStringArray())
|
||||
deadline = Time.get_ticks_msec() + HTTP_TIMEOUT_MS
|
||||
while http.get_status() == HTTPClient.STATUS_REQUESTING:
|
||||
http.poll()
|
||||
if Time.get_ticks_msec() > deadline:
|
||||
http.close()
|
||||
logger.warn("HTTP request timed out for: " + page_url)
|
||||
return {}
|
||||
OS.delay_msec(READ_POLL_DELAY_MS)
|
||||
|
||||
var body := PackedByteArray()
|
||||
while http.get_status() == HTTPClient.STATUS_BODY:
|
||||
http.poll()
|
||||
var chunk: PackedByteArray = http.read_response_body_chunk()
|
||||
if chunk.is_empty():
|
||||
if Time.get_ticks_msec() > deadline:
|
||||
http.close()
|
||||
logger.warn("HTTP body read timed out for: " + page_url)
|
||||
return {}
|
||||
OS.delay_msec(READ_POLL_DELAY_MS)
|
||||
continue
|
||||
body.append_array(chunk)
|
||||
http.close()
|
||||
|
||||
var html := body.get_string_from_utf8()
|
||||
if html.is_empty():
|
||||
logger.warn("Empty HTML response for: " + page_url)
|
||||
return {}
|
||||
if _is_cloudflare_challenge(html):
|
||||
|
||||
# Detect Cloudflare challenge pages — no point extracting screenshots.
|
||||
if html.find("challenge-platform") != -1 or html.find("cf-browser-verification") != -1:
|
||||
logger.warn("Cloudflare challenge detected for: %s — falling back to cover art" % page_url)
|
||||
return {}
|
||||
return _extract_screenshots_from_html(html, page_url)
|
||||
|
||||
|
||||
func _is_cloudflare_challenge(html: String) -> bool:
|
||||
return html.find("challenge-platform") != -1 or html.find("cf-browser-verification") != -1
|
||||
|
||||
|
||||
func _extract_screenshots_from_html(html: String, page_url: String) -> Dictionary:
|
||||
var shot_re := RegEx.new()
|
||||
shot_re.compile(SCREENSHOT_REGEX_PATTERN)
|
||||
var screenshots: Array = []
|
||||
for m in shot_re.search_all(html):
|
||||
var url: String = _sanitize_url(m.get_string(0))
|
||||
if _is_gif_url(url):
|
||||
logger.debug("Skipping GIF screenshot: " + url)
|
||||
continue
|
||||
screenshots.append(url)
|
||||
|
||||
logger.info("Found %d screenshots for page %s" % [screenshots.size(), page_url])
|
||||
return {"screenshots": screenshots}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
{
|
||||
"plugin.id": "itch-artprovider",
|
||||
"plugin.name": "itch.io Art Provider",
|
||||
"plugin.version": "0.1.20",
|
||||
"plugin.version": "0.1.9",
|
||||
"plugin.min-api-version": "1.1.0",
|
||||
"plugin.link": "https://forge.thergic.ar/jose/itchio-opengamepadui-artprovider-plugin",
|
||||
"plugin.source": "https://forge.thergic.ar/jose/itchio-opengamepadui-artprovider-plugin",
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue