#include #include #include #include #include #include #include #include #include #define VS_RUNTIME_TEXT // qui DrawTextEx e MeasureTextEx sono quelle di raylib #include "vs.h" #include "rlgl.h" void vs_BeginBlendMode(int mode) { BeginBlendMode(mode); rlBegin(RL_QUADS); rlEnd(); } // vedi vs.h void vs_EndBlendMode(void) { EndBlendMode(); rlBegin(RL_QUADS); rlEnd(); } #ifdef __vita__ #include #include #include #include #include #include #include #include #include #endif // --- Percorsi ---------------------------------------------------------------- static char data_dir[512]; void vs_init_paths(void) { #ifdef __vita__ snprintf(data_dir, sizeof(data_dir), "ux0:data/VampireSurvivors/"); #else const char *e = getenv("VS_DATA"); snprintf(data_dir, sizeof(data_dir), "%s/", e && *e ? e : "gamedata"); #endif } static void delete_tree(const char *path) { DIR *d = opendir(path); if (d) { struct dirent *e; while ((e = readdir(d))) { if (!strcmp(e->d_name, ".") || !strcmp(e->d_name, "..")) continue; char child[600]; snprintf(child, sizeof(child), "%s/%s", path, e->d_name); struct stat st; #ifdef __vita__ int ok = stat(child, &st); #else int ok = lstat(child, &st); // a link is removed, never followed #endif if (!ok && S_ISDIR(st.st_mode)) delete_tree(child); else remove(child); } closedir(d); } rmdir(path); } void vs_delete_all_and_exit(void) { char root[512]; const char *dev = getenv("VS_DELETE_ROOT"); // only to test the routine on a throwaway folder snprintf(root, sizeof(root), "%s", dev && *dev ? dev : data_dir); size_t n = strlen(root); if (n && root[n - 1] == '/') root[n - 1] = 0; #ifndef __vita__ if (!dev) { TraceLog(LOG_WARNING, "VS: delete all is disabled on the desktop"); exit(0); } #endif delete_tree(root); exit(0); } #define NET_WRAP_INPUT #include "net.h" const char *vs_asset(const char *rel) { static char buf[4][600]; static int i; char *b = buf[i++ & 3]; #ifdef __vita__ snprintf(b, sizeof(buf[0]), "app0:assets/%s", rel); #else const char *e = getenv("VS_ASSETS"); snprintf(b, sizeof(buf[0]), "%s/%s", e ? e : TextFormat("%sassets", GetApplicationDirectory()), rel); #endif return b; } const char *vs_boot_pic(void) { #ifdef __vita__ return "app0:sce_sys/pic0.png"; #else return TextFormat("%ssce_sys/pic0.png", GetApplicationDirectory()); #endif } const char *vs_path(const char *rel) { static char buf[8][600]; static int i; char *b = buf[i++ & 7]; snprintf(b, sizeof(buf[0]), "%s%s", data_dir, rel); return b; } static char *read_text(const char *rel) { int n = 0; unsigned char *d = LoadFileData(vs_path(rel), &n); if (!d) return NULL; char *s = malloc(n + 1); memcpy(s, d, n); s[n] = 0; UnloadFileData(d); return s; } cJSON *read_json(const char *rel) { char *s = read_text(rel); if (!s) return NULL; cJSON *j = cJSON_Parse(s); free(s); if (!j) TraceLog(LOG_WARNING, "VS: JSON non valido: %s", rel); return j; } // --- Atlanti ----------------------------------------------------------------- // Tutti i frame di tutti gli atlanti in una tabella hash (atlante + nome frame). #define MAX_ATLASES 64 #define MAX_PAGES 8 #define HASH_SIZE 65536 // potenza di 2, ben sopra i frame del gioco typedef struct { char name[48]; Texture2D pages[MAX_PAGES]; int n_pages; } Atlas; typedef struct { unsigned atlas; // indice + 1, 0 = vuoto char *name; Frame f; } Slot; static Atlas atlases[MAX_ATLASES]; static int n_atlases; static Slot *slots; static unsigned hash(unsigned atlas, const char *s) { unsigned h = 2166136261u ^ atlas; while (*s) h = (h ^ (unsigned char)*s++) * 16777619u; return h; } static int atlas_index(const char *name) { for (int i = 0; i < n_atlases; i++) if (!strcmp(atlases[i].name, name)) return i; return -1; } static void put_frame(int ai, const char *name, Frame f); static void add_frame(int ai, Texture2D *tex, cJSON *fr, const char *name) { cJSON *r = cJSON_GetObjectItem(fr, "frame"), *s = cJSON_GetObjectItem(fr, "spriteSourceSize"), *ss = cJSON_GetObjectItem(fr, "sourceSize"); if (!r) return; if (cJSON_IsTrue(cJSON_GetObjectItem(fr, "rotated"))) TraceLog(LOG_WARNING, "VS: frame ruotato non gestito: %s/%s", atlases[ai].name, name); Frame f = { tex, cJSON_GetObjectItem(r, "x")->valueint, cJSON_GetObjectItem(r, "y")->valueint, cJSON_GetObjectItem(r, "w")->valueint, cJSON_GetObjectItem(r, "h")->valueint, 0, 0, 0, 0 }; // Come Phaser (Textures/parsers/JSONHash): il ritaglio vale solo con trimmed: true. // Molti frame hanno trimmed false con uno spriteSourceSize spostato, da ignorare. if (cJSON_IsTrue(cJSON_GetObjectItem(fr, "trimmed"))) { f.ox = s ? cJSON_GetObjectItem(s, "x")->valueint : 0; f.oy = s ? cJSON_GetObjectItem(s, "y")->valueint : 0; f.sw = ss ? cJSON_GetObjectItem(ss, "w")->valueint : f.w; f.sh = ss ? cJSON_GetObjectItem(ss, "h")->valueint : f.h; } else { f.sw = f.w; f.sh = f.h; } put_frame(ai, name, f); } static void put_frame(int ai, const char *name, Frame f) { unsigned h = hash(ai + 1, name); for (unsigned k = 0; k < HASH_SIZE; k++) { Slot *sl = &slots[(h + k) & (HASH_SIZE - 1)]; if (!sl->atlas || (sl->atlas == (unsigned)ai + 1 && !strcmp(sl->name, name))) { if (!sl->atlas) sl->name = strdup(name); sl->atlas = ai + 1; sl->f = f; return; } } TraceLog(LOG_ERROR, "VS: tabella dei frame piena"); } int atlas_load(const char *name) { if (atlas_index(name) >= 0) return 1; if (n_atlases == MAX_ATLASES) return 0; if (!slots) slots = calloc(HASH_SIZE, sizeof(Slot)); char rel[128]; snprintf(rel, sizeof(rel), "img/%s.json", name); cJSON *j = read_json(rel); if (!j) return 0; int ai = n_atlases++; Atlas *a = &atlases[ai]; snprintf(a->name, sizeof(a->name), "%s", name); // Formato multi-pagina ("textures": [{image, frames: [...]}]) o hash semplice ("frames": {...}). cJSON *pages = cJSON_GetObjectItem(j, "textures"), *page; if (pages) { cJSON_ArrayForEach(page, pages) { if (a->n_pages == MAX_PAGES) break; const char *img = cJSON_GetStringValue(cJSON_GetObjectItem(page, "image")); snprintf(rel, sizeof(rel), "img/%s", img ? img : ""); Texture2D *t = &a->pages[a->n_pages++]; *t = LoadTexture(vs_path(rel)); cJSON *fr; cJSON_ArrayForEach(fr, cJSON_GetObjectItem(page, "frames")) add_frame(ai, t, fr, cJSON_GetStringValue(cJSON_GetObjectItem(fr, "filename"))); } } else { cJSON *meta = cJSON_GetObjectItem(j, "meta"); const char *img = meta ? cJSON_GetStringValue(cJSON_GetObjectItem(meta, "image")) : NULL; snprintf(rel, sizeof(rel), "img/%s", img ? img : ""); if (!img) snprintf(rel, sizeof(rel), "img/%s.png", name); Texture2D *t = &a->pages[a->n_pages++]; *t = LoadTexture(vs_path(rel)); cJSON *fr; cJSON_ArrayForEach(fr, cJSON_GetObjectItem(j, "frames")) { const char *fn = cJSON_GetStringValue(cJSON_GetObjectItem(fr, "filename")); add_frame(ai, t, fr, fn ? fn : fr->string); } } cJSON_Delete(j); return 1; } // Un PNG intero come fotogramma di un atlante senza JSON (personaggi CUSTOM): l'atlante nasce al primo int atlas_add_image(const char *atlas, const char *frame, const char *path) { int ai = atlas_index(atlas); if (ai < 0) { if (n_atlases == MAX_ATLASES) return 0; if (!slots) slots = calloc(HASH_SIZE, sizeof(Slot)); ai = n_atlases++; snprintf(atlases[ai].name, sizeof(atlases[ai].name), "%s", atlas); } if (!FileExists(path)) return 0; Texture2D *t = malloc(sizeof(*t)); // una texture per fotogramma; un atlante impacchettato se i CUSTOM diventano tanti *t = LoadTexture(path); if (!t->id) { free(t); return 0; } put_frame(ai, frame, (Frame){ t, 0, 0, (short)t->width, (short)t->height, 0, 0, (short)t->width, (short)t->height }); return 1; } const Frame *frame_get(const char *atlas, const char *frame) { if (!atlas || !frame) return NULL; // dati senza texture/frameName: fotogramma mancante, come in Phaser int ai = atlas_index(atlas); if (ai < 0 && (!atlas_load(atlas) || (ai = atlas_index(atlas)) < 0)) return NULL; unsigned h = hash(ai + 1, frame); for (unsigned k = 0; k < HASH_SIZE; k++) { Slot *sl = &slots[(h + k) & (HASH_SIZE - 1)]; if (!sl->atlas) return NULL; if (sl->atlas == (unsigned)ai + 1 && !strcmp(sl->name, frame)) return &sl->f; } return NULL; } // Centro della cornice originale in c (origine 0.5 come in Phaser). void frame_draw_ex(const Frame *f, Vector2 c, int flip, float sx, float sy, float angle, Color tint) { if (!f) return; Rectangle src = { f->x, f->y, flip ? -f->w : f->w, f->h }; float ox = flip ? f->sw - f->ox - f->w : f->ox; // origine = centro della cornice originale, cosi' la rotazione gira attorno a c Vector2 org = { (f->sw * 0.5f - ox) * sx, (f->sh * 0.5f - f->oy) * sy }; DrawTexturePro(*f->tex, src, (Rectangle){ c.x, c.y, f->w * sx, f->h * sy }, org, angle, tint); } void frame_draw(const Frame *f, Vector2 c, int flip, float scale, Color tint) { frame_draw_ex(f, c, flip, scale, scale, 0, tint); } // --- Dati e testi ------------------------------------------------------------- cJSON *data_get(const char *name) { static struct { char name[32]; cJSON *j; } cache[32]; for (int i = 0; i < 32; i++) { if (!cache[i].j) { char rel[64]; snprintf(rel, sizeof(rel), "data/%s.json", name); snprintf(cache[i].name, sizeof(cache[i].name), "%s", name); cache[i].j = read_json(rel); return cache[i].j; } if (!strcmp(cache[i].name, name)) return cache[i].j; } return NULL; } static cJSON *lang_all, *lang_cur, *lang_en; static char lang_code[8] = "en"; Font vs_font; int lang_load(const char *code) { if (!lang_all) lang_all = read_json("lang/lang.json"); if (!lang_all) return 0; cJSON *l = cJSON_GetObjectItem(lang_all, code); lang_cur = l ? cJSON_GetObjectItem(l, "translations") : NULL; lang_en = cJSON_GetObjectItem(cJSON_GetObjectItem(lang_all, "en"), "translations"); snprintf(lang_code, sizeof(lang_code), "%s", lang_cur ? code : "en"); return lang_cur != NULL; } // Testi delle entita' (lang/.json: lingua -> translations -> ID -> campo). // I file restano in memoria interi: cambiare lingua non li ricarica. static cJSON *lang_file(const char *file) { static struct { char file[32]; cJSON *j; } cache[16]; for (int i = 0; i < 16; i++) { if (!cache[i].j) { char rel[64]; snprintf(rel, sizeof(rel), "lang/%s.json", file); snprintf(cache[i].file, sizeof(cache[i].file), "%s", file); return cache[i].j = read_json(rel); } if (!strcmp(cache[i].file, file)) return cache[i].j; } return NULL; } cJSON *lang_table(const char *file) { return lang_file(file); } // per aggiungere testi (personaggi CUSTOM) const char *tr_of(const char *file, const char *id, const char *field) { cJSON *j = lang_file(file); const char *codes[] = { lang_code, "en" }; for (int c = 0; c < 2 && j; c++) { cJSON *t = cJSON_GetObjectItem(cJSON_GetObjectItem(cJSON_GetObjectItem(j, codes[c]), "translations"), id); const char *s = cJSON_GetStringValue(cJSON_GetObjectItem(t, field)); if (s && *s) return s; } return ""; } const char *tr(const char *key) { const char *s = lang_cur ? cJSON_GetStringValue(cJSON_GetObjectItem(lang_cur, key)) : NULL; if (!s && lang_en) s = cJSON_GetStringValue(cJSON_GetObjectItem(lang_en, key)); return s ? s : key; } // Lang.init / setLangCode (Lang): PlayerOptions.Language, se no la lingua del sistema, se no 'en'. // Integration.getLanguage restituisce il nome "api" di Steam (italian, schinese...): qui quello della console. static const char *Integration_getLanguage(void) { #ifdef __vita__ static const char *const api[] = { "japanese", "english", "french", "spanish", "german", "italian", "dutch", "portuguese", "russian", "koreana", "tchinese", "schinese", "finnish", "swedish", "danish", "norwegian", "polish", "brazilian", "english", "turkish" }; // SCE_SYSTEM_PARAM_LANG_* SceAppUtilInitParam ip = { 0 }; SceAppUtilBootParam bp = { 0 }; sceAppUtilInit(&ip, &bp); // gia' fatto da SDL: l'errore si ignora int l = -1; sceAppUtilSystemParamGetInt(SCE_SYSTEM_PARAM_ID_LANG, &l); return l >= 0 && l < (int)(sizeof(api) / sizeof(*api)) ? api[l] : NULL; #else static char code[8]; // LANG=it_IT.UTF-8 -> "it" -> lang.json["it"].api const char *e = getenv("LANG"); if (!e || !lang_all) return NULL; snprintf(code, sizeof(code), "%.*s", (int)strcspn(e, "_."), e); return cJSON_GetStringValue(cJSON_GetObjectItem(cJSON_GetObjectItem(lang_all, code), "api")); #endif } const char *Lang_getLangCode(void) { return lang_code; } const char *Lang_codeAt(int i) { // Lang.langCodeList (langKeys.json), NULL oltre la fine static cJSON *keys; if (!keys) keys = read_json("lang/langKeys.json"); return cJSON_GetStringValue(cJSON_GetArrayItem(keys, i)); } const char *Lang_native(const char *code) { // Lang.langNameList: lang.json[code].native if (!lang_all) lang_all = read_json("lang/lang.json"); const char *n = cJSON_GetStringValue(cJSON_GetObjectItem(cJSON_GetObjectItem(lang_all, code), "native")); return n ? n : code; } void Lang_setLangCode(const char *code) { lang_load(code); const char *cur = cJSON_GetStringValue(cJSON_GetObjectItem(PlayerOptions, "Language")); if (!cur || strcmp(cur, lang_code)) { cJSON_ReplaceItemInObject(PlayerOptions, "Language", cJSON_CreateString(lang_code)); PlayerOptions_Save(); // SaveOptions } } void Lang_init(void) { if (!lang_all) lang_all = read_json("lang/lang.json"); const char *api = Integration_getLanguage(), *sys = NULL; cJSON *keys = read_json("lang/langKeys.json"), *k; cJSON_ArrayForEach(k, keys) { const char *a = cJSON_IsString(k) ? cJSON_GetStringValue(cJSON_GetObjectItem(cJSON_GetObjectItem(lang_all, k->valuestring), "api")) : NULL; if (api && a && !strcmp(api, a)) { sys = k->valuestring; break; } } static char code[8]; const char *po = cJSON_GetStringValue(cJSON_GetObjectItem(PlayerOptions, "Language")); snprintf(code, sizeof(code), "%s", po && *po ? po : sys ? sys : "en"); if (getenv("VS_LANG")) snprintf(code, sizeof(code), "%s", getenv("VS_LANG")); // sviluppo: la lingua di prova (si salva) cJSON_Delete(keys); Lang_setLangCode(code); } // --- Salvataggio -------------------------------------------------------------- // File di testo nella cartella dei dati, scritto prima su un temporaneo: un salvataggio interrotto non cancella quello buono. char *vs_read_text(const char *rel) { return read_text(rel); } void vs_free(void *p) { free(p); } // vs_game.c ridefinisce free (gmem) int vs_write_text(const char *rel, const char *s) { char tmp[600]; snprintf(tmp, sizeof(tmp), "%s.tmp", vs_path(rel)); if (!SaveFileText(tmp, (char *)s)) return 0; #ifdef __vita__ remove(vs_path(rel)); // sceIoRename non sovrascrive #endif return rename(tmp, vs_path(rel)) == 0; } // SHA-256 (FIPS 180-4) in esadecimale minuscolo, come createHash('sha256').digest('hex') void sha256_hex(const char *msg, char out[65]) { static const uint32_t K[64] = { 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 }; uint32_t h[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 }; #define ROR(x, n) ((x) >> (n) | (x) << (32 - (n))) size_t len = strlen(msg), total = ((len + 9 + 63) / 64) * 64; for (size_t off = 0; off < total; off += 64) { uint8_t blk[64]; for (int i = 0; i < 64; i++) { size_t p = off + i; blk[i] = p < len ? (uint8_t)msg[p] : p == len ? 0x80 : 0; } if (off + 64 == total) for (int i = 0; i < 8; i++) blk[63 - i] = (uint8_t)((uint64_t)len * 8 >> (8 * i)); uint32_t w[64], a[8]; for (int i = 0; i < 16; i++) w[i] = (uint32_t)blk[4 * i] << 24 | blk[4 * i + 1] << 16 | blk[4 * i + 2] << 8 | blk[4 * i + 3]; for (int i = 16; i < 64; i++) w[i] = w[i - 16] + (ROR(w[i - 15], 7) ^ ROR(w[i - 15], 18) ^ w[i - 15] >> 3) + w[i - 7] + (ROR(w[i - 2], 17) ^ ROR(w[i - 2], 19) ^ w[i - 2] >> 10); memcpy(a, h, sizeof(a)); for (int i = 0; i < 64; i++) { uint32_t t1 = a[7] + (ROR(a[4], 6) ^ ROR(a[4], 11) ^ ROR(a[4], 25)) + ((a[4] & a[5]) ^ (~a[4] & a[6])) + K[i] + w[i]; uint32_t t2 = (ROR(a[0], 2) ^ ROR(a[0], 13) ^ ROR(a[0], 22)) + ((a[0] & a[1]) ^ (a[0] & a[2]) ^ (a[1] & a[2])); memmove(a + 1, a, 7 * sizeof(*a)); a[4] += t1, a[0] = t1 + t2; } for (int i = 0; i < 8; i++) h[i] += a[i]; } #undef ROR for (int i = 0; i < 8; i++) snprintf(out + 8 * i, 9, "%08x", (unsigned)h[i]); } // --- Input -------------------------------------------------------------------- // Sulla Vita: croce = conferma, cerchio = annulla (layout occidentale, come VS su Switch). int in_confirm(void) { return IsKeyPressed(KEY_ENTER) || IsKeyPressed(KEY_SPACE) || (IsGamepadAvailable(0) && (IsGamepadButtonPressed(0, GAMEPAD_BUTTON_RIGHT_FACE_DOWN) || IsGamepadButtonPressed(0, GAMEPAD_BUTTON_MIDDLE_RIGHT))); } int in_cancel(void) { return IsKeyPressed(KEY_ESCAPE) || IsKeyPressed(KEY_BACKSPACE) || (IsGamepadAvailable(0) && IsGamepadButtonPressed(0, GAMEPAD_BUTTON_RIGHT_FACE_RIGHT)); } int in_dir_pressed(int *dx, int *dy) { *dx = *dy = 0; int pad = IsGamepadAvailable(0); if (IsKeyPressed(KEY_LEFT) || IsKeyPressed(KEY_A) || (pad && IsGamepadButtonPressed(0, GAMEPAD_BUTTON_LEFT_FACE_LEFT))) *dx = -1; if (IsKeyPressed(KEY_RIGHT) || IsKeyPressed(KEY_D) || (pad && IsGamepadButtonPressed(0, GAMEPAD_BUTTON_LEFT_FACE_RIGHT))) *dx = 1; if (IsKeyPressed(KEY_UP) || IsKeyPressed(KEY_W) || (pad && IsGamepadButtonPressed(0, GAMEPAD_BUTTON_LEFT_FACE_UP))) *dy = -1; if (IsKeyPressed(KEY_DOWN) || IsKeyPressed(KEY_S) || (pad && IsGamepadButtonPressed(0, GAMEPAD_BUTTON_LEFT_FACE_DOWN))) *dy = 1; // Levetta: uno scatto quando supera la soglia. static int stick_held; if (pad) { float x = GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_X), y = GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_Y); int held = fabsf(x) > 0.6f || fabsf(y) > 0.6f; if (held && !stick_held) { if (fabsf(x) > fabsf(y)) *dx = x > 0 ? 1 : -1; else *dy = y > 0 ? 1 : -1; } stick_held = held; } return *dx || *dy; } Vector2 in_move(void) { Vector2 m = { 0, 0 }; if (IsGamepadAvailable(0)) { m.x = GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_X); m.y = GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_Y); if (fabsf(m.x) < 0.2f) m.x = 0; if (fabsf(m.y) < 0.2f) m.y = 0; if (IsGamepadButtonDown(0, GAMEPAD_BUTTON_LEFT_FACE_LEFT)) m.x = -1; if (IsGamepadButtonDown(0, GAMEPAD_BUTTON_LEFT_FACE_RIGHT)) m.x = 1; if (IsGamepadButtonDown(0, GAMEPAD_BUTTON_LEFT_FACE_UP)) m.y = -1; if (IsGamepadButtonDown(0, GAMEPAD_BUTTON_LEFT_FACE_DOWN)) m.y = 1; } if (IsKeyDown(KEY_A) || IsKeyDown(KEY_LEFT)) m.x = -1; if (IsKeyDown(KEY_D) || IsKeyDown(KEY_RIGHT)) m.x = 1; if (IsKeyDown(KEY_W) || IsKeyDown(KEY_UP)) m.y = -1; if (IsKeyDown(KEY_S) || IsKeyDown(KEY_DOWN)) m.y = 1; float l = sqrtf(m.x * m.x + m.y * m.y); if (l > 1) m.x /= l, m.y /= l; return m; } // --- Font -------------------------------------------------------------------- // Lang.FONTFAMILY: 'fontKO, fontANY, Courier, serif, sans-serif' per ko/ja/zh-CN, altrimenti 'Courier, fontANY, ...' (qui ANY al // posto di Courier, come nell'HUD). Il browser prende ogni glifo dal primo font che ce l'ha, alla stessa dimensione e sulla linea // di base del primo: qui si fa lo stesso una volta per lingua, con i soli glifi che i testi di quella lingua usano (piu' i nomi // delle lingue, sempre nelle Opzioni). Gli ideogrammi non sono in nessun font del gioco: nel browser arrivano dal sistema, qui // dai font della console (ScePvf) o, sul desktop, da Arial Unicode. // La ricerca dei glifi di raylib e' lineare: con ~3000 glifi (giapponese) costa. Per vs_font c'e' la tabella glyph_idx, // usata dalle copie di DrawTextEx / MeasureTextEx qui sotto (stessi calcoli di raylib 5.5, interlinea 2 come il default). #define FONT_PX 32 static unsigned short *glyph_idx; // codepoint -> indice in vs_font.glyphs, 0xffff = assente static int glyph_q; // l'indice di '?', come il ripiego di GetGlyphIndex static void glyph_index_build(void) { if (!glyph_idx) glyph_idx = malloc(sizeof(*glyph_idx) * 0x10000); memset(glyph_idx, 0xff, sizeof(*glyph_idx) * 0x10000); for (int i = vs_font.glyphCount - 1; i >= 0; i--) // al contrario: a parita' di codepoint vince il primo, come la ricerca lineare if ((unsigned)vs_font.glyphs[i].value < 0x10000) glyph_idx[vs_font.glyphs[i].value] = (unsigned short)i; glyph_q = glyph_idx['?'] != 0xffff ? glyph_idx['?'] : 0; } static int glyph_of(int cp) { return glyph_idx && cp >= 0 && cp < 0x10000 && glyph_idx[cp] != 0xffff ? glyph_idx[cp] : glyph_q; } void vs_DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint) { if (font.glyphs != vs_font.glyphs || !glyph_idx) { DrawTextEx(font, text, position, fontSize, spacing, tint); return; } float sc = fontSize / font.baseSize, ox = 0, oy = 0, pad = (float)font.glyphPadding; for (const char *s = text; *s;) { int n = 0, cp = GetCodepointNext(s, &n), i = glyph_of(cp); s += n > 0 ? n : 1; if (cp == '\n') { oy += fontSize + 2, ox = 0; continue; } if (cp != ' ' && cp != '\t') { // DrawTextCodepoint Rectangle r = font.recs[i]; DrawTexturePro(font.texture, (Rectangle){ r.x - pad, r.y - pad, r.width + 2 * pad, r.height + 2 * pad }, (Rectangle){ position.x + ox + (font.glyphs[i].offsetX - pad) * sc, position.y + oy + (font.glyphs[i].offsetY - pad) * sc, (r.width + 2 * pad) * sc, (r.height + 2 * pad) * sc }, (Vector2){ 0, 0 }, 0, tint); } ox += (font.glyphs[i].advanceX ? font.glyphs[i].advanceX : font.recs[i].width) * sc + spacing; } } Vector2 vs_MeasureTextEx(Font font, const char *text, float fontSize, float spacing) { if (font.glyphs != vs_font.glyphs || !glyph_idx) return MeasureTextEx(font, text, fontSize, spacing); if (!text || !*text || !font.texture.id) return (Vector2){ 0, 0 }; float w = 0, maxW = 0, h = fontSize; int bytes = 0, maxBytes = 0; for (const char *s = text; *s;) { int n = 0, cp = GetCodepointNext(s, &n), i = glyph_of(cp); s += n > 0 ? n : 1; bytes++; if (cp != '\n') w += font.glyphs[i].advanceX > 0 ? font.glyphs[i].advanceX : font.recs[i].width + font.glyphs[i].offsetX; else { if (maxW < w) maxW = w; bytes = 0, w = 0, h += fontSize + 2; } if (maxBytes < bytes) maxBytes = bytes; } if (maxW < w) maxW = w; return (Vector2){ maxW * fontSize / font.baseSize + (maxBytes - 1) * spacing, h }; } typedef struct { unsigned char *d; int n, base; unsigned char *has; } TTF; static unsigned rd16(const unsigned char *p) { return (unsigned)p[0] << 8 | p[1]; } static unsigned rd32(const unsigned char *p) { return (unsigned)p[0] << 24 | (unsigned)p[1] << 16 | (unsigned)p[2] << 8 | p[3]; } static const unsigned char *ttf_table(const TTF *t, const char *tag) { for (unsigned i = 0, nt = rd16(t->d + 4); i < nt; i++) { const unsigned char *r = t->d + 12 + 16 * i; if (!memcmp(r, tag, 4)) return rd32(r + 8) < (unsigned)t->n ? t->d + rd32(r + 8) : NULL; } return NULL; } static void cp_set(unsigned char *b, unsigned c) { if (c < 0x10000) b[c >> 3] |= 1 << (c & 7); } static int cp_has(const unsigned char *b, unsigned c) { return c < 0x10000 && (b[c >> 3] >> (c & 7) & 1); } static int ttf_open(TTF *t, const char *path) { // cmap (formati 4 e 12) e linea di base come stbtt: ascent * px / (ascent - descent) memset(t, 0, sizeof(*t)); t->d = FileExists(path) ? LoadFileData(path, &t->n) : NULL; const unsigned char *c = t->d ? ttf_table(t, "cmap") : NULL, *h = t->d ? ttf_table(t, "hhea") : NULL; if (!c || !h) { if (t->d) UnloadFileData(t->d); t->d = NULL; return 0; } t->has = calloc(0x2000, 1); for (unsigned i = 0, ns = rd16(c + 2); i < ns; i++) { const unsigned char *s = c + rd32(c + 8 + 8 * i); unsigned fmt = rd16(s); if (fmt == 4) { unsigned seg = rd16(s + 6) / 2; for (unsigned k = 0; k < seg; k++) for (unsigned cp = rd16(s + 16 + 2 * seg + 2 * k), e = rd16(s + 14 + 2 * k); cp <= e && cp < 0xffff; cp++) cp_set(t->has, cp); } else if (fmt == 12) { for (unsigned g = 0, ng = rd32(s + 12); g < ng; g++) for (unsigned cp = rd32(s + 16 + 12 * g), e = rd32(s + 20 + 12 * g); cp <= e && cp < 0x10000; cp++) cp_set(t->has, cp); } } int asc = (short)rd16(h + 4), desc = (short)rd16(h + 6); t->base = asc - desc > 0 ? (int)((float)asc * FONT_PX / (asc - desc)) : FONT_PX; return 1; } static void cps_walk(cJSON *j, unsigned char *want) { for (; j; j = j->next) { if (cJSON_IsString(j)) for (const char *s = j->valuestring; *s;) { int n = 1, cp = GetCodepointNext(s, &n); cp_set(want, (unsigned)cp); s += n > 0 ? n : 1; } if (j->child) cps_walk(j->child, want); } } static GlyphInfo *glyphs_of(const TTF *t, int *cps, int n) { #if RAYLIB_VERSION_MAJOR >= 6 int got = 0; return LoadFontData(t->d, t->n, FONT_PX, cps, n, FONT_DEFAULT, &got); #else return LoadFontData(t->d, t->n, FONT_PX, cps, n, FONT_DEFAULT); #endif } #ifdef __vita__ #include static void *pvf_alloc(void *u, unsigned sz) { (void)u; return malloc(sz); } static void *pvf_realloc(void *u, void *p, unsigned sz) { (void)u; return realloc(p, sz); } static void pvf_free(void *u, void *p) { (void)u; free(p); } static ScePvfFontId pvf_font(int lang) { // il font della console per la lingua (giapponese, coreano o cinese), tarato sull'altezza di 日 static ScePvfLibId lib; static ScePvfFontId open[6]; ScePvfError e = 0; if (!lib) { ScePvfInitRec r = { NULL, 4, NULL, NULL, pvf_alloc, pvf_realloc, pvf_free }; if (!(lib = scePvfNewLib(&r, &e))) return NULL; scePvfSetEM(lib, 72.0f / (10.125f * 128.0f)); scePvfSetResolution(lib, 128.0f, 128.0f); } if (open[lang]) return open[lang]; ScePvfFontStyleInfo st; memset(&st, 0, sizeof(st)); st.languageCode = lang, st.familyCode = SCE_PVF_FAMILY_SANSERIF, st.style = SCE_PVF_STYLE_REGULAR; ScePvfFontIndex i = scePvfFindOptimumFont(lib, &st, &e); ScePvfFontId f = e >= 0 && i >= 0 ? scePvfOpen(lib, i, 1, &e) : NULL; if (!f) f = scePvfOpenDefaultJapaneseFontOnSharedMemory(lib, &e); if (!f) return NULL; // ScePvfCharInfo.bitmap* resta a 0 su questa libreria: misure e posizioni dalle glyphMetrics (26.6) ScePvfCharInfo ci; scePvfSetCharSize(f, FONT_PX, FONT_PX); if (scePvfGetCharInfo(f, 0x65e5, &ci) >= 0 && ci.glyphMetrics.height64 > 0) { // 日 alto ~0.8 em, come nel browser a 32 px float k = FONT_PX * 0.8f * FONT_PX / (ci.glyphMetrics.height64 / 64.0f); scePvfSetCharSize(f, k, k); } return open[lang] = f; } static int pvf_glyph(ScePvfFontId f, int cp, int base, GlyphInfo *g) { ScePvfCharInfo ci; if (!scePvfIsElement(f, (ScePvfCharCode)cp) || scePvfGetCharInfo(f, (ScePvfCharCode)cp, &ci) < 0) return 0; const ScePvfIGlyphMetricsInfo *m = &ci.glyphMetrics; int left = (int)floorf(m->horizontalBearingX64 / 64.0f), top = (int)ceilf(m->horizontalBearingY64 / 64.0f); int w = (int)ceilf((m->horizontalBearingX64 - left * 64 + (int)m->width64) / 64.0f) + 4, h = (int)ceilf((top * 64 - m->horizontalBearingY64 + (int)m->height64) / 64.0f) + 4; unsigned char *px = RL_CALLOC((size_t)w * h, 1); // la penna (origine sulla linea di base) a (2 - left, 2 + top): il glifo comincia a 2 px dal bordo ScePvfUserImageBufferRec b = { SCE_PVF_USERIMAGE_DIRECT8, (2 - left) * 64, (2 + top) * 64, { (ScePvfU16)w, (ScePvfU16)h }, (ScePvfU16)w, 0, px }; scePvfGetCharGlyphImage(f, (ScePvfCharCode)cp, &b); *g = (GlyphInfo){ cp, left - 2, base - top - 2, (int)lroundf(m->horizontalAdvance64 / 64.0f), { px, w, h, 1, PIXELFORMAT_UNCOMPRESSED_GRAYSCALE } }; return 1; } #endif // Cache del font finito (atlante + glifi) per lingua: costruirlo costa secondi con le lingue CJK (3238 glifi PVF per il cinese). // Chiave: i caratteri richiesti, la lingua, FONT_PX e la versione del formato; se cambia qualcosa il file si rigenera. #define FONT_CACHE_VER 2 // 2: atlante con gli zeri compressi (byte 0 + quanti, fino a 255) typedef struct { unsigned magic, key; int count, w, h, packed; } FontCacheHead; static unsigned fnv1a(const void *p, size_t n, unsigned h) { for (size_t i = 0; i < n; i++) h = (h ^ ((const unsigned char *)p)[i]) * 16777619u; return h; } static double fc_t[4]; // misura: lettura, conversione, texture static int font_cache_load(const char *path, unsigned key, Font *f) { fc_t[0] = GetTime(); FILE *fp = fopen(path, "rb"); if (!fp) return 0; setvbuf(fp, NULL, _IOFBF, 1 << 20); // letture grosse: con il buffer piccolo di newlib la memory card dava ~3 MB/s FontCacheHead hd; int ok = fread(&hd, sizeof(hd), 1, fp) == 1 && hd.magic == 0x46435653 && hd.key == key && hd.count > 0 && hd.w > 0 && hd.h > 0; GlyphInfo *g = ok ? RL_CALLOC((size_t)hd.count, sizeof(GlyphInfo)) : NULL; Rectangle *r = ok ? RL_CALLOC((size_t)hd.count, sizeof(Rectangle)) : NULL; unsigned char *a = ok ? malloc((size_t)hd.w * hd.h) : NULL; for (int i = 0; ok && i < hd.count; i++) { int m[4]; ok = fread(m, sizeof(m), 1, fp) == 1 && fread(&r[i], sizeof(Rectangle), 1, fp) == 1; g[i] = (GlyphInfo){ m[0], m[1], m[2], m[3], { 0 } }; } unsigned char *pk = ok ? malloc((size_t)hd.packed) : NULL; ok = ok && hd.packed > 0 && fread(pk, 1, (size_t)hd.packed, fp) == (size_t)hd.packed; fclose(fp); size_t o = 0, n = (size_t)hd.w * hd.h; for (int i = 0; ok && i < hd.packed; i++) { // gli zeri compressi if (pk[i]) { ok = o < n; if (ok) a[o++] = pk[i]; continue; } int run = i + 1 < hd.packed ? pk[++i] : 0; ok = o + run <= n; if (ok) memset(a + o, 0, run), o += run; } ok = ok && o == n; free(pk); fc_t[1] = GetTime(); if (!ok) { RL_FREE(g), RL_FREE(r), free(a); return 0; } unsigned char *ga = RL_MALLOC((size_t)hd.w * hd.h * 2); // GRAY_ALPHA come GenImageFontAtlas: bianco con l'alpha del glifo for (int i = 0; i < hd.w * hd.h; i++) ga[2 * i] = 255, ga[2 * i + 1] = a[i]; free(a); fc_t[2] = GetTime(); Image im = { ga, hd.w, hd.h, 1, PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA }; *f = (Font){ FONT_PX, hd.count, 2, LoadTextureFromImage(im), r, g }; UnloadImage(im); fc_t[3] = GetTime(); return f->texture.id != 0; } static void font_cache_save(const char *path, unsigned key, const Font *f, const Image *atlas) { if (atlas->format != PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) return; FILE *fp = fopen(path, "wb"); if (!fp) return; size_t n = (size_t)atlas->width * atlas->height, k = 0; const unsigned char *ga = atlas->data; unsigned char *pk = malloc(n * 2 + 2); for (size_t i = 0; i < n;) { unsigned char v = ga[2 * i + 1]; if (v) { pk[k++] = v, i++; continue; } int run = 0; while (i < n && run < 255 && !ga[2 * i + 1]) run++, i++; pk[k++] = 0, pk[k++] = (unsigned char)run; } FontCacheHead hd = { 0x46435653, key, f->glyphCount, atlas->width, atlas->height, (int)k }; fwrite(&hd, sizeof(hd), 1, fp); for (int i = 0; i < f->glyphCount; i++) { int m[4] = { f->glyphs[i].value, f->glyphs[i].offsetX, f->glyphs[i].offsetY, f->glyphs[i].advanceX }; fwrite(m, sizeof(m), 1, fp), fwrite(&f->recs[i], sizeof(Rectangle), 1, fp); } fwrite(pk, 1, k, fp); free(pk); fclose(fp); } static void font_log(double t0, int cached) { // /font.txt: lingua, glifi, millisecondi, cache FILE *fp = fopen(vs_path("font.txt"), "a"); if (!fp) return; fprintf(fp, "%s %d glifi %.0f ms", lang_code, vs_font.glyphCount, 1000 * (GetTime() - t0)); if (cached) fprintf(fp, " (cache: lettura %.0f, conversione %.0f, texture %.0f)", 1000 * (fc_t[1] - fc_t[0]), 1000 * (fc_t[2] - fc_t[1]), 1000 * (fc_t[3] - fc_t[2])); fputc('\n', fp), fclose(fp); } static void font_use(Font f) { SetTextureFilter(f.texture, TEXTURE_FILTER_BILINEAR); if (vs_font.texture.id && vs_font.texture.id != GetFontDefault().texture.id) UnloadFont(vs_font); vs_font = f; glyph_index_build(); } void vs_load_font(void) { double t0 = GetTime(); static const char *const FILES[] = { "achievementLang", "arcanaLang", "characterLang", "enemiesLang", "itemLang", "powerUpLang", "secretLang", "stageLang", "weaponLang" }; unsigned char *want = calloc(0x2000, 1), *taken = calloc(0x2000, 1); for (unsigned c = 32; c < 0x250; c++) cp_set(want, c); for (unsigned c = 0x400; c < 0x460; c++) cp_set(want, c); if (!lang_all) lang_all = read_json("lang/lang.json"); cJSON *cur = cJSON_GetObjectItem(lang_all, lang_code); if (cur) cps_walk(cur->child, want); for (size_t i = 0; i < sizeof(FILES) / sizeof(*FILES); i++) { cJSON *l = cJSON_GetObjectItem(lang_file(FILES[i]), lang_code); if (l) cps_walk(l->child, want); } for (int i = 0; Lang_codeAt(i); i++) cps_walk(cJSON_GetObjectItem(cJSON_GetObjectItem(lang_all, Lang_codeAt(i)), "native"), want); static cJSON *credits; // data/credits.json: i nomi dei traduttori (hangul, kanji, cuori) in qualunque lingua if (!credits) credits = read_json("data/credits.json"); if (credits) cps_walk(credits->child, want); char cpath[600]; snprintf(cpath, sizeof(cpath), "%s", vs_path(TextFormat("font_%s.cache", lang_code))); #ifdef __vita__ const unsigned plat = 0x56495441; // i glifi CJK vengono dai font della console: mai la cache fatta sul desktop #else const unsigned plat = 0; #endif unsigned key = fnv1a(want, 0x2000, fnv1a(lang_code, strlen(lang_code), 2166136261u)) ^ (FONT_PX * 31 + FONT_CACHE_VER) ^ plat; Font cached; if (font_cache_load(cpath, key, &cached)) { font_use(cached); free(want), free(taken); font_log(t0, 1); return; } int cjk = !strcmp(lang_code, "ja") ? 1 : !strcmp(lang_code, "ko") ? 3 : !strcmp(lang_code, "zh-CN") ? 4 : 0; // SCE_PVF_LANGUAGE_J/K/C static TTF any, ko, sys; // aperti una volta: rileggerli a ogni cambio di lingua costava (2 MB dalla memory card) static int opened; if (!opened) { opened = 1; ttf_open(&any, vs_path("fonts/ANY.ttf")); ttf_open(&ko, vs_path("fonts/KO.ttf")); #ifndef __vita__ ttf_open(&sys, "/System/Library/Fonts/Supplemental/Arial Unicode.ttf"); #endif } TTF *order[3] = { cjk ? &ko : &any, cjk ? &any : &ko, &sys }; int base = order[0]->d ? order[0]->base : order[1]->d ? order[1]->base : FONT_PX * 3 / 4; int cap = 0, total = 0, *list = malloc(sizeof(int) * 0x10000); for (unsigned c = 0; c < 0x10000; c++) cap += cp_has(want, c); GlyphInfo *all = RL_CALLOC((size_t)cap + 1, sizeof(GlyphInfo)); for (int s = 0; s < 3; s++) { TTF *t = order[s]; if (!t->d) continue; int n = 0; for (unsigned c = 32; c < 0x10000; c++) if (cp_has(want, c) && !cp_has(taken, c) && cp_has(t->has, c)) list[n++] = (int)c, cp_set(taken, c); GlyphInfo *g = n ? glyphs_of(t, list, n) : NULL; for (int i = 0; g && i < n; i++) g[i].offsetY += base - t->base, all[total++] = g[i]; if (g) RL_FREE(g); // le immagini passano ad all } #ifdef __vita__ ScePvfFontId pf = NULL; for (unsigned c = 0x2e80; c < 0x10000; c++) { // il resto (ideogrammi e punteggiatura CJK) dal font della console if (!cp_has(want, c) || cp_has(taken, c)) continue; if (!pf && !(pf = pvf_font(cjk ? cjk : 1))) break; if (pvf_glyph(pf, (int)c, base, &all[total])) { total++; continue; } static const int other[3] = { 4, 1, 3 }; // manca nel font della lingua (简 nel giapponese): gli altri font della console for (int k = 0; k < 3; k++) { ScePvfFontId of = other[k] != (cjk ? cjk : 1) ? pvf_font(other[k]) : NULL; if (of && of != pf && pvf_glyph(of, (int)c, base, &all[total])) { total++; break; } } } #endif Font f = { 0 }; f.baseSize = FONT_PX, f.glyphCount = total, f.glyphPadding = 2, f.glyphs = all; Image atlas = GenImageFontAtlas(all, &f.recs, total, FONT_PX, 2, 1); f.texture = LoadTextureFromImage(atlas); if (f.texture.id) font_cache_save(cpath, key, &f, &atlas); UnloadImage(atlas); if (f.texture.id) font_use(f); else if (!vs_font.texture.id) vs_font = GetFontDefault(); font_log(t0, 0); free(list), free(want), free(taken); } // --- Video --------------------------------------------------------------------- struct VsVideo { Texture2D tex; int done; #ifdef __vita__ SceAvPlayerHandle player; int slot, started, ready; float waited; #else FILE *pipe; char path[600]; int ready, loop; unsigned char *buf; float t; int frame; #endif }; #ifdef __vita__ // Fotogrammi NV12 (allineamento 256 KiB, come il lettore di VitaShell); la texture GXM in formato // YVU420P2_CSC1 li converte in RGB da sola. Le texture GL restano vive (pool di 4): i loro dati li ha liberati vglFree. static void av_log(const char *fmt, ...) { // diagnosi: /video.log FILE *f = fopen(vs_path("video.log"), "a"); if (!f) return; va_list ap; va_start(ap, fmt), vfprintf(f, fmt, ap), va_end(ap); fputc('\n', f), fclose(f); } static void *av_alloc(void *p, uint32_t align, uint32_t size) { (void)p; void *r = memalign(align, size); if (!r) av_log("alloc %u align %u FALLITA", size, align); return r; } static void av_free(void *p, void *ptr) { (void)p; free(ptr); } // Fotogrammi e buffer del decoder: memoria vista dal decodificatore hardware, cioe' VRAM o RAM fisicamente contigua dai pool di // vitaGL (gia' mappati sulla GPU), allineata a mano. av_blocks ricorda il puntatore vero per vglFree. // Il decoder pero' vuole la BASE di un memblock tutto suo, allineato dal kernel (provato sulla Vita con avtest: un // pezzo di un blocco piu' grande -> solo l'evento STOP). Quindi prima un memblock CDRAM, poi fisicamente contiguo: c'e' // memoria libera solo se avres.req l'ha tenuta fuori da vitaGL (main.c). uid >= 0: blocco del kernel. // I memblock non si liberano mai, si riusano (used = 0): vitaGL manda i disegni alla GPU a fine scena, e smappare // i fotogrammi di un video chiuso a meta' fotogramma faceva GPUCRASH sulla Vita. I tre video hanno buffer uguali. static struct { void *real, *aligned; SceUID uid; uint32_t len; int used; } av_blocks[32]; static void *av_gpu_alloc(void *p, uint32_t align, uint32_t size) { (void)p; if (align < 0x40000) align = 0x40000; for (int k = 0; k < 32; k++) if (av_blocks[k].real && av_blocks[k].uid >= 0 && !av_blocks[k].used && av_blocks[k].len >= size && !((uintptr_t)av_blocks[k].real & (align - 1))) { av_blocks[k].used = 1; return av_blocks[k].real; } static const SceKernelMemBlockType K[2] = { SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_NC_RW }; for (int t = 0; t < 2; t++) { uint32_t a = t && align < 0x100000 ? 0x100000 : align, len = (size + a - 1) & ~(a - 1); SceKernelAllocMemBlockOpt opt; memset(&opt, 0, sizeof(opt)); opt.size = sizeof(opt), opt.attr = 4, opt.alignment = a; // 4: alignment valido SceUID uid = sceKernelAllocMemBlock("avplayer", K[t], len, &opt); if (uid < 0) continue; void *base; sceKernelGetMemBlockBase(uid, &base); if (sceGxmMapMemory(base, len, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE) < 0) { sceKernelFreeMemBlock(uid); continue; } for (int k = 0; k < 32; k++) if (!av_blocks[k].real) { av_blocks[k].real = av_blocks[k].aligned = base, av_blocks[k].uid = uid, av_blocks[k].len = len, av_blocks[k].used = 1; break; } av_log("gpu_alloc %u align %u -> %p memblock %d", size, align, base, t); return base; } static const vglMemType T[3] = { VGL_MEM_VRAM, VGL_MEM_SLOW, VGL_MEM_BUDGET }; for (int t = 0; t < 3; t++) { if (vglMemFree(T[t]) < size + align) continue; void *real = vglAlloc(size + align, T[t]); if (!real) continue; void *al = (void *)(((uintptr_t)real + align - 1) & ~(uintptr_t)(align - 1)); for (int k = 0; k < 32; k++) if (!av_blocks[k].real) { av_blocks[k].real = real, av_blocks[k].aligned = al, av_blocks[k].uid = -1; break; } av_log("gpu_alloc %u align %u -> %p tipo %d", size, align, al, t); return al; } av_log("gpu_alloc %u FALLITA (vram %u slow %u budget %u)", size, (unsigned)vglMemFree(VGL_MEM_VRAM), (unsigned)vglMemFree(VGL_MEM_SLOW), (unsigned)vglMemFree(VGL_MEM_BUDGET)); return NULL; } static void av_gpu_free(void *p, void *ptr) { (void)p; for (int k = 0; k < 32; k++) if (av_blocks[k].aligned == ptr && av_blocks[k].real) { if (av_blocks[k].uid >= 0) av_blocks[k].used = 0; else vglLazyFree(av_blocks[k].real), av_blocks[k].real = NULL; // liberato quando la GPU ha finito di usarlo return; } } static struct { GLuint id; SceGxmTexture *gxm; int used; } av_slots[4]; static void av_event(void *p, int32_t id, int32_t src, void *data) { (void)p, (void)data; av_log("evento %d sorgente %d", id, src); } VsVideo *vs_video_open(const char *rel, int w, int h) { static int loaded; if (!loaded) { int r = sceSysmoduleLoadModule(SCE_SYSMODULE_AVPLAYER); loaded = r >= 0 ? 1 : -1; av_log("sysmodule %08x", r); } int s = 0; while (s < 4 && av_slots[s].used) s++; if (loaded < 0 || s == 4) return NULL; if (!av_slots[s].id) { glGenTextures(1, &av_slots[s].id); glBindTexture(GL_TEXTURE_2D, av_slots[s].id); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); av_slots[s].gxm = vglGetGxmTexture(GL_TEXTURE_2D); vglFree(vglGetTexDataPointer(GL_TEXTURE_2D)); } SceAvPlayerInitData d; memset(&d, 0, sizeof(d)); d.memoryReplacement.allocate = av_alloc, d.memoryReplacement.deallocate = av_free; d.memoryReplacement.allocateTexture = av_gpu_alloc, d.memoryReplacement.deallocateTexture = av_gpu_free; d.eventReplacement.eventCallback = av_event; d.basePriority = 0xa0, d.numOutputVideoFrameBuffers = 2, d.autoStart = 1; SceAvPlayerHandle pl = sceAvPlayerInit(&d); av_log("init %s slot %d -> %08x gxm %p", rel, s, pl, (void *)av_slots[s].gxm); if (!pl || ((unsigned)pl & 0xffff0000u) == 0x806a0000u) return NULL; // l'handle e' un indirizzo (sopra 0x80000000): errore solo 0x806Axxxx int as = sceAvPlayerAddSource(pl, strchr(rel, ':') ? rel : vs_path(rel)); av_log("addsource %08x", as); if (as < 0) { sceAvPlayerClose(pl); return NULL; } VsVideo *v = calloc(1, sizeof(VsVideo)); v->player = pl, v->slot = s, av_slots[s].used = 1; v->tex = (Texture2D){ av_slots[s].id, w, h, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 }; return v; } int vs_video_update(VsVideo *v, float ms) { if (!v || v->done) return 0; if (!sceAvPlayerIsActive(v->player)) { // parte in modo asincrono: finito solo dopo essere partito, o se non parte in 3 s v->waited += ms; if (v->started || v->waited > 3000) { av_log("fine (partito %d, attesa %.0f ms)", v->started, v->waited); return !(v->done = 1); } return 1; } v->started = 1; SceAvPlayerFrameInfo f; if (sceAvPlayerGetVideoData(v->player, &f)) { static int nf; if (nf++ % 60 == 0) av_log("frame %d data %p %ux%u ts %llu", nf, (void *)f.pData, f.details.video.width, f.details.video.height, (unsigned long long)f.timeStamp); SceGxmTexture *t = av_slots[v->slot].gxm; v->ready = 1; sceGxmTextureInitLinear(t, f.pData, SCE_GXM_TEXTURE_FORMAT_YVU420P2_CSC1, f.details.video.width, f.details.video.height, 0); sceGxmTextureSetMinFilter(t, SCE_GXM_TEXTURE_FILTER_LINEAR), sceGxmTextureSetMagFilter(t, SCE_GXM_TEXTURE_FILTER_LINEAR); } return 1; } void vs_video_loop(VsVideo *v) { if (v) sceAvPlayerSetLooping(v->player, SCE_TRUE); } int vs_video_ready(const VsVideo *v) { return v && v->ready; } void vs_video_close(VsVideo *v) { if (!v) return; sceAvPlayerStop(v->player); sceAvPlayerClose(v->player); av_slots[v->slot].used = 0; free(v); } #else VsVideo *vs_video_open(const char *rel, int w, int h) { // semplificazione: anteprima sul Mac, serve ffmpeg nel PATH char cmd[700]; const char *path = rel[0] == '/' ? rel : vs_path(rel); snprintf(cmd, sizeof(cmd), "ffmpeg -v quiet -i '%s' -f rawvideo -pix_fmt rgba -", path); FILE *p = popen(cmd, "r"); if (!p) return NULL; VsVideo *v = calloc(1, sizeof(VsVideo)); snprintf(v->path, sizeof(v->path), "%s", path); v->pipe = p, v->buf = calloc((size_t)w * h, 4); Image im = { v->buf, w, h, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 }; v->tex = LoadTextureFromImage(im); SetTextureFilter(v->tex, TEXTURE_FILTER_BILINEAR); return v; } int vs_video_update(VsVideo *v, float ms) { // i fotogrammi a 30 fps sul tempo trascorso if (!v || v->done) return 0; v->t += ms; size_t n = (size_t)v->tex.width * v->tex.height * 4; int want = (int)(v->t * 30 / 1000), got = 0; while (v->frame < want) { if (fread(v->buf, 1, n, v->pipe) != n) { if (!v->loop) return !(v->done = 1); char cmd[700]; snprintf(cmd, sizeof(cmd), "ffmpeg -v quiet -i '%s' -f rawvideo -pix_fmt rgba -", v->path); pclose(v->pipe); if (!(v->pipe = popen(cmd, "r")) || fread(v->buf, 1, n, v->pipe) != n) return !(v->done = 1); } v->frame++, got = 1; } if (got) UpdateTexture(v->tex, v->buf), v->ready = 1; return 1; } void vs_video_loop(VsVideo *v) { if (v) v->loop = 1; } int vs_video_ready(const VsVideo *v) { return v && v->ready; } void vs_video_close(VsVideo *v) { if (!v) return; pclose(v->pipe); UnloadTexture(v->tex); free(v->buf), free(v); } #endif Texture2D vs_video_texture(const VsVideo *v) { return v ? v->tex : (Texture2D){ 0 }; }