现代Minecraft渲染导论 第四章：后现代Minecraft渲染架构(26.1+)

RenderSystem.setShader(...)
RenderSystem.setShaderTexture(0, texture)

val builder = Tesselator.getInstance().builder
builder.begin(...)
// vertex(...)
val mesh = builder.end()
BufferUploader.drawWithShader(mesh)

public class GuiGraphics implements net.neoforged.neoforge.client.extensions.IGuiGraphicsExtension {
    final Minecraft minecraft;
    private final Matrix3x2fStack pose;
    private final GuiGraphics.ScissorStack scissorStack = new GuiGraphics.ScissorStack();
    private final MaterialSet materials;
    private final TextureAtlas guiSprites;
    final GuiRenderState guiRenderState;

    private GuiGraphics(Minecraft minecraft, Matrix3x2fStack pose, GuiRenderState guiRenderState, int mouseX, int mouseY) {
        this.minecraft = minecraft;
        this.pose = pose;
        this.guiRenderState = guiRenderState;
    }

    public GuiGraphics(Minecraft minecraft, GuiRenderState guiRenderState, int mouseX, int mouseY) {
        this(minecraft, new Matrix3x2fStack(16), guiRenderState, mouseX, mouseY);
    }
}

public Matrix3x2fStack pose() {
    return this.pose;
}

public void fill(int minX, int minY, int maxX, int maxY, int color) {
    this.fill(RenderPipelines.GUI, minX, minY, maxX, maxY, color);
}

public void fill(RenderPipeline pipeline, int minX, int minY, int maxX, int maxY, int color) {
    this.submitColoredRectangle(pipeline, TextureSetup.noTexture(), minX, minY, maxX, maxY, color, null);
}

private void submitColoredRectangle(
    RenderPipeline pipeline,
    TextureSetup textureSetup,
    int minX,
    int minY,
    int maxX,
    int maxY,
    int colorFrom,
    @Nullable Integer colorTo
) {
    this.guiRenderState.submitGuiElement(
        new ColoredRectangleRenderState(
            pipeline,
            textureSetup,
            new Matrix3x2f(this.pose),
            minX,
            minY,
            maxX,
            maxY,
            colorFrom,
            colorTo != null ? colorTo : colorFrom,
            this.scissorStack.peek()
        )
    );
}

public void drawString(Font font, FormattedCharSequence text, int x, int y, int color, boolean drawShadow) {
    if (ARGB.alpha(color) != 0) {
        this.guiRenderState.submitText(
            new GuiTextRenderState(
                font, text, new Matrix3x2f(this.pose), x, y, color, 0, drawShadow, false, this.scissorStack.peek()
            )
        );
    }
}

public Font.PreparedText ensurePrepared() {
    if (this.preparedText == null) {
        this.preparedText = this.font.prepareText(this.text, this.x, this.y, this.color, this.dropShadow, this.includeEmpty, this.backgroundColor);
        ScreenRectangle screenrectangle = this.preparedText.bounds();
        if (screenrectangle != null) {
            screenrectangle = screenrectangle.transformMaxBounds(this.pose);
            this.bounds = this.scissor != null ? this.scissor.intersection(screenrectangle) : screenrectangle;
        }
    }

    return this.preparedText;
}

private void renderItem(@Nullable LivingEntity entity, @Nullable Level level, ItemStack stack, int x, int y, int seed) {
    if (!stack.isEmpty()) {
        TrackingItemStackRenderState trackingitemstackrenderstate = new TrackingItemStackRenderState();
        this.minecraft
            .getItemModelResolver()
            .updateForTopItem(trackingitemstackrenderstate, stack, ItemDisplayContext.GUI, level, entity, seed);

        this.guiRenderState.submitItem(
            new GuiItemRenderState(
                stack.getItem().getName().toString(),
                new Matrix3x2f(this.pose),
                trackingitemstackrenderstate,
                x,
                y,
                this.scissorStack.peek()
            )
        );
    }
}

public void enableScissor(int minX, int minY, int maxX, int maxY) {
    ScreenRectangle screenrectangle = new ScreenRectangle(minX, minY, maxX - minX, maxY - minY)
        .transformAxisAligned(this.pose);
    this.scissorStack.push(screenrectangle);
}

public void blitSprite(RenderPipeline pipeline, Identifier sprite, int x, int y, int width, int height, int color) {
    TextureAtlasSprite textureatlassprite = this.guiSprites.getSprite(sprite);
    GuiSpriteScaling guispritescaling = getSpriteScaling(textureatlassprite);
    switch (guispritescaling) {
        case GuiSpriteScaling.Stretch guispritescaling$stretch:
            this.blitSprite(pipeline, textureatlassprite, x, y, width, height, color);
            break;
        case GuiSpriteScaling.Tile guispritescaling$tile:
            this.blitTiledSprite(...);
            break;
        case GuiSpriteScaling.NineSlice guispritescaling$nineslice:
            this.blitNineSlicedSprite(...);
            break;
        default:
    }
}

