198 lignes
7.7 KiB
C++
198 lignes
7.7 KiB
C++
// 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<f32>(in_len > 0 ? in[0] : 0u) * 2.0f;
|
|
const f32 h = 300.0f + static_cast<f32>(in_len > 1 ? in[1] : 0u) * 2.0f;
|
|
const f32 inset = 40.0f + static_cast<f32>(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<f32>(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<const u8*>(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<i32>(out_cap / (4u * 32u));
|
|
if (fh <= 0) return 0;
|
|
|
|
render::Framebuffer fb;
|
|
fb.pixels = reinterpret_cast<u32*>(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<uptr>(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<usize>(fw) * static_cast<usize>(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
|