Introduce RenderPasses which allow custom modifications to the entire tile-model without being bound to a custom block or entity

Author: TBlueF

core/src/main/java/de/bluecolored/bluemap/core/map/BmMap.java

@@ -105,6 +105,7 @@ public BmMap(String id, String name, World world, MapStorage storage, ResourcePa
         saveTextureGallery();
 
         this.hiresModelManager = new HiresModelManager(
+                world,
                 storage.hiresTiles(),
                 this.resourcePack,
                 this.textureGallery,
@@ -135,7 +136,7 @@ public void renderTile(Vector2i tile) {
 
         long start = System.nanoTime();
 
-        hiresModelManager.render(world, tile, lowresTileManager, mapSettings.isSaveHiresLayer());
+        hiresModelManager.render(tile, lowresTileManager, mapSettings.isSaveHiresLayer());
 
         long end = System.nanoTime();
         long delta = end - start;

core/src/main/java/de/bluecolored/bluemap/core/map/hires/HiresModelManager.java

@@ -38,47 +38,60 @@
 
 import java.io.IOException;
 import java.io.OutputStream;
+import java.util.Collection;
+import java.util.List;
 
 public class HiresModelManager {
 
+    private final World world;
     private final GridStorage storage;
-    private final HiresModelRenderer renderer;
+    private final ThreadLocal<Collection<RenderPass>> renderPasses;
 
     @Getter
     private final Grid tileGrid;
 
-    public HiresModelManager(GridStorage storage, ResourcePack resourcePack, TextureGallery textureGallery, RenderSettings renderSettings, Grid tileGrid) {
-        this(storage, new HiresModelRenderer(resourcePack, textureGallery, renderSettings), tileGrid);
-    }
-
-    public HiresModelManager(GridStorage storage, HiresModelRenderer renderer, Grid tileGrid) {
+    public HiresModelManager(World world, GridStorage storage, ResourcePack resourcePack, TextureGallery textureGallery, RenderSettings renderSettings, Grid tileGrid) {
+        this.world = world;
         this.storage = storage;
-        this.renderer = renderer;
-
         this.tileGrid = tileGrid;
+
+        Collection<RenderPassType> renderPassTypes = List.copyOf(RenderPassType.REGISTRY.values());
+        this.renderPasses = ThreadLocal.withInitial(() -> renderPassTypes.stream()
+                .map(type -> type.create(resourcePack, textureGallery, renderSettings))
+                .toList()
+        );
     }
 
     /**
      * Renders the given world tile with the provided render-settings
      */
-    public void render(World world, Vector2i tile, TileMetaConsumer tileMetaConsumer, boolean save) {
-        Vector2i tileMin = tileGrid.getCellMin(tile);
-        Vector2i tileMax = tileGrid.getCellMax(tile);
-
-        Vector3i modelMin = new Vector3i(tileMin.getX(), Integer.MIN_VALUE, tileMin.getY());
-        Vector3i modelMax = new Vector3i(tileMax.getX(), Integer.MAX_VALUE, tileMax.getY());
+    public void render(Vector2i tile, TileMetaConsumer tileMetaConsumer, boolean save) {
+        Vector3i modelMin = new Vector3i(tileGrid.getCellMinX(tile.getX()), Integer.MIN_VALUE, tileGrid.getCellMinY(tile.getY()));
+        Vector3i modelMax = new Vector3i(tileGrid.getCellMaxX(tile.getX()), Integer.MAX_VALUE, tileGrid.getCellMaxY(tile.getY()));
+        Vector3i modelAnchor = new Vector3i(modelMin.getX(), 0, modelMin.getZ());
 
         if (save) {
             ArrayTileModel model = ArrayTileModel.instancePool().claimInstance();
+            TileModelView modelView = new TileModelView(model);
 
-            renderer.render(world, modelMin, modelMax, model, tileMetaConsumer);
+            try {
+                for (RenderPass renderPass : renderPasses.get()) {
+                    renderPass.render(world, modelMin, modelMax, modelAnchor, modelView.initialize(), tileMetaConsumer);
+                }
+            } catch (MaxCapacityReachedException ex) {
+                Logger.global.noFloodWarning("max-capacity-reached",
+                        "One or more map-tiles are too complex to be completed (@~ %s to %s): %s".formatted(modelMin, modelMax, ex));
+            }
 
             model.sort();
             save(model, tile);
 
             ArrayTileModel.instancePool().recycleInstance(model);
         } else {
-            renderer.render(world, modelMin, modelMax, VoidTileModel.INSTANCE, tileMetaConsumer);
+            TileModelView modelView = new TileModelView(VoidTileModel.INSTANCE);
+            for (RenderPass renderPass : renderPasses.get()) {
+                renderPass.render(world, modelMin, modelMax, modelAnchor, modelView.initialize(), tileMetaConsumer);
+            }
         }
 
     }

core/src/main/java/de/bluecolored/bluemap/core/map/hires/HiresModelRenderer.java

@@ -0,0 +1,62 @@
+/*
+ * This file is part of BlueMap, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) Blue (Lukas Rieger) <https://bluecolored.de>
+ * Copyright (c) contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package de.bluecolored.bluemap.core.map.hires;
+
+import com.flowpowered.math.vector.Vector3i;
+import de.bluecolored.bluemap.core.map.TileMetaConsumer;
+import de.bluecolored.bluemap.core.world.World;
+
+public interface RenderPass {
+
+    /**
+     * Does a pass to render a specified of the world onto the given tileModel.
+     * <p>
+     *  <b>Implementation Note:</b><br>
+     *  This method is guaranteed to be called only on <b>one thread per RenderPass instance</b>, so you can use this
+     *  for optimizations.
+     * </p>
+     * @param world The world that should be rendered
+     * @param modelMin The min-position of the world that should be included in the tileModel
+     * @param modelMax The max-position of the world that should be included in the tileModel
+     * @param modelAnchor The position in the world that should be at (0,0,0) in the tileModel
+     * @param tileModel The model(-view) where the world should be rendered to.
+     * @param tileMetaConsumer A consumer that the RenderPass can call to emit heightmap and light-data that is produced during rendering.
+     *                         This data is then e.g. used to generate the lowres-tiles.
+     */
+    void render(World world, Vector3i modelMin, Vector3i modelMax, Vector3i modelAnchor, TileModelView tileModel, TileMetaConsumer tileMetaConsumer);
+
+    /**
+     * Does a pass to render a specified of the world onto the given tileModel.
+     * @param world The world that should be rendered
+     * @param modelMin The min-position of the world that should be included in the tileModel
+     * @param modelMax The max-position of the world that should be included in the tileModel
+     * @param modelAnchor The position in the world that should be at (0,0,0) in the tileModel
+     * @param tileModel The model(-view) where the world should be rendered to.
+     */
+    default void render(World world, Vector3i modelMin, Vector3i modelMax, Vector3i modelAnchor, TileModelView tileModel) {
+        render(world, modelMin, modelMax, modelAnchor, tileModel, (x, z, c, h, l) -> {});
+    }
+
+}

core/src/main/java/de/bluecolored/bluemap/core/map/hires/RenderPass.java

@@ -0,0 +1,10 @@
+package de.bluecolored.bluemap.core.map.hires;
+
+import de.bluecolored.bluemap.core.map.TextureGallery;
+import de.bluecolored.bluemap.core.resources.pack.resourcepack.ResourcePack;
+
+public interface RenderPassFactory {
+
+    RenderPass create(ResourcePack resourcePack, TextureGallery textureGallery, RenderSettings renderSettings);
+
+}

core/src/main/java/de/bluecolored/bluemap/core/map/hires/RenderPassFactory.java

@@ -0,0 +1,37 @@
+package de.bluecolored.bluemap.core.map.hires;
+
+import de.bluecolored.bluemap.core.map.TextureGallery;
+import de.bluecolored.bluemap.core.map.hires.block.BlockRenderPass;
+import de.bluecolored.bluemap.core.map.hires.entity.EntityRenderPass;
+import de.bluecolored.bluemap.core.resources.pack.resourcepack.ResourcePack;
+import de.bluecolored.bluemap.core.util.Key;
+import de.bluecolored.bluemap.core.util.Keyed;
+import de.bluecolored.bluemap.core.util.Registry;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+public interface RenderPassType extends Keyed, RenderPassFactory {
+
+    RenderPassType BLOCKS = new Impl(Key.bluemap("blocks"), BlockRenderPass::new);
+    RenderPassType ENTITIES = new Impl(Key.bluemap("entities"), EntityRenderPass::new);
+
+    Registry<RenderPassType> REGISTRY = new Registry<>(
+            BLOCKS,
+            ENTITIES
+    );
+
+    @RequiredArgsConstructor
+    class Impl implements RenderPassType {
+
+        @Getter
+        private final Key key;
+        private final RenderPassFactory factory;
+
+        @Override
+        public RenderPass create(ResourcePack resourcePack, TextureGallery textureGallery, RenderSettings renderSettings) {
+            return factory.create(resourcePack, textureGallery, renderSettings);
+        }
+
+    }
+
+}