public class GuiRenderState {
    private final List<GuiRenderState.Node> strata = new ArrayList<>();
    private int firstStratumAfterBlur = Integer.MAX_VALUE;
    private GuiRenderState.Node current;
    private final Set<Object> itemModelIdentities = new HashSet<>();
    private @Nullable ScreenRectangle lastElementBounds;

    public GuiRenderState() {
        this.nextStratum();
    }
}

public void nextStratum() {
    this.current = new GuiRenderState.Node(null);
    this.strata.add(this.current);
}

public void up() {
    if (this.current.up == null) {
        this.current.up = new GuiRenderState.Node(this.current);
    }

    this.current = this.current.up;
}

private boolean findAppropriateNode(ScreenArea screenArea) {
    ScreenRectangle screenrectangle = screenArea.bounds();
    if (screenrectangle == null) {
        return false;
    } else {
        if (this.lastElementBounds != null && this.lastElementBounds.encompasses(screenrectangle)) {
            this.up();
        } else {
            this.navigateToAboveHighestElementWithIntersectingBounds(screenrectangle);
        }

        this.lastElementBounds = screenrectangle;
        return true;
    }
}

private void navigateToAboveHighestElementWithIntersectingBounds(ScreenRectangle rectangle) {
    GuiRenderState.Node node = this.strata.getLast();

    while (node.up != null) {
        node = node.up;
    }

    boolean flag = false;

    while (!flag) {
        flag = this.hasIntersection(rectangle, node.elementStates)
            || this.hasIntersection(rectangle, node.itemStates)
            || this.hasIntersection(rectangle, node.textStates)
            || this.hasIntersection(rectangle, node.picturesInPictureStates);
        if (node.parent == null) {
            break;
        }

        if (!flag) {
            node = node.parent;
        }
    }

    this.current = node;
    if (flag) {
        this.up();
    }
}

static class Node {
    public @Nullable List<GuiElementRenderState> elementStates;
    public @Nullable List<GuiElementRenderState> glyphStates;
    public @Nullable List<GuiItemRenderState> itemStates;
    public @Nullable List<GuiTextRenderState> textStates;
    public @Nullable List<PictureInPictureRenderState> picturesInPictureStates;
}

public void forEachElement(Consumer<GuiElementRenderState> action, GuiRenderState.TraverseRange traverseRange) { ... }
public void forEachItem(Consumer<GuiItemRenderState> action) { ... }
public void forEachText(Consumer<GuiTextRenderState> action) { ... }
public void forEachPictureInPicture(Consumer<PictureInPictureRenderState> action) { ... }

public ScreenRectangle transformAxisAligned(Matrix3x2fc pose) {
    Vector2f v0 = pose.transformPosition(this.left(), this.top(), new Vector2f());
    Vector2f v1 = pose.transformPosition(this.right(), this.bottom(), new Vector2f());
    return new ScreenRectangle(Mth.floor(v0.x), Mth.floor(v0.y), Mth.floor(v1.x - v0.x), Mth.floor(v1.y - v0.y));
}

public ScreenRectangle transformMaxBounds(Matrix3x2fc pose) {
    Vector2f v0 = pose.transformPosition(this.left(), this.top(), new Vector2f());
    Vector2f v1 = pose.transformPosition(this.right(), this.top(), new Vector2f());
    Vector2f v2 = pose.transformPosition(this.left(), this.bottom(), new Vector2f());
    Vector2f v3 = pose.transformPosition(this.right(), this.bottom(), new Vector2f());
    float minX = Math.min(Math.min(v0.x(), v2.x()), Math.min(v1.x(), v3.x()));
    float maxX = Math.max(Math.max(v0.x(), v2.x()), Math.max(v1.x(), v3.x()));
    float minY = Math.min(Math.min(v0.y(), v2.y()), Math.min(v1.y(), v3.y()));
    float maxY = Math.max(Math.max(v0.y(), v2.y()), Math.max(v1.y(), v3.y()));
    return new ScreenRectangle(Mth.floor(minX), Mth.floor(minY), Mth.ceil(maxX - minX), Mth.ceil(maxY - minY));
}

public void enableScissor(int minX, int minY, int maxX, int maxY) {
    ScreenRectangle screenrectangle = new ScreenRectangle(minX, minY, maxX - minX, maxY - minY)
        .transformAxisAligned(this.pose);
    this.scissorStack.push(screenrectangle);
}

