gta6/tests/materials.test.js

import { describe, expect, it } from "vitest";
import { applyPolygonOffsets, MATERIAL_KEYS, POLYGON_OFFSETS, POLYGON_OFFSET_ORDER, SURFACE_COLORS, TEXTURES,
         waterNormalData } from "../src/world/materials.js";
import { buildChunkGeometry } from "../src/world/geometry.js";

describe("materials", () => {
    it("deckt genau die Geometrie-Teile ab", () => {
        const chunk = { chunk: [0, 0], origin: [0, 0], land: [], roads: [], centerlines: [], buildings: [], palms: [] };
        expect(Object.keys(buildChunkGeometry(chunk)).sort()).toEqual([...MATERIAL_KEYS].sort());
    });

    it("nennt für jedes Material genau eine Textur oder eine Farbe", () => {
        for (const key of MATERIAL_KEYS) expect(Boolean(TEXTURES[key]) !== Boolean(SURFACE_COLORS[key]), key).toBe(true);
    });

    it("gibt Feldern das Gras des Parks, dem Parkplatz den Asphalt der Straßen und Wegen Betonplatten", () => {
        expect(TEXTURES.field).toBe(TEXTURES.park);
        expect(TEXTURES.parking).toBe(TEXTURES.carriageway);
        expect(TEXTURES.paths).toBe("concrete_pavement");
        expect(Object.keys(SURFACE_COLORS).sort()).toEqual(["court", "markings", "pool"]);
    });

    it("deckt Strand und Park mit eigenen Materialien ab", () => {
        expect(MATERIAL_KEYS).toContain("sand");
        expect(MATERIAL_KEYS).toContain("park");
    });

    it("gibt Brücken dieselbe Textur wie Straßen, damit an der Übergangsnaht kein Farbsprung entsteht (Ruling 56)", () => {
        // Brücken sind in den Daten dasselbe Straßenstück, nur über Wasser.
        expect(TEXTURES.bridges).toBe(TEXTURES.carriageway);
    });

    it("erzeugt eine Wellen-Normalmap mit neutraler Grundfarbe", () => {
        const data = waterNormalData(32);
        expect(data.length).toBe(32 * 32 * 4);
        // Normalen zeigen im Mittel nach oben: Blaukanal nahe 255.
        const blue = [...data].filter((_, i) => i % 4 === 2);
        expect(blue.reduce((a, b) => a + b, 0) / blue.length).toBeGreaterThan(200);
    });
});

