CustomRenderLayer

package at.tobiazsh.myworld.traffic_addition.components.Rendering;

import com.mojang.blaze3d.systems.RenderSystem;
import net.minecraft.client.render.RenderPhase;
import net.minecraft.client.render.VertexFormat;
import net.minecraft.client.render.VertexFormats;
import net.minecraft.util.Identifier;
import net.minecraft.util.TriState;
import net.minecraft.util.Util;
import net.minecraft.client.render.RenderLayer;
import org.joml.Matrix4fStack;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

import static net.minecraft.client.render.RenderPhase.*;

public class CustomRenderLayer {

    private static final Map<Identifier, RenderLayer> BUILT_TEXT_RENDER_LAYERS = new HashMap<>(); // Stores all the built text render layers of all fonts

    public static RenderLayer getTextRenderLayer(Identifier key) {
//        Identifier newKey = Identifier.of(key.getNamespace(), key.getPath().substring(0, key.getPath().lastIndexOf("/") - 1)); // Cutting the font id short for simplicity
        return BUILT_TEXT_RENDER_LAYERS.get(key);
    }

    public static void queryTextRenderLayer(Identifier key, RenderLayer renderLayer) {
//        Identifier newKey = Identifier.of(key.getNamespace(), key.getPath().substring(0, key.getPath().lastIndexOf("/") - 1)); // Cutting the font id short for simplicity
        BUILT_TEXT_RENDER_LAYERS.put(key, renderLayer);
    }

    // ------------------ GENERAL Layering -----------------------------------------------------------------------------------------------------------------------------------------------------------------------

    public static class Layering {
        public static RenderPhase.Layering getRenderPhaseZLayeringBackward(float zOffset) {
            return new RenderPhase.Layering("view_offset_z_layering_backward", () -> {
                Matrix4fStack matrix4fStack = RenderSystem.getModelViewStack();
                matrix4fStack.pushMatrix();
                RenderSystem.getProjectionType().apply(matrix4fStack, zOffset);
            },
                    () -> {
                        Matrix4fStack matrix4fStack = RenderSystem.getModelViewStack();
                        matrix4fStack.popMatrix();
                    }
            );
        }
    }

    // ------------------ Image Layering -----------------------------------------------------------------------------------------------------------------------------------------------------------------------

    public static class ImageLayering {

        private float zOffset;

        public ImageLayering(float zOffset) {
            this.zOffset = zOffset;
        }

        private final Function<Identifier, RenderLayer> ENTITY_SOLID_Z_OFFSET_BACKWARD = Util.memoize(
                texture -> {
                    RenderLayer.MultiPhaseParameters multiPhaseParameters = RenderLayer.MultiPhaseParameters.builder()
                            .program(RenderPhase.ENTITY_SOLID_PROGRAM)
                            .texture(new RenderPhase.Texture(texture, TriState.FALSE, false))
                            .transparency(RenderLayer.NO_TRANSPARENCY)
                            .lightmap(ENABLE_LIGHTMAP)
                            .overlay(RenderPhase.ENABLE_OVERLAY_COLOR)
                            .layering(CustomRenderLayer.Layering.getRenderPhaseZLayeringBackward(zOffset))
                            .build(true);

                    return RenderLayer.of(
                            "entity_solid_z_offset_backward",
                            VertexFormats.POSITION_COLOR_TEXTURE_OVERLAY_LIGHT_NORMAL,
                            VertexFormat.DrawMode.QUADS,
                            1536,
                            true,
                            false,
                            multiPhaseParameters
                    );
                }
        );

        public static RenderLayer build(LayeringType layeringType, Identifier texture, float zOffset) {
            ImageLayering layering = new ImageLayering(zOffset);

            return switch (layeringType) {
                case VIEW_OFFSET_Z_LAYERING_BACKWARD -> layering.ENTITY_SOLID_Z_OFFSET_BACKWARD.apply(texture);
            };
        }

        public enum LayeringType {
            VIEW_OFFSET_Z_LAYERING_BACKWARD
        }
    }

    // ------------------ Text Layering -----------------------------------------------------------------------------------------------------------------------------------------------------------------------

    public static class TextLayering {

        private float zOffset;
        RenderLayer renderLayer;

        public TextLayering(float zOffset) {
            this.zOffset = zOffset;
        }

        private final Function<Identifier, RenderLayer> TEXT_Z_OFFSET_BACKWARD = Util.memoize(
                texture -> RenderLayer.of(
                        "text_z_offset_backward",
                        VertexFormats.POSITION_COLOR_TEXTURE_LIGHT,
                        VertexFormat.DrawMode.QUADS,
                        786432,
                        false,
                        false,
                        RenderLayer.MultiPhaseParameters.builder()
                                .program(TEXT_PROGRAM)
                                .texture(new RenderPhase.Texture(texture, TriState.FALSE, false))
                                .transparency(TRANSLUCENT_TRANSPARENCY)
                                .lightmap(ENABLE_LIGHTMAP)
                                .layering(CustomRenderLayer.Layering.getRenderPhaseZLayeringBackward(zOffset))
                                .build(false)
                )
        );

        public RenderLayer build(LayeringType layeringType, Identifier texture, float zOffset) {
            this.zOffset = zOffset;
            this.renderLayer =  switch (layeringType) {
                case VIEW_OFFSET_Z_LAYERING_BACKWARD -> TEXT_Z_OFFSET_BACKWARD.apply(texture);
            };

            queryTextRenderLayer(texture, renderLayer);

            return this.renderLayer;
        }

        public RenderLayer getRenderLayer() {
            return renderLayer;
        }

        public enum LayeringType {
            VIEW_OFFSET_Z_LAYERING_BACKWARD
        }

        public static final Function<Identifier, RenderLayer> TEST_TEXT_RENDER_LAYER = Util.memoize(
                texture -> RenderLayer.of(
                        "text_z_offset_backward",
                        VertexFormats.POSITION_COLOR_TEXTURE_LIGHT,
                        VertexFormat.DrawMode.QUADS,
                        786432,
                        false,
                        false,
                        RenderLayer.MultiPhaseParameters.builder()
                                .program(TEXT_PROGRAM)
                                .texture(new RenderPhase.Texture(texture, TriState.FALSE, false))
                                .transparency(TRANSLUCENT_TRANSPARENCY)
                                .lightmap(ENABLE_LIGHTMAP)
                                .layering(CustomRenderLayer.Layering.getRenderPhaseZLayeringBackward(2.0f))
                                .build(false)
                )
        );

        // Just for testing purposes
        public static RenderLayer getTextRenderLayer(Identifier id) {
            return TEST_TEXT_RENDER_LAYER.apply(id);
        }
    }
}