[aukio-3d.git] /

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

import eu.svjatoslav.aukio.e3d.geometry.Point2D;
import eu.svjatoslav.aukio.e3d.gui.RenderingContext;
import eu.svjatoslav.aukio.e3d.renderer.raster.RenderAggregator;
import eu.svjatoslav.aukio.e3d.math.TransformStack;

/**
 * Paint/sort handle for one triangle of a {@link TriangleMeshBlock}. The
 * triangle's geometry lives in the block's flat arrays (SoA layout); this
 * object exists only so the existing sort/bin/paint pipeline — typed on
 * individual shapes — can address one triangle. Handles are allocated once
 * at block build time and reused every frame; {@link #transform} is a
 * no-op because the block transforms all its triangles in one tight loop.
 *
 * <p>Per-slot screen data is read from the block's arrays through the
 * overridden accessors, so the Z-comparator and tile binning see exactly
 * the values an object-backed {@link TexturedTriangle} would expose.</p>
 */
final class MeshTriangle extends TexturedTriangle {

    /**
     * Scratch Point2D carriers for the flat paint call. Interpolators
     * hold references to the screen/UV points they are given, so the
     * objects must stay stable for the duration of one paint — but a
     * paint never nests, so three screen + three UV points per thread
     * suffice and nothing is allocated per triangle.
     */
    private static final ThreadLocal<Point2D[]> SCREEN_SCRATCH =
            ThreadLocal.withInitial(() -> new Point2D[]{
                    new Point2D(), new Point2D(), new Point2D()});
    private static final ThreadLocal<Point2D[]> UV_SCRATCH =
            ThreadLocal.withInitial(() -> new Point2D[]{
                    new Point2D(), new Point2D(), new Point2D()});

    private final TriangleMeshBlock block;
    private final int index;

    MeshTriangle(final TriangleMeshBlock block, final int index,
                 final eu.svjatoslav.aukio.e3d.renderer.raster.texture.Texture texture) {
        super(texture);
        this.block = block;
        this.index = index;
    }

    /**
     * No-op: the owning block transforms all its triangles (including this
     * one) in a single flat-array loop. Queued handles are never
     * transformed through the shape path. Sort Z and screen bounds live in
     * the inherited per-slot fields, written by the block via
     * {@code setSlotScreenState}.
     */
    @Override
    public void transform(final TransformStack transforms,
                          final RenderAggregator aggregator,
                          final RenderingContext renderingContext) {
        // intentionally empty — see TriangleMeshBlock.transform
    }

    /**
     * Publishes this triangle's per-slot screen state (called by the
     * owning block during its flat transform loop). Trampoline: the
     * inherited setter is protected, so the call must go through the
     * subclass.
     */
    void publishSlotState(final int slot, final double z,
                          final double minY, final double maxY,
                          final double minX, final double maxX) {
        setSlotScreenState(slot, z, minY, maxY, minX, maxX);
    }

    @Override
    public void paint(final RenderingContext renderBuffer) {
        final int slot = renderBuffer.vertexSlot;
        final Point2D[] screen = SCREEN_SCRATCH.get();
        final Point2D[] uvs = UV_SCRATCH.get();

        final int clip = block.clipOffset(slot, index);
        if (clip >= 0) {
            // Near-plane straddler: the block clipped to a loop of 3-4
            // vertices, stored as (x, y, z, u, v, sx, sy) tuples. Paint
            // as a fan, mirroring TexturedTriangle.paint's clipped path.
            final int count = block.clipCount(slot, index);
            final double[] store = block.clipStore(slot);
            loadClipVertex(screen[0], uvs[0], store, clip);
            for (int i = 1; i + 1 < count; i++) {
                loadClipVertex(screen[1], uvs[1], store, clip + i * 7);
                loadClipVertex(screen[2], uvs[2], store, clip + (i + 1) * 7);
                paintFlat(renderBuffer, block.texture(index), block.backfaceCull(),
                        screen[0], screen[1], screen[2],
                        uvs[0], uvs[1], uvs[2],
                        store[clip + 2],
                        store[clip + i * 7 + 2],
                        store[clip + (i + 1) * 7 + 2],
                        block.clipTtd(slot, clip));
            }
            return;
        }

        block.loadScreenVertex(screen[0], uvs[0], slot, index, 0, renderBuffer);
        block.loadScreenVertex(screen[1], uvs[1], slot, index, 1, renderBuffer);
        block.loadScreenVertex(screen[2], uvs[2], slot, index, 2, renderBuffer);
        paintFlat(renderBuffer, block.texture(index), block.backfaceCull(),
                screen[0], screen[1], screen[2],
                uvs[0], uvs[1], uvs[2],
                block.camZ(slot, index, 0),
                block.camZ(slot, index, 1),
                block.camZ(slot, index, 2),
                block.origTtd(index));
    }

    /**
     * Fills the scratch screen/UV points from one clip-loop entry; screen
     * coordinates were stored at clip time with the exact
     * {@code Vertex.setCameraSpaceCoordinate} expression.
     */
    private void loadClipVertex(final Point2D screen, final Point2D uv,
                                final double[] store, final int entry) {
        screen.x = store[entry + 5];
        screen.y = store[entry + 6];
        uv.x = store[entry + 3];
        uv.y = store[entry + 4];
    }
}