// Flackernder Boden (Diagnose-Report): geometry.js legt Boden bei y=0, Strand/Park/Stadtfläche
// bei SURFACE_OFFSET=0.02 und Straßen bei ROAD_OFFSET=0.03 an — 1-2 cm Abstand, der bei
// 150-300 m Kameraentfernung unter der Auflösung eines 24-Bit-Tiefenpuffers liegt. Rein und
// ganz ohne Browser testbar (wie im Auftrag gefordert): POLYGON_OFFSETS ist eine reine
// Datenstruktur, applyPolygonOffsets() eine reine Funktion auf Platzhalterobjekten — beide
// brauchen weder createMaterials() noch echtes Texturladen.
describe("Tiefenpuffer-Versatz je Schicht (gegen Flackern zwischen Boden/Stadt/Park/Strand/Straße)", () => {
    it("ordnet die Schichten Boden < Stadtfläche < Park < Strand < Feld < Platz < Pool < Parkplatz < Restfläche < Gehweg < Weg", () => {
        expect(POLYGON_OFFSET_ORDER).toEqual(["ground", "urban", "park", "sand", "field", "court", "pool",
                                              "parking", "lots", "sidewalk", "paths"]);
    });

    it("aktiviert polygonOffset für jede der fünf Schichten", () => {
        for (const key of POLYGON_OFFSET_ORDER) {
            expect(POLYGON_OFFSETS[key]?.polygonOffset).toBe(true);
        }
    });

    it("kein Paar unter den fünf Schichten teilt sich Faktor und Units — Strand, Park und "
        + "Stadtfläche bekommen je eine eigene Stufe statt sich eine zu teilen", () => {
        const sigs = POLYGON_OFFSET_ORDER.map((key) => {
            const o = POLYGON_OFFSETS[key];
            return `${o.polygonOffsetFactor}/${o.polygonOffsetUnits}`;
        });
        expect(new Set(sigs).size).toBe(sigs.length);
    });

    it("Betrag von Faktor und Units steigt streng von Boden zu Straße (Richtung Kamera)", () => {
        const factors = POLYGON_OFFSET_ORDER.map((key) => POLYGON_OFFSETS[key].polygonOffsetFactor);
        const units = POLYGON_OFFSET_ORDER.map((key) => POLYGON_OFFSETS[key].polygonOffsetUnits);
        for (let i = 1; i < factors.length; i++) {
            // Zunehmend negativ = zunehmend Richtung Kamera gezogen, s. Kommentar in materials.js.
            expect(factors[i]).toBeLessThan(factors[i - 1]);
            expect(units[i]).toBeLessThan(units[i - 1]);
        }
    });

    it("trägt den Versatz nur in Boden/Stadtfläche/Park/Strand/Straße ein — Brücken, Gebäude, "
        + "Wasser und Meeresboden bleiben unberührt (eigene Materialobjekte, s. Auftrag)", () => {
        const fake = Object.fromEntries(
            ["ground", "urban", "park", "sand", "field", "court", "pool", "parking", "lots", "sidewalk",
             "paths", "markings", "carriageway", "curb", "bridges", "buildings", "water", "seafloor"]
                .map((k) => [k, {}]),
        );
        applyPolygonOffsets(fake);
        for (const key of POLYGON_OFFSET_ORDER) {
            expect(fake[key]).toMatchObject(POLYGON_OFFSETS[key]);
        }
        // markings steht nicht in POLYGON_OFFSET_ORDER (eigener Versatz außerhalb der Rangfolge,
        // s. Kommentar dort), bekommt seinen Versatz aber trotzdem über den zweiten Eintrag im
        // POLYGON_OFFSETS-Objekt — einziger Beleg, dass der bis in ein Materialobjekt durchreicht.
        expect(fake.markings).toEqual(POLYGON_OFFSETS.markings);
        for (const key of ["carriageway", "curb", "bridges", "buildings", "water", "seafloor"]) {
            expect(fake[key]).toEqual({});
        }
    });
});

describe("Schichten aus Teil 2", () => {
    it("hat für jede neue Schicht ein Material", () => {
        for (const key of ["carriageway", "curb", "sidewalk", "markings", "lots"]) {
            expect(MATERIAL_KEYS).toContain(key);
        }
        expect(MATERIAL_KEYS).not.toContain("roads");
    });

    it("nimmt Bordstein und Gehweg aus dem Kit", () => {
        expect(TEXTURES.curb).toBe("curb");
        expect(TEXTURES.sidewalk).toBe("sidewalk");
        expect(TEXTURES.carriageway).toBe("asphalt_02");
        expect(TEXTURES.lots).toBe("asphalt_02");
    });

    it("gibt der Markierung eine Farbe statt einer Textur", () => {
        expect(SURFACE_COLORS.markings).toBeDefined();
        expect(TEXTURES.markings).toBeUndefined();
    });

    it("gibt der Markierung einen eigenen kleinen Versatz statt der obersten Stufe der Beläge", () => {
        // Ihr einziger Nachbar ist die Fahrbahn 1 cm darunter, und die hat keinen Versatz. Die oberste
        // Stufe zöge sie beim streifenden Blick am weitesten nach vorn, ohne dass es etwas nützte.
        expect(POLYGON_OFFSET_ORDER).not.toContain("markings");
        expect(POLYGON_OFFSETS.markings).toEqual({ polygonOffset: true, polygonOffsetFactor: -1, polygonOffsetUnits: -1 });
        // Fahrbahn und Bordstein liegen 15 cm tiefer und sind echte Geometrie — kein Versatz nötig.
        expect(POLYGON_OFFSETS.carriageway).toBeUndefined();
        expect(POLYGON_OFFSETS.curb).toBeUndefined();
    });
});