261 lines
9.9 KiB
Haxe
261 lines
9.9 KiB
Haxe
package;
|
|
|
|
import haxe.io.Path;
|
|
import openfl.utils.AssetLibrary;
|
|
import openfl.utils.AssetManifest;
|
|
import openfl.utils.AssetType;
|
|
import openfl.events.Event;
|
|
import openfl.events.EventDispatcher;
|
|
import sys.FileSystem;
|
|
import sys.io.File;
|
|
import haxe.crypto.Base64;
|
|
|
|
/**
|
|
* Custom asset management system that initializes OpenFL's asset system.
|
|
* This supplements OpenFL's built-in asset handling.
|
|
*/
|
|
class Assets {
|
|
// Track initialization state
|
|
public static var isLoaded:Bool = false;
|
|
|
|
// Event dispatcher for asset loading events
|
|
private static var dispatcher:EventDispatcher = new EventDispatcher();
|
|
|
|
// Potential manifest locations
|
|
private static var manifestPaths = [
|
|
"manifest/default.json",
|
|
"bin/cpp/manifest/default.json",
|
|
"../manifest/default.json"
|
|
];
|
|
|
|
// Event types
|
|
public static inline var ASSET_LOADED:String = "assetLoaded";
|
|
public static inline var ASSET_ERROR:String = "assetError";
|
|
|
|
/**
|
|
* Initialize the asset system
|
|
*/
|
|
public static function initializeAssets():Void {
|
|
if (isLoaded) return; // Don't load twice
|
|
|
|
trace("Initializing asset system...");
|
|
|
|
// First, try to initialize embedded assets if the macro created them
|
|
try {
|
|
if (Reflect.hasField(macros.AssetMacro, "initEmbeddedAssets")) {
|
|
trace("Initializing embedded assets...");
|
|
Reflect.callMethod(macros.AssetMacro,
|
|
Reflect.field(macros.AssetMacro, "initEmbeddedAssets"), []);
|
|
isLoaded = true;
|
|
}
|
|
} catch (e:Dynamic) {
|
|
trace("No embedded assets available: " + e);
|
|
}
|
|
|
|
// Then try to load from manifest files
|
|
loadFromManifest();
|
|
|
|
if (isLoaded) {
|
|
trace("Asset system initialized successfully.");
|
|
|
|
// Log available assets
|
|
trace("Available assets:");
|
|
for (assetPath in openfl.Assets.list()) {
|
|
var type = getAssetTypeString(assetPath);
|
|
trace(" - " + assetPath + " (Type: " + type + ")");
|
|
}
|
|
} else {
|
|
trace("WARNING: Asset system could not be fully initialized.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Try to load assets from an external manifest file
|
|
*/
|
|
private static function loadFromManifest():Void {
|
|
trace("Checking for asset manifest files...");
|
|
for (path in manifestPaths) {
|
|
if (FileSystem.exists(path)) {
|
|
try {
|
|
trace("Loading asset manifest from: " + path);
|
|
var content = File.getContent(path);
|
|
var jsonStartPos = 0;
|
|
while (jsonStartPos < content.length && content.charAt(jsonStartPos) != '{') {
|
|
jsonStartPos++;
|
|
}
|
|
if (jsonStartPos > 0) {
|
|
content = content.substr(jsonStartPos);
|
|
}
|
|
if (content == null || content.length == 0 || content.charAt(0) != '{') {
|
|
trace("Invalid JSON content in manifest file");
|
|
continue;
|
|
}
|
|
var manifestData = haxe.Json.parse(content);
|
|
var manifest = new AssetManifest();
|
|
manifest.name = manifestData.name;
|
|
manifest.assets = manifestData.assets;
|
|
manifest.rootPath = manifestData.rootPath != null ? manifestData.rootPath : Path.directory(path);
|
|
manifest.version = manifestData.version;
|
|
manifest.libraryType = manifestData.libraryType;
|
|
manifest.libraryArgs = manifestData.libraryArgs;
|
|
if (manifest.assets != null && manifest.assets.length > 0) {
|
|
trace("Parsed manifest with " + manifest.assets.length + " assets");
|
|
var library = AssetLibrary.fromManifest(manifest);
|
|
if (library != null) {
|
|
var libraryName = manifest.name != null ? manifest.name : "default";
|
|
if (openfl.Assets.hasLibrary(libraryName)) {
|
|
openfl.Assets.unloadLibrary(libraryName);
|
|
}
|
|
openfl.Assets.registerLibrary(libraryName, library);
|
|
trace("Registered asset library: " + libraryName);
|
|
isLoaded = true;
|
|
dispatcher.dispatchEvent(new Event(ASSET_LOADED));
|
|
return;
|
|
} else {
|
|
trace("ERROR: Failed to create library from manifest");
|
|
}
|
|
} else {
|
|
trace("ERROR: No assets found in manifest");
|
|
}
|
|
} catch (e:Dynamic) {
|
|
trace("Error loading manifest from " + path + ": " + e);
|
|
}
|
|
} else {
|
|
trace("Manifest not found at: " + path);
|
|
}
|
|
}
|
|
dispatcher.dispatchEvent(new Event(ASSET_ERROR));
|
|
}
|
|
|
|
/**
|
|
* Add event listener for asset events
|
|
*/
|
|
public static function addEventListener(type:String, listener:Dynamic->Void,
|
|
useCapture:Bool = false, priority:Int = 0,
|
|
useWeakReference:Bool = false):Void {
|
|
dispatcher.addEventListener(type, listener, useCapture, priority, useWeakReference);
|
|
}
|
|
|
|
/**
|
|
* Remove event listener
|
|
*/
|
|
public static function removeEventListener(type:String, listener:Dynamic->Void,
|
|
useCapture:Bool = false):Void {
|
|
dispatcher.removeEventListener(type, listener, useCapture);
|
|
}
|
|
|
|
/**
|
|
* Force reload the asset system
|
|
*/
|
|
public static function reload():Void {
|
|
var libraryNames = openfl.Assets.list().map(function(id) {
|
|
var parts = id.split(":");
|
|
return parts.length > 1 ? parts[0] : "default";
|
|
}).filter(function(name) {
|
|
return name != null && name != "";
|
|
});
|
|
|
|
var uniqueNames = new Map<String, Bool>();
|
|
for (name in libraryNames) {
|
|
uniqueNames.set(name, true);
|
|
}
|
|
|
|
for (name in uniqueNames.keys()) {
|
|
if (openfl.Assets.hasLibrary(name)) {
|
|
try {
|
|
openfl.Assets.unloadLibrary(name);
|
|
} catch (e:Dynamic) {
|
|
trace("Error unloading library " + name + ": " + e);
|
|
}
|
|
}
|
|
}
|
|
|
|
isLoaded = false;
|
|
initializeAssets();
|
|
}
|
|
|
|
/**
|
|
* Helper function to determine asset types by extension
|
|
*/
|
|
private static function getAssetTypeString(id:String):String {
|
|
try {
|
|
if (!openfl.Assets.exists(id)) return "unknown";
|
|
var extension = Path.extension(id).toLowerCase();
|
|
return switch(extension) {
|
|
case "jpg", "jpeg", "png", "gif", "bmp": "image";
|
|
case "mp3", "ogg", "wav": "sound";
|
|
case "ttf", "otf": "font";
|
|
case "txt", "json", "xml", "csv", "tsv": "text";
|
|
default: "binary";
|
|
}
|
|
} catch (e:Dynamic) {
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Debug the manifest and asset system status
|
|
*/
|
|
public static function debugManifest():String {
|
|
var result = "Asset System Status:\n";
|
|
result += "Initialized: " + isLoaded + "\n\n";
|
|
var hasManifest = false;
|
|
for (path in manifestPaths) {
|
|
if (FileSystem.exists(path)) {
|
|
hasManifest = true;
|
|
try {
|
|
var content = File.getContent(path);
|
|
var jsonStartPos = 0;
|
|
while (jsonStartPos < content.length && content.charAt(jsonStartPos) != '{') {
|
|
jsonStartPos++;
|
|
}
|
|
if (jsonStartPos > 0) {
|
|
content = content.substr(jsonStartPos);
|
|
}
|
|
result += "Manifest: " + path + "\n";
|
|
result += "Size: " + content.length + " bytes\n";
|
|
if (content.length > 200) {
|
|
result += "Content: " + content.substr(0, 200) + "...\n";
|
|
} else {
|
|
result += "Content: " + content + "\n";
|
|
}
|
|
var assetCount = "unknown";
|
|
try {
|
|
var jsonData = haxe.Json.parse(content);
|
|
if (jsonData != null && jsonData.assets != null) {
|
|
assetCount = Std.string(jsonData.assets.length);
|
|
}
|
|
} catch (e:Dynamic) {
|
|
assetCount = "Error: " + e;
|
|
}
|
|
result += "Assets: " + assetCount + "\n";
|
|
} catch (e:Dynamic) {
|
|
result += "Error reading manifest " + path + ": " + e + "\n";
|
|
}
|
|
}
|
|
}
|
|
if (!hasManifest) {
|
|
result += "No manifest files found.\n";
|
|
}
|
|
var libraryNames = [];
|
|
try {
|
|
for (asset in openfl.Assets.list()) {
|
|
var libName = "";
|
|
var colonIndex = asset.indexOf(":");
|
|
if (colonIndex > -1) {
|
|
libName = asset.substring(0, colonIndex);
|
|
} else {
|
|
libName = "default";
|
|
}
|
|
if (libraryNames.indexOf(libName) == -1) {
|
|
libraryNames.push(libName);
|
|
}
|
|
}
|
|
} catch (e:Dynamic) {
|
|
result += "Error getting libraries: " + e + "\n";
|
|
}
|
|
result += "\nLibraries: " + libraryNames.join(", ") + "\n";
|
|
result += "Asset count: " + openfl.Assets.list().length;
|
|
return result;
|
|
}
|
|
} |