[aukio-3d.git] /

/*
 * Aukio 3D engine. Author: Svjatoslav Agejenko.
 * This project is released under Creative Commons Zero (CC0) license.
 */
package eu.svjatoslav.aukio.e3d.renderer.raster.shapes.composite;

import eu.svjatoslav.aukio.e3d.geometry.Point3D;
import eu.svjatoslav.aukio.e3d.renderer.raster.gi.LightmappedTriangle;
import eu.svjatoslav.aukio.e3d.renderer.raster.shapes.AbstractCoordinateShape;
import eu.svjatoslav.aukio.e3d.renderer.raster.shapes.AbstractShape;
import eu.svjatoslav.aukio.e3d.renderer.raster.shapes.basic.solidpolygon.SolidPolygon;
import eu.svjatoslav.aukio.e3d.renderer.raster.shapes.composite.base.AbstractCompositeShape;

import java.util.ArrayList;
import java.util.List;

/**
 * Composite shape whose solid polygons can render as lightmapped
 * triangles for the global illumination system.
 *
 * <p><b>Lightmapping:</b> when enabled, every {@link SolidPolygon}
 * (including those inside nested composites, which are flattened) is
 * wrapped as a {@link LightmappedTriangle} with its own lightmap texture,
 * and the GI system paints light across its surface instead of leaving
 * it a single flat color. Rebuild is automatic via the normal
 * cache-invalidation path.</p>
 *
 * <p><b>Ordering:</b> none required — the engine's z-buffer resolves
 * visibility per pixel, so this class needs no spatial ordering
 * structure of its own. Nested composites are flattened assuming
 * identity transforms (vertices are used in the composite's local
 * space); animate transforms above this composite, not inside it.</p>
 *
 * @see LightmappedTriangle the per-fragment lightmap carrier
 * @see AbstractCompositeShape the base composite (fan-triangulates
 *      N-vertex polygons when building the render list)
 */
public class LightmappedCompositeShape extends AbstractCompositeShape {

    /**
     * When true, the composite's polygons render as
     * {@link LightmappedTriangle}s: each polygon gets its own lightmap
     * texture and the GI system paints light across its surface.
     */
    private boolean lightmappingEnabled;

    /** World units per lightmap texel (smaller = finer GI detail). */
    private double lightmapUnitsPerTexel = 12.0;

    /**
     * Replaces solid polygons with lightmapped wrappers when lightmapping
     * is enabled; otherwise returns the list unchanged.
     *
     * @param renderList the render list built from the shape registry
     * @return lightmapped wrappers + non-polygon passthrough shapes
     */
    @Override
    protected List<AbstractShape> postprocessRenderList(final List<AbstractShape> renderList) {
        if (!lightmappingEnabled)
            return renderList;

        final List<AbstractShape> result = new ArrayList<>(renderList.size());
        for (final AbstractShape shape : renderList) {
            if (shape instanceof SolidPolygon) {
                wrapLightmapped((SolidPolygon) shape, result);
            } else if (shape instanceof AbstractCompositeShape) {
                // Flatten nested composites. Assumes identity transforms
                // on the nested composite chain.
                for (final SolidPolygon polygon
                        : ((AbstractCompositeShape) shape).extractSolidPolygons())
                    wrapLightmapped(polygon, result);
            } else {
                result.add(shape);
            }
        }
        return result;
    }

    /**
     * Enables or disables lightmapping. When enabled, the composite's
     * polygons render as {@link LightmappedTriangle}s with per-polygon
     * lightmap textures filled by the global illumination system.
     * Rebuilds the render list on the next frame.
     *
     * @param enabled true to render polygons lightmapped
     */
    public void setLightmappingEnabled(final boolean enabled) {
        if (lightmappingEnabled != enabled) {
            lightmappingEnabled = enabled;
            setCacheNeedsRebuild(true);
        }
    }

    /**
     * Returns whether lightmapping is enabled.
     *
     * @return true when polygons render as lightmapped triangles
     */
    public boolean isLightmappingEnabled() {
        return lightmappingEnabled;
    }

    /**
     * Sets the lightmap resolution. Default 12 world units per texel:
     * a 100-unit wall cell gets an 8x8 lightmap. Halving the units
     * quadruples the GI tracing work; finer texels are the ONLY way to
     * smoother shadow edges (there is no upsampling). Takes effect on the
     * next render list rebuild.
     *
     * @param unitsPerTexel world units per texel
     */
    public void setLightmapUnitsPerTexel(final double unitsPerTexel) {
        lightmapUnitsPerTexel = unitsPerTexel;
        setCacheNeedsRebuild(true);
    }

    /**
     * Fan-triangulates a polygon (triangles pass through as-is) and wraps
     * each triangle into a lightmapped textured triangle with the same
     * geometry, color and culling. The initial texture is dim; the GI
     * system converges it to full lighting within seconds.
     *
     * @param polygon the polygon to wrap (any vertex count >= 3)
     * @param out     the list receiving the lightmapped triangles
     */
    private void wrapLightmapped(final SolidPolygon polygon, final List<AbstractShape> out) {
        final int vertexCount = polygon.getVertexCount();
        if (vertexCount == 3) {
            out.add(wrapTriangle(polygon));
            return;
        }
        // Fan: anchor vertex 0, then consecutive pairs
        final Point3D anchor = polygon.vertices.get(0).coordinate;
        for (int i = 1; i + 1 < vertexCount; i++) {
            final SolidPolygon triangle = new SolidPolygon(
                    anchor,
                    polygon.vertices.get(i).coordinate,
                    polygon.vertices.get(i + 1).coordinate,
                    polygon.getColor());
            triangle.setShadingEnabled(polygon.isShadingEnabled());
            triangle.setBackfaceCulling(polygon.isBackfaceCullingEnabled());
            triangle.setMouseInteractionController(polygon.mouseInteractionController);
            out.add(wrapTriangle(triangle));
        }
    }

    /**
     * Wraps one triangle into a lightmapped textured triangle with the
     * same geometry, color and culling.
     */
    private AbstractCoordinateShape wrapTriangle(final SolidPolygon polygon) {
        final Point3D a = polygon.vertices.get(0).coordinate;
        final Point3D b = polygon.vertices.get(1).coordinate;
        final Point3D c = polygon.vertices.get(2).coordinate;

        // Normal: right-handed cross(b-a, c-a).
        final double e1x = b.x - a.x, e1y = b.y - a.y, e1z = b.z - a.z;
        final double e2x = c.x - a.x, e2y = c.y - a.y, e2z = c.z - a.z;
        double nx = e1y * e2z - e1z * e2y;
        double ny = e1z * e2x - e1x * e2z;
        double nz = e1x * e2y - e1y * e2x;
        final double len = Math.sqrt(nx * nx + ny * ny + nz * nz);
        if (len > 0) {
            nx /= len;
            ny /= len;
            nz /= len;
        }

        final LightmappedTriangle triangle = new LightmappedTriangle(
                a, b, c, polygon.getColor(), lightmapUnitsPerTexel,
                nx, ny, nz);
        triangle.setBackfaceCulling(polygon.isBackfaceCullingEnabled());
        triangle.setMouseInteractionController(polygon.mouseInteractionController);
        return triangle;
    }
}