[aukio-3d.git] /

package eu.svjatoslav.aukio.e3d.renderer.raster.shapes.basic.texturedpolygon;

import eu.svjatoslav.aukio.e3d.geometry.Box;
import eu.svjatoslav.aukio.e3d.geometry.Point2D;
import eu.svjatoslav.aukio.e3d.geometry.Point3D;
import eu.svjatoslav.aukio.e3d.gui.HiZPyramid;
import eu.svjatoslav.aukio.e3d.gui.RenderingContext;
import eu.svjatoslav.aukio.e3d.gui.StereoEye;
import eu.svjatoslav.aukio.e3d.renderer.raster.RenderAggregator;
import eu.svjatoslav.aukio.e3d.renderer.raster.shapes.AbstractShape;
import eu.svjatoslav.aukio.e3d.renderer.raster.texture.Texture;
import eu.svjatoslav.aukio.e3d.math.TransformStack;

/**
 * A block of textured triangles stored as flat primitive arrays
 * (struct-of-arrays) instead of one object graph per triangle. Built once
 * (off the render thread), then every frame a single tight loop applies
 * the composed camera transform to all vertices — sequential memory
 * access instead of pointer chasing through {@code Vertex}/{@code Point3D}
 * soup, which is what made the transform phase memory-latency-bound.
 *
 * <p>Interaction with the rest of the pipeline is unchanged: each visible
 * triangle is queued as a thin preallocated {@link MeshTriangle} handle
 * into the same {@link RenderAggregator}, sorted by the same comparator,
 * binned into the same tile grid, and painted by the same
 * {@link TexturedTriangle#paintFlat} core — bit-exact with the
 * object-backed path.</p>
 *
 * <p>Subpixel-cull verdicts are cached per triangle ({@link #cullEpoch}):
 * while the verdict epoch holds, a culled triangle costs one integer
 * compare per frame — no vertex math at all.</p>
 *
 * <p>Limitations vs object-backed triangles: no mouse picking, no SDF
 * textures (rejected at build), no GI/lightmap integration.</p>
 */
public final class TriangleMeshBlock extends AbstractShape {

    // Build-time geometry: 9 world doubles and 6 UV doubles per triangle.
    private final double[] world;
    private final double[] uv;
    private final Texture[] textures;
    private final boolean backfaceCull;
    private final int triCount;
    private final MeshTriangle[] handles;
    private final Box boundingBox;

    // Per-slot projected state: 3 screen/camera doubles per triangle per
    // slot. (Sort Z and binning bounds are published into the handles'
    // per-slot fields at transform time, not kept here.)
    private final double[][] projX = new double[3][];
    private final double[][] projY = new double[3][];
    private final double[][] camZ = new double[3][];

    // Subpixel-cull verdicts: epoch in which the triangle was found tiny.
    private final int[] cullEpoch;

    // Near-plane clip output per slot: packed (offset << 3) | count into
    // clipStore, -1 = not clipped. Clip data is 7 doubles per loop vertex
    // (camera x, y, z, u, v + screen x, y), at most 4 vertices per
    // straddler. Sort Z and binning bounds for straddlers are derived
    // from the store, exactly like the object path derives them from the
    // clipped loop. clipTtd keeps the ORIGINAL triangle's UV perimeter
    // per straddler (index = clip offset / 28): mipmap selection must
    // use the unclipped texel density, exactly like the object path.
    private static final int CLIP_STRIDE = 7;
    private static final int CLIP_ENTRY = 4 * CLIP_STRIDE;
    private final int[][] clipRef = new int[3][];
    private final double[][] clipStore = new double[3][];
    private final double[][] clipTtd = new double[3][];

    /** Per-triangle UV perimeter (mipmap metric), computed once at build:
     * the uv array never changes afterwards. Same expression and
     * accumulation order as {@code TexturedTriangle}'s
     * computeTotalTextureDistance: d(0,1) + d(0,2) + d(1,2). */
    private final double[] uvPerimeter;

    /** Per-triangle screen-edge perimeter (mipmap metric's visible side),
     * computed once per slot in the transform loop — identical expression
     * to what the paint core used to recompute per tile. */
    private final double[][] screenPerim = new double[3][];
    private final int[] clipUsed = new int[3];

    // Scratch for the composed top transform of the current transform call.
    private final double[] top = new double[12];

