Рендеринг в мире (Rendering in the World) 26.1.2

Создавайте собственные конвейеры рендеринга, если стандартные вам не подходят.

WARNING

Эта страница написана для версии 26.1.2. Документация для более старых версий может быть неполной.

ТРЕБОВАНИЯ

Перед началом обязательно прочитайте Rendering Concepts. Эта страница опирается на изложенные там идеи и объясняет, как рендерить объекты в мире.

Здесь рассматриваются современные концепции рендеринга. Вы узнаете о двух разделённых фазах рендеринга — «извлечение» (или подготовка) и «отрисовка» (рендеринг). В этом руководстве мы будем использовать термины фаза извлечения (extraction) и фаза отрисовки (drawing).

Чтобы отрендерить собственные объекты в мире, есть два варианта. Внедриться в существующий ванильный рендеринг и добавить свой код (но это ограничит тебя существующими конвейерами рендеринга). Если стандартные конвейеры рендеринга вам не подходят, создайте свой собственный.

Перед тем как перейти к созданию собственных конвейеров рендеринга, посмотрим, как работает стандартный (ванильный) рендеринг.

Фазы извлечения и отрисовки

Как упоминалось в Rendering Concepts, в последних версиях Minecraft процесс рендеринга разделяется на две фазы: извлечение (extraction) и отрисовка (drawing).

Во время фазы извлечения собираются все данные, необходимые для рендеринга. Оно включает, например, доступ к данным мира. Даже если метод начинается с draw или render, он всё равно должен вызываться во время фазы извлечения. Именно на этом этапе нужно добавлять все элементы, которые ты хочешь отрисовать.

Когда фаза извлечения завершена, начинается фаза отрисовки, в которой собранный буфер строится и выводится на экран. Во время этой фазы содержимое буфера выводится на экран. Цель разделения этих фаз — позволить игре отрисовывать предыдущий кадр параллельно с подготовкой следующего, повышая производительность.

Теперь, понимая эти две фазы, перейдём к созданию собственного конвейера рендеринга.

Пользовательские конвейеры рендеринга

Предположим, мы хотим отрендерить точки (waypoints), которые должны быть видны сквозь стены. Ближе всего к этому подходит ванильный конвейер RenderPipelines#DEBUG_FILLED_BOX, но он не рендерит сквозь стены, поэтому нужно создать свой.

Определение пользовательского конвейера

Создаём класс, определяющий наш конвейер рендеринга:

java

private static final RenderPipeline FILLED_THROUGH_WALLS = RenderPipelines.register(RenderPipeline.builder(RenderPipelines.DEBUG_FILLED_SNIPPET)
		.withLocation(Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, "pipeline/debug_filled_box_through_walls"))
		.withDepthStencilState(Optional.empty())
		.build()
);

Фаза извлечения

Реализуем фазу извлечения. Эта часть кода вызывается во время фазы извлечения, чтобы добавить waypoint для рендеринга:

java

private static WaypointRenderState waypointState;

private void extractWaypoint(LevelExtractionContext context) {
	// Access data from the world or anything here in the extraction phase.
	// You can only access the (immutable and thread safe) render state in the drawing phase.
	waypointState = new WaypointRenderState(0, 100, 0, 0f, 1f, 0f, 0.5f);
}

// Render states should be immutable, thread safe, and fast to create.
private record WaypointRenderState(int x, int y, int z, float r, float g, float b, float a) { }

Если вы хотите рендерить несколько точек, измените waypointState в лист и добавьте некоторые состояния отображения этих меток. Главное — делай это во время фазы извлечения, до начала отрисовки.

Состояния рендеринга

Заметьте, что в коде ниже мы сохраняем WaypointRenderState в поле. Это нужно, чтобы использовать его на этапе отрисовки. В таком случае, WaypointRenderState - это "состояние отображения" или "извлечённые данные". Если вам требуются дополнительные данные (то-есть из мира) во время фазы "прорисовки", то вам надо добавить это в ваш класс кастомного рендера.

Фаза отрисовки

