runtime.c
48914 bytes · Original / download
#include <dirent.h>
#include <stdarg.h>
#include <sys/stat.h>
#include <unistd.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#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 <malloc.h>
#include <psp2/apputil.h>
#include <psp2/avplayer.h>
#include <psp2/gxm.h>
#include <psp2/io/stat.h>
#include <psp2/kernel/sysmem.h>
#include <psp2/sysmodule.h>
#include <psp2/system_param.h>
#include <vitaGL.h>
#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/<file>.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 <psp2/pvf.h>
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) { // <dati>/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: <dati>/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 }; }