    /**
     * Builds a block from baked world-space triangle soup.
     *
     * @param world         9 doubles per triangle (x0,y0,z0,x1,...), world
     *                      space; the array is adopted, not copied
     * @param uv            6 doubles per triangle (u0,v0,...) in primary
     *                      texture pixels; adopted
     * @param textures      one texture per triangle
     * @param backfaceCull  cull clockwise triangles on screen
     */
    public TriangleMeshBlock(final double[] world, final double[] uv,
                             final Texture[] textures,
                             final boolean backfaceCull) {
        this.triCount = textures.length;
        if (world.length != triCount * 9 || uv.length != triCount * 6)
            throw new IllegalArgumentException("array length mismatch");
        this.world = world;
        this.uv = uv;
        this.textures = textures;
        this.backfaceCull = backfaceCull;
        for (final Texture texture : textures)
            if (texture != null && texture.isSdf())
                throw new IllegalArgumentException(
                        "SDF textures are not supported in mesh blocks");

        this.handles = new MeshTriangle[triCount];
        for (int t = 0; t < triCount; t++)
            handles[t] = new MeshTriangle(this, t, textures[t]);

        this.cullEpoch = new int[triCount];
        java.util.Arrays.fill(cullEpoch, -1);

        for (int s = 0; s < 3; s++) {
            projX[s] = new double[triCount * 3];
            projY[s] = new double[triCount * 3];
            camZ[s] = new double[triCount * 3];
            clipRef[s] = new int[triCount];
            java.util.Arrays.fill(clipRef[s], -1);
            clipStore[s] = new double[256];
            clipTtd[s] = new double[16];
            screenPerim[s] = new double[triCount];
        }

        uvPerimeter = new double[triCount];
        for (int t = 0; t < triCount; t++) {
            final int u = t * 6;
            final double d1 = Math.sqrt(
                    ((uv[u] - uv[u + 2]) * (uv[u] - uv[u + 2]))
                            + ((uv[u + 1] - uv[u + 3]) * (uv[u + 1] - uv[u + 3])));
            final double d2 = Math.sqrt(
                    ((uv[u] - uv[u + 4]) * (uv[u] - uv[u + 4]))
                            + ((uv[u + 1] - uv[u + 5]) * (uv[u + 1] - uv[u + 5])));
            final double d3 = Math.sqrt(
                    ((uv[u + 2] - uv[u + 4]) * (uv[u + 2] - uv[u + 4]))
                            + ((uv[u + 3] - uv[u + 5]) * (uv[u + 3] - uv[u + 5])));
            uvPerimeter[t] = d1 + d2 + d3;
        }

        double minX = Double.MAX_VALUE, minY = Double.MAX_VALUE,
                minZ = Double.MAX_VALUE;
        double maxX = -Double.MAX_VALUE, maxY = -Double.MAX_VALUE,
                maxZ = -Double.MAX_VALUE;
        for (int i = 0; i < world.length; i += 3) {
            if (world[i] < minX) minX = world[i];
            if (world[i] > maxX) maxX = world[i];
            if (world[i + 1] < minY) minY = world[i + 1];
            if (world[i + 1] > maxY) maxY = world[i + 1];
            if (world[i + 2] < minZ) minZ = world[i + 2];
            if (world[i + 2] > maxZ) maxZ = world[i + 2];
        }
        boundingBox = new Box(new Point3D(minX, minY, minZ),
                new Point3D(maxX, maxY, maxZ));
    }

    public int triCount() {
        return triCount;
    }

    @Override
    public Box getBoundingBox() {
        return boundingBox;
    }

    @Override
    public int getTransformWeight(final RenderingContext renderingContext) {
        return Math.max(1, triCount);
    }