public class RenderPipeline {
    private final Identifier location;
    private final Identifier vertexShader;
    private final Identifier fragmentShader;
    private final ShaderDefines shaderDefines;
    private final List<String> samplers;
    private final List<RenderPipeline.UniformDescription> uniforms;
    private final DepthTestFunction depthTestFunction;
    private final PolygonMode polygonMode;
    private final boolean cull;
    private final Optional<BlendFunction> blendFunction;
    private final boolean writeColor;
    private final boolean writeAlpha;
    private final boolean writeDepth;
    private final VertexFormat vertexFormat;
    private final VertexFormat.Mode vertexFormatMode;
    private final float depthBiasScaleFactor;
    private final float depthBiasConstant;
    private final int sortKey;
}

public static class Builder {
    public RenderPipeline.Builder withLocation(String location) { ... }
    public RenderPipeline.Builder withFragmentShader(String fragmentShader) { ... }
    public RenderPipeline.Builder withVertexShader(String vertexShader) { ... }
    public RenderPipeline.Builder withShaderDefine(String flag) { ... }
    public RenderPipeline.Builder withShaderDefine(String key, float value) { ... }
    public RenderPipeline.Builder withSampler(String sampler) { ... }
    public RenderPipeline.Builder withUniform(String uniform, UniformType type) { ... }
    public RenderPipeline.Builder withDepthTestFunction(DepthTestFunction depthTestFunction) { ... }
    public RenderPipeline.Builder withCull(boolean cull) { ... }
    public RenderPipeline.Builder withBlend(BlendFunction blendFunction) { ... }
    public RenderPipeline.Builder withDepthWrite(boolean writeDepth) { ... }
    public RenderPipeline.Builder withVertexFormat(VertexFormat vertexFormat, VertexFormat.Mode vertexFormatMode) { ... }
}

public static RenderPipeline.Builder builder(RenderPipeline.Snippet... snippets) {
    RenderPipeline.Builder builder = new RenderPipeline.Builder();

    for (RenderPipeline.Snippet snippet : snippets) {
        builder.withSnippet(snippet);
    }

    return builder;
}

public static final RenderPipeline.Snippet PARTICLE_SNIPPET = RenderPipeline.builder(MATRICES_FOG_SNIPPET)
    .withVertexShader("core/particle")
    .withFragmentShader("core/particle")
    .withSampler("Sampler0")
    .withSampler("Sampler2")
    .withVertexFormat(DefaultVertexFormat.PARTICLE, VertexFormat.Mode.QUADS)
    .buildSnippet();

public static final RenderPipeline.Snippet GUI_SNIPPET = RenderPipeline.builder(MATRICES_PROJECTION_SNIPPET)
    .withVertexShader("core/gui")
    .withFragmentShader("core/gui")
    .withBlend(BlendFunction.TRANSLUCENT)
    .withVertexFormat(DefaultVertexFormat.POSITION_COLOR, VertexFormat.Mode.QUADS)
    .withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST)
    .buildSnippet();

public static final RenderPipeline.Snippet GUI_TEXTURED_SNIPPET = RenderPipeline.builder(MATRICES_PROJECTION_SNIPPET)
    .withVertexShader("core/position_tex_color")
    .withFragmentShader("core/position_tex_color")
    .withSampler("Sampler0")
    .withBlend(BlendFunction.TRANSLUCENT)
    .withVertexFormat(DefaultVertexFormat.POSITION_TEX_COLOR, VertexFormat.Mode.QUADS)
    .withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST)
    .buildSnippet();

public static final RenderPipeline.Snippet GUI_TEXT_SNIPPET = RenderPipeline.builder(TEXT_SNIPPET)
    .withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST)
    .buildSnippet();

public static final RenderPipeline.Snippet OUTLINE_SNIPPET = RenderPipeline.builder(MATRICES_PROJECTION_SNIPPET)
    .withVertexShader("core/rendertype_outline")
    .withFragmentShader("core/rendertype_outline")
    .withSampler("Sampler0")
    .withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST)
    .withDepthWrite(false)
    .withVertexFormat(DefaultVertexFormat.POSITION_TEX_COLOR, VertexFormat.Mode.QUADS)
    .buildSnippet();

