// test/oracle/pairs_render.cpp — enregistrement des routines du pipeline de // rendu comme REFERENCES FIGEES. // // Aucune version assembleur n existe encore (chantier 5 : « Pas de version // assembleur du rasterizer dans cette passe »). C est precisement pour cela // que ces paires sont enregistrees maintenant, avec opt = nullptr : // // - le harnais execute la reference sur tous les cas, ce qui verifie qu elle // ne plante pas, ne deborde pas son tampon, et n alloue rien (le garde-fou // du chantier 3 est lie a cet executable) ; // - le jour ou la version NEON arrive, il n y a qu un pointeur a remplir. // Personne n a a se demander comment brancher le test : il est deja la. // // Enregistrer une routine AVANT d avoir son assembleur est la seule facon // d etre sur que le harnais sera utilise. Construit apres coup, il ne l est // jamais. #include "oracle.hpp" #include "proj3/render/compose.hpp" #include "proj3/render/rasterizer.hpp" namespace proj3::oracle { namespace { // --- Glyphe synthetique ---------------------------------------------------- // Le harnais ne doit dependre d aucun fichier : il doit tourner sur la machine // de dev, sur un Raspberry Pi, dans un conteneur, sans police installee. On // fabrique donc un glyphe a partir des octets d entree. // // Forme : un rectangle exterieur (sens horaire) et un rectangle interieur // (sens anti-horaire), plus un arc quadratique. C est le minimum qui exerce // vraiment le nonzero winding : si la regle etait mal portee, le rectangle // interieur ne serait pas creuse et la difference sauterait aux yeux. constexpr u32 kSynthPointCount = 12; constexpr u32 kSynthContourCount = 2; struct SynthGlyph { font::GlyphPoint points[kSynthPointCount]; u32 contour_end[kSynthContourCount]; font::Glyph glyph; }; void build_synth(SynthGlyph& g, const u8* in, usize in_len) { // Deux octets d entree pilotent la geometrie. Bornes pour rester dans des // valeurs de police plausibles et pour que le glyphe ne soit jamais vide. const f32 w = 200.0f + static_cast(in_len > 0 ? in[0] : 0u) * 2.0f; const f32 h = 300.0f + static_cast(in_len > 1 ? in[1] : 0u) * 2.0f; const f32 inset = 40.0f + static_cast(in_len > 2 ? (in[2] & 0x3Fu) : 0u); auto P = [](f32 x, f32 y, bool on) { font::GlyphPoint p; p.x = x; p.y = y; p.on_curve = on; return p; }; // Contour exterieur : rectangle avec un cote superieur bombe (un point de // controle off-curve), 6 points. g.points[0] = P(0.0f, 0.0f, true); g.points[1] = P(w, 0.0f, true); g.points[2] = P(w, h, true); g.points[3] = P(w * 0.5f, h + 80.0f, false); // controle quadratique g.points[4] = P(0.0f, h, true); g.points[5] = P(0.0f, h * 0.5f, true); g.contour_end[0] = 6; // Contour interieur, oriente en sens inverse : c est lui que le nonzero // doit creuser. 6 points aussi, pour garder un tableau simple. const f32 x0 = inset, x1 = w - inset; const f32 y0 = inset, y1 = h - inset; g.points[6] = P(x0, y0, true); g.points[7] = P(x0, y1, true); g.points[8] = P((x0 + x1) * 0.5f, y1 + 20.0f, false); g.points[9] = P(x1, y1, true); g.points[10] = P(x1, y0, true); g.points[11] = P((x0 + x1) * 0.5f, y0 - 20.0f, false); g.contour_end[1] = 12; g.glyph = font::Glyph{}; g.glyph.points = g.points; g.glyph.contour_end = g.contour_end; g.glyph.point_count = kSynthPointCount; g.glyph.contour_count = kSynthContourCount; g.glyph.advance_width = w + 100.0f; } // --- Paire 1 : rasterization ---------------------------------------------- usize rasterize_ref(const u8* in, usize in_len, u8* out, usize out_cap) { if (g_system == nullptr) return 0; SynthGlyph g; build_synth(g, in, in_len); // Taille en pixels pilotee par l entree, bornee a des corps realistes. const f32 px = 8.0f + static_cast(in_len > 3 ? (in[3] & 0x3Fu) : 16u); mem::Arena& scratch = g_system->geometry; mem::Arena& store = g_system->atlas; const usize m_scratch = scratch.mark(); const usize m_store = store.mark(); render::RasterizedGlyph rg; const bool ok = render::rasterize_glyph(g.glyph, 1000, px, store, scratch, rg); usize written = 0; if (ok) { // On publie la couverture brute, plus les trois metriques en tete : // une divergence de bearing ou d avance doit etre detectee au meme // titre qu une divergence de pixel. const i32 meta[3] = {rg.bearing_x, rg.bearing_y, rg.advance}; const u8* meta_bytes = reinterpret_cast(meta); for (usize i = 0; i < sizeof(meta) && written < out_cap; ++i) { out[written++] = meta_bytes[i]; } const usize n = rg.coverage.size_bytes(); for (usize i = 0; i < n && written < out_cap; ++i) { out[written++] = rg.coverage.pixels[i]; } } store.rewind_to(m_store); scratch.rewind_to(m_scratch); return written; } // Les tailles sont choisies pour que la couverture depasse largement out_cap // dans les petits cas (on ne compare alors que le prefixe) et la remplisse // dans les grands. const CaseSpec kRasterCases[] = { {"entree vide", 0, 0, 0, 0}, {"4 octets", 4, 0, 0, 0}, {"64 octets", 64, 0, 0, 0}, {"4 Ko", 4096, 0, 0, 0}, {"4 Ko desaligne +1/+3", 4096, 0, 1, 3}, {"aleatoire 4 Ko", 4096, 0xA5A5'5A5A'0F0F'F0F0ull, 0, 0}, {"aleatoire 16 Ko", 16384, 0x0123'4567'89AB'CDEFull, 0, 0}, }; PROJ3_ORACLE_PAIR(raster_glyph, "render::rasterize_glyph (glyphe synthetique)", &rasterize_ref, nullptr, kRasterCases); // --- Paire 2 : composition ------------------------------------------------- // Separee de la rasterization, comme le code l est : c est cette routine-la // qui deviendra un noyau NEON en premier. usize compose_ref(const u8* in, usize in_len, u8* out, usize out_cap) { if (g_system == nullptr || out_cap < 16) return 0; // Framebuffer minuscule ecrit directement dans `out` : on compare donc // exactement les octets que la routine produit, sans recopie. const i32 fw = 32; const i32 fh = static_cast(out_cap / (4u * 32u)); if (fh <= 0) return 0; render::Framebuffer fb; fb.pixels = reinterpret_cast(out); fb.width = fw; fb.height = fh; // out est aligne par le harnais selon out_align_offset ; compose_coverage // exige 4 octets. On refuse proprement si l alignement ne convient pas, // plutot que de paniquer : ce cas fait partie de ce qu on veut tester. if ((reinterpret_cast(out) & 3u) != 0) return 0; render::framebuffer_clear(fb, 0xFF000000u); mem::Arena& store = g_system->atlas; const usize m = store.mark(); render::Coverage8 cov = render::coverage_alloc(store, 16, 16); for (usize i = 0; i < cov.size_bytes(); ++i) { cov.pixels[i] = (i < in_len && (in[i] & 1u) != 0) ? 255 : 0; } // Trois positions : entierement dedans, a cheval sur le bord droit, a // cheval sur le coin haut-gauche (coordonnees negatives). render::compose_coverage(fb, 2, 2, cov, 0xFFFFFFFFu); render::compose_coverage(fb, fw - 8, 4, cov, 0xFF00FF00u); render::compose_coverage(fb, -6, -6, cov, 0xFFFF0000u); store.rewind_to(m); return static_cast(fw) * static_cast(fh) * 4u; } const CaseSpec kComposeCases[] = { {"1 ligne", 128, 0, 0, 0}, {"8 lignes", 1024, 0, 0, 0}, {"32 lignes", 4096, 0, 0, 0}, {"32 lignes aleatoire", 4096, 0xFEED'FACE'DEAD'C0DEull, 0, 0}, }; PROJ3_ORACLE_PAIR(compose_cov, "render::compose_coverage", &compose_ref, nullptr, kComposeCases); } // namespace } // namespace proj3::oracle