Теперь реализуем фазу отрисовки. Эту функцию следует вызывать после того, как все точки, которые вы хотите отобразить, будут добавлены в waypointState на этапе "извлечения".

java

private static final ByteBufferBuilder ALLOCATOR = new ByteBufferBuilder(RenderType.SMALL_BUFFER_SIZE);
private static final Vector4f COLOR_MODULATOR = new Vector4f(1f, 1f, 1f, 1f);
private static final Vector3f MODEL_OFFSET = new Vector3f();
private static final Matrix4f TEXTURE_MATRIX = new Matrix4f();
private BufferBuilder buffer;
private MappableRingBuffer vertexBuffer;

private void renderAndDrawWaypoint(LevelRenderContext context) {
	this.renderWaypoint(context);
	this.drawFilledThroughWalls(Minecraft.getInstance(), FILLED_THROUGH_WALLS);
}

private void renderWaypoint(LevelRenderContext context) {
	PoseStack matrices = context.poseStack();
	Vec3 camera = context.levelState().cameraRenderState.pos;

	matrices.pushPose();
	matrices.translate(-camera.x, -camera.y, -camera.z);

	if (this.buffer == null) {
		this.buffer = new BufferBuilder(ALLOCATOR, FILLED_THROUGH_WALLS.getVertexFormatMode(), FILLED_THROUGH_WALLS.getVertexFormat());
	}

	this.renderFilledBox(matrices.last().pose(), this.buffer, waypointState.x(), waypointState.y(), waypointState.z(), waypointState.x() + 1, waypointState.y() + 1, waypointState.z() + 1, waypointState.r(), waypointState.g(), waypointState.b(), waypointState.a());

	matrices.popPose();
}

private void renderFilledBox(Matrix4fc positionMatrix, BufferBuilder buffer, float minX, float minY, float minZ, float maxX, float maxY, float maxZ, float red, float green, float blue, float alpha) {
	// Front Face
	buffer.addVertex(positionMatrix, minX, minY, maxZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, minY, maxZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, maxY, maxZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, minX, maxY, maxZ).setColor(red, green, blue, alpha);

	// Back face
	buffer.addVertex(positionMatrix, maxX, minY, minZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, minX, minY, minZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, minX, maxY, minZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, maxY, minZ).setColor(red, green, blue, alpha);

	// Left face
	buffer.addVertex(positionMatrix, minX, minY, minZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, minX, minY, maxZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, minX, maxY, maxZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, minX, maxY, minZ).setColor(red, green, blue, alpha);

	// Right face
	buffer.addVertex(positionMatrix, maxX, minY, maxZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, minY, minZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, maxY, minZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, maxY, maxZ).setColor(red, green, blue, alpha);

	// Top face
	buffer.addVertex(positionMatrix, minX, maxY, maxZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, maxY, maxZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, maxY, minZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, minX, maxY, minZ).setColor(red, green, blue, alpha);

	// Bottom face
	buffer.addVertex(positionMatrix, minX, minY, minZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, minY, minZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, maxX, minY, maxZ).setColor(red, green, blue, alpha);
	buffer.addVertex(positionMatrix, minX, minY, maxZ).setColor(red, green, blue, alpha);
}

private void drawFilledThroughWalls(Minecraft client, @SuppressWarnings("SameParameterValue") RenderPipeline pipeline) {
	// Build the buffer
	MeshData builtBuffer = this.buffer.buildOrThrow();
	MeshData.DrawState drawParameters = builtBuffer.drawState();
	VertexFormat format = drawParameters.format();

	GpuBuffer vertices = this.upload(drawParameters, format, builtBuffer);

	draw(client, pipeline, builtBuffer, drawParameters, vertices, format);

	// Rotate the vertex buffer so we are less likely to use buffers that the GPU is using
	this.vertexBuffer.rotate();
	this.buffer = null;
}