    /**
     * Transforms every triangle of the block with the composed top
     * transform of the stack (hoisted out of the loop), culls (near
     * plane, subpixel with verdict cache, viewport) and queues a thin
     * handle per surviving triangle. All expressions replicate
     * {@code TransformStack.transform} /
     * {@code Vertex.calculateLocationRelativeToViewer} exactly, so output
     * is bit-identical with the object-backed path.
     */
    @Override
    public void transform(final TransformStack transforms,
                          final RenderAggregator aggregator,
                          final RenderingContext renderingContext) {
        final int slot = renderingContext.vertexSlot;
        final double[] px = projX[slot];
        final double[] py = projY[slot];
        final double[] cz = camZ[slot];
        final int[] cref = clipRef[slot];
        clipUsed[slot] = 0;

        transforms.getTopTransform(top);
        final double r0 = top[0], r1 = top[1], r2 = top[2];
        final double r3 = top[3], r4 = top[4], r5 = top[5];
        final double r6 = top[6], r7 = top[7], r8 = top[8];
        final double t0 = top[9], t1 = top[10], t2 = top[11];

        final double near = renderingContext.nearPlaneDistance;
        final double scale = renderingContext.projectionScale;
        final double centerX = renderingContext.centerCoordinate.x;
        final double centerY = renderingContext.centerCoordinate.y;
        final double stereo = renderingContext.stereoViewportOffsetX;

        // Hi-Z whole-block occlusion: test the world AABB against last
        // frame's depth pyramid before touching a single triangle.
        // Skipped in stereo (the pyramid is mono-view) and whenever a
        // corner crosses the near plane (its projection is unreliable).
        final HiZPyramid hiz = renderingContext.occlusionPyramid;
        if (hiz != null
                && renderingContext.stereoEye == StereoEye.NONE) {
            hiz.blocksTested.incrementAndGet();
            final Point3D lo = boundingBox.p1, hi = boundingBox.p2;
            double ax1 = Double.MAX_VALUE, ay1 = Double.MAX_VALUE;
            double ax2 = -Double.MAX_VALUE, ay2 = -Double.MAX_VALUE;
            double nearestW = -Double.MAX_VALUE;
            boolean usable = true;
            for (int c = 0; c < 8; c++) {
                final double wx = (c & 1) != 0 ? hi.x : lo.x;
                final double wy = (c & 2) != 0 ? hi.y : lo.y;
                final double wz = (c & 4) != 0 ? hi.z : lo.z;
                final double ccz = r6 * wx + r7 * wy + r8 * wz + t2;
                if (ccz <= near) {
                    usable = false;
                    break;
                }
                final double ccx = r0 * wx + r1 * wy + r2 * wz + t0;
                final double ccy = r3 * wx + r4 * wy + r5 * wz + t1;
                final double sx = ((ccx / ccz) * scale) + centerX + stereo;
                final double sy = ((ccy / ccz) * scale) + centerY;
                if (sx < ax1) ax1 = sx;
                if (sx > ax2) ax2 = sx;
                if (sy < ay1) ay1 = sy;
                if (sy > ay2) ay2 = sy;
                final double w = 1d / ccz;
                if (w > nearestW) nearestW = w;
            }
            if (usable && ax1 <= ax2 && ay1 <= ay2
                    && hiz.occluded(ax1, ay1, ax2, ay2, nearestW)) {
                hiz.blocksCulled.incrementAndGet();
                return;
            }
        }
        final double cullThreshold = renderingContext.subpixelCullingThreshold;
        final int epoch = renderingContext.subpixelCullingEpoch;
        final double rMinX = renderingContext.renderMinX;
        final double rMaxX = renderingContext.renderMaxX;
        final double rMinY = renderingContext.renderMinY;
        final double rMaxY = renderingContext.renderMaxY;

        for (int t = 0; t < triCount; t++) {
            if (cullThreshold > 0 && cullEpoch[t] == epoch)
                continue;

            final int w = t * 9;
            // Same expression order as TransformStack.transform.
            final double x0 = world[w], y0 = world[w + 1], z0 = world[w + 2];
            final double cx0 = r0 * x0 + r1 * y0 + r2 * z0 + t0;
            final double cy0 = r3 * x0 + r4 * y0 + r5 * z0 + t1;
            final double cz0 = r6 * x0 + r7 * y0 + r8 * z0 + t2;
            final double x1 = world[w + 3], y1 = world[w + 4], z1 = world[w + 5];
            final double cx1 = r0 * x1 + r1 * y1 + r2 * z1 + t0;
            final double cy1 = r3 * x1 + r4 * y1 + r5 * z1 + t1;
            final double cz1 = r6 * x1 + r7 * y1 + r8 * z1 + t2;
            final double x2 = world[w + 6], y2 = world[w + 7], z2 = world[w + 8];
            final double cx2 = r0 * x2 + r1 * y2 + r2 * z2 + t0;
            final double cy2 = r3 * x2 + r4 * y2 + r5 * z2 + t1;
            final double cz2 = r6 * x2 + r7 * y2 + r8 * z2 + t2;

            final boolean in0 = cz0 > near;
            final boolean in1 = cz1 > near;
            final boolean in2 = cz2 > near;

            if (!in0 && !in1 && !in2) {
                cref[t] = -1;
                continue;
            }

            final int v = t * 3;
            if (!(in0 && in1 && in2)) {
                clipAndQueue(t, v, slot, cx0, cy0, cz0, cx1, cy1, cz1,
                        cx2, cy2, cz2, in0, in1, in2, near, cref,
                        aggregator, renderingContext);
                continue;
            }

            cref[t] = -1;
            cz[v] = cz0;
            cz[v + 1] = cz1;
            cz[v + 2] = cz2;
            // Same expression order as
            // Vertex.calculateLocationRelativeToViewer (divide, scale,
            // add center, add stereo offset).
            final double sx0 = ((cx0 / cz0) * scale) + centerX + stereo;
            final double sy0 = ((cy0 / cz0) * scale) + centerY;
            final double sx1 = ((cx1 / cz1) * scale) + centerX + stereo;
            final double sy1 = ((cy1 / cz1) * scale) + centerY;
            final double sx2 = ((cx2 / cz2) * scale) + centerX + stereo;
            final double sy2 = ((cy2 / cz2) * scale) + centerY;
            px[v] = sx0;
            py[v] = sy0;
            px[v + 1] = sx1;
            py[v + 1] = sy1;
            px[v + 2] = sx2;
            py[v + 2] = sy2;
            final double triZ = (cz0 + cz1 + cz2) / 3;

            final double minX = Math.min(sx0, Math.min(sx1, sx2));
            final double maxX = Math.max(sx0, Math.max(sx1, sx2));
            final double minY = Math.min(sy0, Math.min(sy1, sy2));
            final double maxY = Math.max(sy0, Math.max(sy1, sy2));

            // Publish the same per-slot state an object-backed triangle
            // would have written (paint margins are 0 for mesh tris):
            // comparator and tile binning then read plain fields.
            handles[t].publishSlotState(slot, triZ, minY, maxY, minX, maxX);

            // Subpixel verdict with per-triangle cache (same raw-span
            // semantics as AbstractCoordinateShape).
            if (cullThreshold > 0
                    && maxX - minX < cullThreshold
                    && maxY - minY < cullThreshold) {
                cullEpoch[t] = epoch;
                continue;
            }

            // Viewport cull (paint margins are 0 for mesh triangles).
            if (maxX < rMinX || minX >= rMaxX || maxY < rMinY || minY >= rMaxY)
                continue;

            // Mipmap metric's visible side, once per slot instead of per
            // tile: edge12 + edge13 + edge23, the same expression the
            // paint core ran per tile (getDistanceTo sequence).
            final double dx01 = sx0 - sx1, dy01 = sy0 - sy1;
            final double dx02 = sx0 - sx2, dy02 = sy0 - sy2;
            final double dx12 = sx1 - sx2, dy12 = sy1 - sy2;
            screenPerim[slot][t] = Math.sqrt(dx01 * dx01 + dy01 * dy01)
                    + Math.sqrt(dx02 * dx02 + dy02 * dy02)
                    + Math.sqrt(dx12 * dx12 + dy12 * dy12);

            aggregator.queueShapeForRendering(handles[t]);
        }
    }