public static final RenderPipeline GUI = register(RenderPipeline.builder(GUI_SNIPPET).withLocation("pipeline/gui").build());
public static final RenderPipeline GUI_TEXTURED = register(RenderPipeline.builder(GUI_TEXTURED_SNIPPET).withLocation("pipeline/gui_textured").build());
public static final RenderPipeline GUI_INVERT = register(
    RenderPipeline.builder(GUI_SNIPPET).withLocation("pipeline/gui_invert").withBlend(BlendFunction.INVERT).build()
);
public static final RenderPipeline GUI_TEXT_HIGHLIGHT = register(
    RenderPipeline.builder(GUI_SNIPPET).withLocation("pipeline/gui_text_highlight").withBlend(BlendFunction.ADDITIVE).build()
);

/**
 * Fired to allow mods to register custom {@linkplain RenderPipeline pipelines}.
 * This event is fired after the default Minecraft pipelines have been registered.
 */
public class RegisterRenderPipelinesEvent extends Event implements IModBusEvent {
    private final Consumer<RenderPipeline> registrar;

    public void registerPipeline(RenderPipeline pipeline) {
        registrar.accept(pipeline);
    }
}

public class TextureTarget extends RenderTarget {
    public TextureTarget(@Nullable String name, int width, int height, boolean useDepth) {
        this(name, width, height, useDepth, false);
    }

    public TextureTarget(@Nullable String name, int width, int height, boolean useDepth, boolean enableStencil) {
        super(name, useDepth, enableStencil);
        RenderSystem.assertOnRenderThread();
        this.resize(width, height);
    }
}

public abstract class RenderTarget {
    public int width;
    public int height;
    public final boolean useDepth;
    public final boolean useStencil;
    protected @Nullable GpuTexture colorTexture;
    protected @Nullable GpuTextureView colorTextureView;
    protected @Nullable GpuTexture depthTexture;
    protected @Nullable GpuTextureView depthTextureView;
}

public void createBuffers(int width, int height) {
    RenderSystem.assertOnRenderThread();
    GpuDevice device = RenderSystem.getDevice();

    if (this.useDepth) {
        this.depthTexture = device.createTexture(() -> this.label + " / Depth", 15, format, width, height, 1, 1);
        this.depthTextureView = device.createTextureView(this.depthTexture);
    }

    this.colorTexture = device.createTexture(() -> this.label + " / Color", 15, TextureFormat.RGBA8, width, height, 1, 1);
    this.colorTextureView = device.createTextureView(this.colorTexture);
}

public void destroyBuffers() {
    RenderSystem.assertOnRenderThread();
    if (this.depthTexture != null) {
        this.depthTexture.close();
        this.depthTexture = null;
    }
    if (this.depthTextureView != null) {
        this.depthTextureView.close();
        this.depthTextureView = null;
    }
    if (this.colorTexture != null) {
        this.colorTexture.close();
        this.colorTexture = null;
    }
    if (this.colorTextureView != null) {
        this.colorTextureView.close();
        this.colorTextureView = null;
    }
}

public void copyDepthFrom(RenderTarget otherTarget) {
    RenderSystem.getDevice()
        .createCommandEncoder()
        .copyTextureToTexture(otherTarget.depthTexture, this.depthTexture, 0, 0, 0, 0, 0, this.width, this.height);
}

public void blitAndBlendToTexture(GpuTextureView textureView) {
    try (RenderPass renderpass = RenderSystem.getDevice()
            .createCommandEncoder()
            .createRenderPass(() -> "Blit render target", textureView, OptionalInt.empty())) {
        renderpass.setPipeline(RenderPipelines.ENTITY_OUTLINE_BLIT);
        RenderSystem.bindDefaultUniforms(renderpass);
        renderpass.bindTexture("InSampler", this.colorTextureView, RenderSystem.getSamplerCache().getClampToEdge(FilterMode.NEAREST));
        renderpass.draw(0, 3);
    }
}

public abstract class GpuTextureView implements AutoCloseable {
    private final GpuTexture texture;
    private final int baseMipLevel;
    private final int mipLevels;

    public GpuTexture texture() {
        return this.texture;
    }

    public int baseMipLevel() {
        return this.baseMipLevel;
    }

    public int mipLevels() {
        return this.mipLevels;
    }

    public int getWidth(int mipLevel) {
        return this.texture.getWidth(mipLevel + this.baseMipLevel);
    }

    public int getHeight(int mipLevel) {
        return this.texture.getHeight(mipLevel + this.baseMipLevel);
    }

    public abstract boolean isClosed();
}

if (this.colorTextureView != null) {
    this.colorTextureView.close();
    this.colorTextureView = null;
}

public class FrameGraphBuilder {
    private final List<FrameGraphBuilder.InternalVirtualResource<?>> internalResources = new ArrayList<>();
    private final List<FrameGraphBuilder.ExternalResource<?>> externalResources = new ArrayList<>();
    private final List<FrameGraphBuilder.Pass> passes = new ArrayList<>();