private GpuBuffer upload(MeshData.DrawState drawParameters, VertexFormat format, MeshData builtBuffer) {
	// Calculate the size needed for the vertex buffer
	int vertexBufferSize = drawParameters.vertexCount() * format.getVertexSize();

	// Initialize or resize the vertex buffer as needed
	if (this.vertexBuffer == null || this.vertexBuffer.size() < vertexBufferSize) {
		if (this.vertexBuffer != null) {
			this.vertexBuffer.close();
		}

		this.vertexBuffer = new MappableRingBuffer(() -> ExampleMod.MOD_ID + " example render pipeline", GpuBuffer.USAGE_VERTEX | GpuBuffer.USAGE_MAP_WRITE, vertexBufferSize);
	}

	// Copy vertex data into the vertex buffer
	CommandEncoder commandEncoder = RenderSystem.getDevice().createCommandEncoder();

	try (GpuBuffer.MappedView mappedView = commandEncoder.mapBuffer(this.vertexBuffer.currentBuffer().slice(0, builtBuffer.vertexBuffer().remaining()), false, true)) {
		MemoryUtil.memCopy(builtBuffer.vertexBuffer(), mappedView.data());
	}

	return this.vertexBuffer.currentBuffer();
}

private static void draw(Minecraft client, RenderPipeline pipeline, MeshData builtBuffer, MeshData.DrawState drawParameters, GpuBuffer vertices, VertexFormat format) {
	GpuBuffer indices;
	VertexFormat.IndexType indexType;

	if (pipeline.getVertexFormatMode() == VertexFormat.Mode.QUADS) {
		// Sort the quads if there is translucency
		builtBuffer.sortQuads(ALLOCATOR, RenderSystem.getProjectionType().vertexSorting());
		// Upload the index buffer
		indices = pipeline.getVertexFormat().uploadImmediateIndexBuffer(builtBuffer.indexBuffer());
		indexType = builtBuffer.drawState().indexType();
	} else {
		// Use the general shape index buffer for non-quad draw modes
		RenderSystem.AutoStorageIndexBuffer shapeIndexBuffer = RenderSystem.getSequentialBuffer(pipeline.getVertexFormatMode());
		indices = shapeIndexBuffer.getBuffer(drawParameters.indexCount());
		indexType = shapeIndexBuffer.type();
	}

	// Actually execute the draw
	GpuBufferSlice dynamicTransforms = RenderSystem.getDynamicUniforms()
			.writeTransform(RenderSystem.getModelViewMatrix(), COLOR_MODULATOR, MODEL_OFFSET, TEXTURE_MATRIX);
	try (RenderPass renderPass = RenderSystem.getDevice()
			.createCommandEncoder()
			.createRenderPass(() -> ExampleMod.MOD_ID + " example render pipeline rendering", client.getMainRenderTarget().getColorTextureView(), OptionalInt.empty(), client.getMainRenderTarget().getDepthTextureView(), OptionalDouble.empty())) {
		renderPass.setPipeline(pipeline);

		RenderSystem.bindDefaultUniforms(renderPass);
		renderPass.setUniform("DynamicTransforms", dynamicTransforms);

		// Bind texture if applicable:
		// Sampler0 is used for texture inputs in vertices
		// renderPass.bindTexture("Sampler0", textureSetup.texure0(), textureSetup.sampler0());

		renderPass.setVertexBuffer(0, vertices);
		renderPass.setIndexBuffer(indices, indexType);

		// The base vertex is the starting index when we copied the data into the vertex buffer divided by vertex size
		//noinspection ConstantValue
		renderPass.drawIndexed(0 / format.getVertexSize(), 0, drawParameters.indexCount(), 1);
	}

	builtBuffer.close();
}

Размер, используемый в конструкторе ByteBufferBuilder зависит от отображения конвейера, которого вы используете. В таком случае, это RenderType.SMALL_BUFFER_SIZE.

Очистка

Не забудь освободить ресурсы при закрытии рендерера игры. Метод GameRenderer#close должен вызывать очистку, для этого нужно внедриться (inject) в GameRenderer#close с помощью Mixin.

java