    /**
     * Near-plane clip for one straddling triangle, Sutherland-Hodgman
     * over the three edges with the exact interpolation expressions of
     * {@code AbstractCoordinateShape.interpolateAtPlane}. Output goes to
     * the slot's grow-only clip store; the handle is queued with a packed
     * reference.
     */
    private void clipAndQueue(final int t, final int v, final int slot,
                              final double cx0, final double cy0, final double cz0,
                              final double cx1, final double cy1, final double cz1,
                              final double cx2, final double cy2, final double cz2,
                              final boolean in0, final boolean in1, final boolean in2,
                              final double near, final int[] cref,
                              final RenderAggregator aggregator,
                              final RenderingContext renderingContext) {
        double[] store = clipStore[slot];
        int used = clipUsed[slot];
        if (used + CLIP_ENTRY > store.length) {
            final double[] grown = new double[store.length * 2];
            System.arraycopy(store, 0, grown, 0, used);
            store = grown;
            clipStore[slot] = grown;
            final double[] grownTtd = new double[grown.length / CLIP_ENTRY];
            System.arraycopy(clipTtd[slot], 0, grownTtd, 0, clipTtd[slot].length);
            clipTtd[slot] = grownTtd;
        }
        final int base = used;
        clipTtd[slot][base / CLIP_ENTRY] = uvPerimeter[t];

        final double scale = renderingContext.projectionScale;
        final double centerX = renderingContext.centerCoordinate.x;
        final double centerY = renderingContext.centerCoordinate.y;
        final double stereo = renderingContext.stereoViewportOffsetX;

        final double[] cx = {cx0, cx1, cx2};
        final double[] cy = {cy0, cy1, cy2};
        final double[] czz = {cz0, cz1, cz2};
        final boolean[] in = {in0, in1, in2};
        final int uvi = t * 6;

        int n = 0;
        double sumZ = 0;
        for (int i = 0; i < 3; i++) {
            final int j = (i + 1) % 3;
            final boolean currentIn = in[i];
            final boolean nextIn = in[j];
            if (currentIn) {
                store[used++] = cx[i];
                store[used++] = cy[i];
                store[used++] = czz[i];
                store[used++] = uv[uvi + i * 2];
                store[used++] = uv[uvi + i * 2 + 1];
                // setCameraSpaceCoordinate expression, same order
                store[used++] = ((cx[i] / czz[i]) * scale) + centerX + stereo;
                store[used++] = ((cy[i] / czz[i]) * scale) + centerY;
                n++;
                sumZ += czz[i];
            }
            if (currentIn != nextIn) {
                final double tt = (near - czz[i]) / (czz[j] - czz[i]);
                final double ix = cx[i] + (cx[j] - cx[i]) * tt;
                final double iy = cy[i] + (cy[j] - cy[i]) * tt;
                final double iz = czz[i] + (czz[j] - czz[i]) * tt;
                store[used++] = ix;
                store[used++] = iy;
                store[used++] = iz;
                store[used++] = uv[uvi + i * 2]
                        + (uv[uvi + j * 2] - uv[uvi + i * 2]) * tt;
                store[used++] = uv[uvi + i * 2 + 1]
                        + (uv[uvi + j * 2 + 1] - uv[uvi + i * 2 + 1]) * tt;
                store[used++] = ((ix / iz) * scale) + centerX + stereo;
                store[used++] = ((iy / iz) * scale) + centerY;
                n++;
                sumZ += iz;
            }
        }

        // Degenerate sliver: fewer loop points than a renderable triangle.
        if (n < 3) {
            cref[t] = -1;
            return;
        }
        clipUsed[slot] = used;
        cref[t] = (base << 3) | n;
        // Object path averages Z and derives bounds over the clipped loop
        double cMinX = Double.MAX_VALUE, cMaxX = -Double.MAX_VALUE;
        double cMinY = Double.MAX_VALUE, cMaxY = -Double.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            final double sx = store[base + i * CLIP_STRIDE + 5];
            final double sy = store[base + i * CLIP_STRIDE + 6];
            if (sx < cMinX) cMinX = sx;
            if (sx > cMaxX) cMaxX = sx;
            if (sy < cMinY) cMinY = sy;
            if (sy > cMaxY) cMaxY = sy;
        }
        handles[t].publishSlotState(slot, sumZ / n, cMinY, cMaxY, cMinX, cMaxX);
        aggregator.queueShapeForRendering(handles[t]);
    }

    // ---- handle-facing accessors (package-private) ----

    double camZ(final int slot, final int tri, final int vertex) {
        return camZ[slot][tri * 3 + vertex];
    }

    Texture texture(final int tri) {
        return textures[tri];
    }

    boolean backfaceCull() {
        return backfaceCull;
    }

    int clipOffset(final int slot, final int tri) {
        final int ref = clipRef[slot][tri];
        return ref < 0 ? -1 : ref >> 3;
    }

    int clipCount(final int slot, final int tri) {
        return clipRef[slot][tri] & 7;
    }

    double[] clipStore(final int slot) {
        return clipStore[slot];
    }

    double clipTtd(final int slot, final int clipOffset) {
        return clipTtd[slot][clipOffset / CLIP_ENTRY];
    }

    /** The triangle's UV perimeter, precomputed at build (see field). */
    double uvPerimeter(final int tri) {
        return uvPerimeter[tri];
    }

    /**
     * The triangle's screen-edge perimeter for this slot, precomputed in
     * the transform loop (only valid for triangles queued unclipped).
     */
    double screenPerim(final int slot, final int tri) {
        return screenPerim[slot][tri];
    }

    /**
     * Loads one unclipped triangle vertex (screen + UV) into the scratch
     * carriers, values exactly as computed at transform time.
     */
    void loadScreenVertex(final Point2D screen, final Point2D uvOut,
                          final int slot, final int tri, final int vertex,
                          final RenderingContext ctx) {
        final int v = tri * 3 + vertex;
        screen.x = projX[slot][v];
        screen.y = projY[slot][v];
        uvOut.x = uv[tri * 6 + vertex * 2];
        uvOut.y = uv[tri * 6 + vertex * 2 + 1];
    }
}