    public FramePass addPass(String name) {
        FrameGraphBuilder.Pass pass = new FrameGraphBuilder.Pass(this.passes.size(), name);
        this.passes.add(pass);
        return pass;
    }

    public <T> ResourceHandle<T> importExternal(String name, T resource) {
        ...
    }

    public <T> ResourceHandle<T> createInternal(String name, ResourceDescriptor<T> descriptor) {
        ...
    }
}

static class Handle<T> implements ResourceHandle<T> {
    final FrameGraphBuilder.VirtualResource<T> holder;
    private final int version;
    final FrameGraphBuilder.@Nullable Pass createdBy;
    final BitSet readBy = new BitSet();
    private FrameGraphBuilder.@Nullable Handle<T> aliasedBy;

    @Override
    public T get() {
        return this.holder.get();
    }
}

public void execute(GraphicsResourceAllocator allocator, FrameGraphBuilder.Inspector inspector) {
    BitSet keep = this.identifyPassesToKeep();
    List<FrameGraphBuilder.Pass> ordered = new ArrayList<>(keep.cardinality());
    BitSet visiting = new BitSet(this.passes.size());

    for (FrameGraphBuilder.Pass pass : this.passes) {
        this.resolvePassOrder(pass, keep, visiting, ordered);
    }

    this.assignResourceLifetimes(ordered);

    for (FrameGraphBuilder.Pass pass : ordered) {
        ...
        pass.task.run();
        ...
    }
}

private BitSet identifyPassesToKeep() {
    for (FrameGraphBuilder.VirtualResource<?> virtualresource : this.externalResources) {
        FrameGraphBuilder.Pass pass = virtualresource.handle.createdBy;
        if (pass != null) {
            this.discoverAllRequiredPasses(pass, bitset, deque);
        }
    }

    for (FrameGraphBuilder.Pass pass : this.passes) {
        if (pass.disableCulling) {
            this.discoverAllRequiredPasses(pass, bitset, deque);
        }
    }
}

private void assignResourceLifetimes(Collection<FrameGraphBuilder.Pass> passes) {
    FrameGraphBuilder.Pass[] lastUsers = new FrameGraphBuilder.Pass[this.internalResources.size()];

    for (FrameGraphBuilder.Pass pass : passes) {
        for (int i = pass.requiredResourceIds.nextSetBit(0); i >= 0; i = pass.requiredResourceIds.nextSetBit(i + 1)) {
            FrameGraphBuilder.InternalVirtualResource<?> resource = this.internalResources.get(i);
            FrameGraphBuilder.Pass previous = lastUsers[i];
            lastUsers[i] = pass;
            if (previous == null) {
                pass.resourcesToAcquire.add(resource);
            } else {
                previous.resourcesToRelease.clear(i);
            }

            pass.resourcesToRelease.set(i);
        }
    }
}

public interface GpuDevice {
    CommandEncoder createCommandEncoder();

    GpuSampler createSampler(...);

    GpuTexture createTexture(...);

    GpuTextureView createTextureView(GpuTexture texture);

    GpuTextureView createTextureView(GpuTexture texture, int baseMipLevel, int mipLevels);

    GpuBuffer createBuffer(...);

    CompiledRenderPipeline precompilePipeline(RenderPipeline pipeline, @Nullable ShaderSource shaderSource);
}

public interface CommandEncoder {
    RenderPass createRenderPass(Supplier<String> debugGroup, GpuTextureView colorTexture, OptionalInt clearColor);

    void clearColorTexture(GpuTexture texture, int color);

    void writeToBuffer(GpuBufferSlice slice, ByteBuffer buffer);

    void writeToTexture(GpuTexture texture, NativeImage image);

    void copyTextureToTexture(GpuTexture source, GpuTexture destination, int mipLevel, int x, int y, int sourceX, int sourceY, int width, int height);

    void presentTexture(GpuTextureView texture);
}

public interface RenderPass extends AutoCloseable {
    void setPipeline(RenderPipeline pipeline);

    void bindTexture(String name, @Nullable GpuTextureView textureView, @Nullable GpuSampler sampler);

    void setUniform(String name, GpuBuffer buffer);

    void setViewport(int x, int y, int width, int height);

    void enableScissor(int x, int y, int width, int height);

    void setVertexBuffer(int index, GpuBuffer buffer);

    void setIndexBuffer(GpuBuffer indexBuffer, VertexFormat.IndexType indexType);

    void drawIndexed(int firstIndex, int index, int indexCount, int primCount);

    void draw(int firstIndex, int indexCount);
}