public void close() {
	ALLOCATOR.close();

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

java

package com.example.docs.mixin.client;

import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;

import net.minecraft.client.renderer.GameRenderer;

import com.example.docs.rendering.CustomRenderPipeline;

@Mixin(GameRenderer.class)
public class GameRendererMixin {
	@Inject(method = "close", at = @At("RETURN"))
	private void onGameRendererClose(CallbackInfo ci) {
		CustomRenderPipeline.getInstance().close();
	}
}

Итоговый код

Объединив все шаги выше, получаем простой класс, который рендерит точку (waypoint) в координатах (0, 100, 0) через стены.

java

package com.example.docs.rendering;

import java.util.Optional;
import java.util.OptionalDouble;
import java.util.OptionalInt;

import com.mojang.blaze3d.buffers.GpuBuffer;
import com.mojang.blaze3d.buffers.GpuBufferSlice;
import com.mojang.blaze3d.pipeline.RenderPipeline;
import com.mojang.blaze3d.systems.CommandEncoder;
import com.mojang.blaze3d.systems.RenderPass;
import com.mojang.blaze3d.systems.RenderSystem;
import com.mojang.blaze3d.vertex.BufferBuilder;
import com.mojang.blaze3d.vertex.ByteBufferBuilder;
import com.mojang.blaze3d.vertex.MeshData;
import com.mojang.blaze3d.vertex.PoseStack;
import com.mojang.blaze3d.vertex.VertexFormat;
import org.joml.Matrix4f;
import org.joml.Matrix4fc;
import org.joml.Vector3f;
import org.joml.Vector4f;
import org.lwjgl.system.MemoryUtil;

import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.MappableRingBuffer;
import net.minecraft.client.renderer.RenderPipelines;
import net.minecraft.client.renderer.rendertype.RenderType;
import net.minecraft.resources.Identifier;
import net.minecraft.world.phys.Vec3;

import net.fabricmc.api.ClientModInitializer;
import net.fabricmc.fabric.api.client.rendering.v1.level.LevelExtractionContext;
import net.fabricmc.fabric.api.client.rendering.v1.level.LevelRenderContext;
import net.fabricmc.fabric.api.client.rendering.v1.level.LevelRenderEvents;

import com.example.docs.ExampleMod;

public class CustomRenderPipeline implements ClientModInitializer {
	private static CustomRenderPipeline instance;
	private static final RenderPipeline FILLED_THROUGH_WALLS = RenderPipelines.register(RenderPipeline.builder(RenderPipelines.DEBUG_FILLED_SNIPPET)
			.withLocation(Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, "pipeline/debug_filled_box_through_walls"))
			.withDepthStencilState(Optional.empty())
			.build()
	);
	private static WaypointRenderState waypointState;

	private static final ByteBufferBuilder ALLOCATOR = new ByteBufferBuilder(RenderType.SMALL_BUFFER_SIZE);
	private static final Vector4f COLOR_MODULATOR = new Vector4f(1f, 1f, 1f, 1f);
	private static final Vector3f MODEL_OFFSET = new Vector3f();
	private static final Matrix4f TEXTURE_MATRIX = new Matrix4f();
	private BufferBuilder buffer;
	private MappableRingBuffer vertexBuffer;

	public static CustomRenderPipeline getInstance() {
		return instance;
	}

	@Override
	public void onInitializeClient() {
		instance = this;
		LevelRenderEvents.END_EXTRACTION.register(this::extractWaypoint);
		LevelRenderEvents.AFTER_TRANSLUCENT_TERRAIN.register(this::renderAndDrawWaypoint);
	}

	private void extractWaypoint(LevelExtractionContext context) {
		// Access data from the world or anything here in the extraction phase.
		// You can only access the (immutable and thread safe) render state in the drawing phase.
		waypointState = new WaypointRenderState(0, 100, 0, 0f, 1f, 0f, 0.5f);
	}

	private void renderAndDrawWaypoint(LevelRenderContext context) {
		this.renderWaypoint(context);
		this.drawFilledThroughWalls(Minecraft.getInstance(), FILLED_THROUGH_WALLS);
	}

	private void renderWaypoint(LevelRenderContext context) {
		PoseStack matrices = context.poseStack();
		Vec3 camera = context.levelState().cameraRenderState.pos;

		matrices.pushPose();
		matrices.translate(-camera.x, -camera.y, -camera.z);

		if (this.buffer == null) {
			this.buffer = new BufferBuilder(ALLOCATOR, FILLED_THROUGH_WALLS.getVertexFormatMode(), FILLED_THROUGH_WALLS.getVertexFormat());
		}

		this.renderFilledBox(matrices.last().pose(), this.buffer, waypointState.x(), waypointState.y(), waypointState.z(), waypointState.x() + 1, waypointState.y() + 1, waypointState.z() + 1, waypointState.r(), waypointState.g(), waypointState.b(), waypointState.a());

		matrices.popPose();
	}

	private void renderFilledBox(Matrix4fc positionMatrix, BufferBuilder buffer, float minX, float minY, float minZ, float maxX, float maxY, float maxZ, float red, float green, float blue, float alpha) {
		// Front Face
		buffer.addVertex(positionMatrix, minX, minY, maxZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, minY, maxZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, maxY, maxZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, minX, maxY, maxZ).setColor(red, green, blue, alpha);

		// Back face
		buffer.addVertex(positionMatrix, maxX, minY, minZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, minX, minY, minZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, minX, maxY, minZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, maxY, minZ).setColor(red, green, blue, alpha);

		// Left face
		buffer.addVertex(positionMatrix, minX, minY, minZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, minX, minY, maxZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, minX, maxY, maxZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, minX, maxY, minZ).setColor(red, green, blue, alpha);

		// Right face
		buffer.addVertex(positionMatrix, maxX, minY, maxZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, minY, minZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, maxY, minZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, maxY, maxZ).setColor(red, green, blue, alpha);

		// Top face
		buffer.addVertex(positionMatrix, minX, maxY, maxZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, maxY, maxZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, maxY, minZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, minX, maxY, minZ).setColor(red, green, blue, alpha);

		// Bottom face
		buffer.addVertex(positionMatrix, minX, minY, minZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, minY, minZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, maxX, minY, maxZ).setColor(red, green, blue, alpha);
		buffer.addVertex(positionMatrix, minX, minY, maxZ).setColor(red, green, blue, alpha);
	}

	private void drawFilledThroughWalls(Minecraft client, @SuppressWarnings("SameParameterValue") RenderPipeline pipeline) {
		// Build the buffer
		MeshData builtBuffer = this.buffer.buildOrThrow();
		MeshData.DrawState drawParameters = builtBuffer.drawState();
		VertexFormat format = drawParameters.format();

		GpuBuffer vertices = this.upload(drawParameters, format, builtBuffer);

		draw(client, pipeline, builtBuffer, drawParameters, vertices, format);

		// Rotate the vertex buffer so we are less likely to use buffers that the GPU is using
		this.vertexBuffer.rotate();
		this.buffer = null;
	}

	private GpuBuffer upload(MeshData.DrawState drawParameters, VertexFormat format, MeshData builtBuffer) {
		// Calculate the size needed for the vertex buffer
		int vertexBufferSize = drawParameters.vertexCount() * format.getVertexSize();

		// Initialize or resize the vertex buffer as needed
		if (this.vertexBuffer == null || this.vertexBuffer.size() < vertexBufferSize) {
			if (this.vertexBuffer != null) {
				this.vertexBuffer.close();
			}

			this.vertexBuffer = new MappableRingBuffer(() -> ExampleMod.MOD_ID + " example render pipeline", GpuBuffer.USAGE_VERTEX | GpuBuffer.USAGE_MAP_WRITE, vertexBufferSize);
		}

		// Copy vertex data into the vertex buffer
		CommandEncoder commandEncoder = RenderSystem.getDevice().createCommandEncoder();

		try (GpuBuffer.MappedView mappedView = commandEncoder.mapBuffer(this.vertexBuffer.currentBuffer().slice(0, builtBuffer.vertexBuffer().remaining()), false, true)) {
			MemoryUtil.memCopy(builtBuffer.vertexBuffer(), mappedView.data());
		}

		return this.vertexBuffer.currentBuffer();
	}

	private static void draw(Minecraft client, RenderPipeline pipeline, MeshData builtBuffer, MeshData.DrawState drawParameters, GpuBuffer vertices, VertexFormat format) {
		GpuBuffer indices;
		VertexFormat.IndexType indexType;

		if (pipeline.getVertexFormatMode() == VertexFormat.Mode.QUADS) {
			// Sort the quads if there is translucency
			builtBuffer.sortQuads(ALLOCATOR, RenderSystem.getProjectionType().vertexSorting());
			// Upload the index buffer
			indices = pipeline.getVertexFormat().uploadImmediateIndexBuffer(builtBuffer.indexBuffer());
			indexType = builtBuffer.drawState().indexType();
		} else {
			// Use the general shape index buffer for non-quad draw modes
			RenderSystem.AutoStorageIndexBuffer shapeIndexBuffer = RenderSystem.getSequentialBuffer(pipeline.getVertexFormatMode());
			indices = shapeIndexBuffer.getBuffer(drawParameters.indexCount());
			indexType = shapeIndexBuffer.type();
		}

		// Actually execute the draw
		GpuBufferSlice dynamicTransforms = RenderSystem.getDynamicUniforms()
				.writeTransform(RenderSystem.getModelViewMatrix(), COLOR_MODULATOR, MODEL_OFFSET, TEXTURE_MATRIX);
		try (RenderPass renderPass = RenderSystem.getDevice()
				.createCommandEncoder()
				.createRenderPass(() -> ExampleMod.MOD_ID + " example render pipeline rendering", client.getMainRenderTarget().getColorTextureView(), OptionalInt.empty(), client.getMainRenderTarget().getDepthTextureView(), OptionalDouble.empty())) {
			renderPass.setPipeline(pipeline);

			RenderSystem.bindDefaultUniforms(renderPass);
			renderPass.setUniform("DynamicTransforms", dynamicTransforms);

			// Bind texture if applicable:
			// Sampler0 is used for texture inputs in vertices
			// renderPass.bindTexture("Sampler0", textureSetup.texure0(), textureSetup.sampler0());

			renderPass.setVertexBuffer(0, vertices);
			renderPass.setIndexBuffer(indices, indexType);

			// The base vertex is the starting index when we copied the data into the vertex buffer divided by vertex size
			//noinspection ConstantValue
			renderPass.drawIndexed(0 / format.getVertexSize(), 0, drawParameters.indexCount(), 1);
		}

		builtBuffer.close();
	}

	public void close() {
		ALLOCATOR.close();

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

	// Render states should be immutable, thread safe, and fast to create.
	private record WaypointRenderState(int x, int y, int z, float r, float g, float b, float a) { }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222

Не забудь добавить GameRendererMixin! Вот результат:

Создание вашего первого предмета

Сущности блока

Генерация модели

Генерация мира

Переход на версию 26.1

Миграция маппингов

Авторы страницы

Ссылки на файлы

Авторы страницы

Рендеринг в мире (Rendering in the World) 26.1.2

Фазы извлечения и отрисовки

Пользовательские конвейеры рендеринга

Определение пользовательского конвейера

Фаза извлечения

Состояния рендеринга

Фаза отрисовки

Очистка

Итоговый код

Авторы страницы

Ссылки на файлы

Авторы страницы

Рендеринг в мире (Rendering in the World) 26.1.2 ​

Фазы извлечения и отрисовки ​

Пользовательские конвейеры рендеринга ​

Определение пользовательского конвейера ​

Фаза извлечения ​

Состояния рендеринга ​

Фаза отрисовки ​

Очистка ​

Итоговый код ​

Рендеринг в мире (Rendering in the World) 26.1.2

Фазы извлечения и отрисовки

Пользовательские конвейеры рендеринга

Определение пользовательского конвейера

Фаза извлечения

Состояния рендеринга

Фаза отрисовки

Очистка

Итоговый код