1.21.10 port

Author: ijustseen

MINECRAFT_1.21.10_GUIDE.md

@@ -50,6 +50,16 @@ Advanced Twitch chat integration for Minecraft. Show chat messages in 3D or as a
 ./gradlew build
 ```
 
+## Development
+
+For developers working on this mod:
+
+- **[MINECRAFT_1.21.10_GUIDE.md](MINECRAFT_1.21.10_GUIDE.md)** - Complete guide for Minecraft 1.21.10 update
+  - API changes and fixes
+  - Custom rendering system
+  - Usage examples
+  - Troubleshooting
+
 ## License
 
 MIT License. See `LICENSE` for details.

README.md

@@ -4,9 +4,9 @@ org.gradle.parallel=true
 
 # Fabric Properties
 # check these on https://fabricmc.net/develop
-minecraft_version=1.21.7
-yarn_mappings=1.21.7+build.6
-loader_version=0.16.14
+minecraft_version=1.21.10
+yarn_mappings=1.21.10+build.2
+loader_version=0.17.3
 loom_version=1.11-SNAPSHOT
 
 # Mod Properties
@@ -15,4 +15,4 @@ maven_group=takeyourminestream.modid
 archives_base_name=tyms
 
 # Dependencies
-fabric_version=0.129.0+1.21.7
+fabric_version=0.137.0+1.21.10

gradle.properties

@@ -138,7 +138,11 @@ public void render(DrawContext context, int mouseX, int mouseY, float delta) {
     }
 
     @Override
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+    public boolean mouseClicked(net.minecraft.client.gui.Click click, boolean rightClick) {
+        double mouseX = click.x();
+        double mouseY = click.y();
+        int button = click.button();
+        
         if (button == 0) {
             int top = 40;
             int bottom = this.height - 60;
@@ -175,7 +179,7 @@ public boolean mouseClicked(double mouseX, double mouseY, int button) {
                 y += LINE_HEIGHT;
             }
         }
-        return super.mouseClicked(mouseX, mouseY, button);
+        return super.mouseClicked(click, rightClick);
     }
 
     @Override

src/client/java/takeyourminestream/modid/BanwordConfigScreen.java

@@ -29,7 +29,7 @@ public void registerKeyBindings() {
             "key.takeyourminestream.openconfig",
             InputUtil.Type.KEYSYM,
             GLFW.GLFW_KEY_RIGHT_BRACKET, // Клавиша ']'
-            "category.takeyourminestream.general"
+            KeyBinding.Category.MISC
         ));
 
         // Обработка нажатия клавиш

src/client/java/takeyourminestream/modid/input/KeyBindingManager.java

@@ -20,7 +20,7 @@ public static Vec3d generateRandomPosition(MinecraftClient client) {
         }
 
         Random random = client.world.random;
-        Vec3d playerPos = client.player.getPos();
+        Vec3d playerPos = client.player.getEyePos();
 
         // Генерируем случайный угол и радиус
         double angle = random.nextDouble() * 2 * Math.PI;

src/client/java/takeyourminestream/modid/messages/MessagePosition.java

@@ -1,6 +1,6 @@
 package takeyourminestream.modid.messages;
 
-import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderEvents;
+import net.fabricmc.fabric.api.client.rendering.v1.world.WorldRenderEvents;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.font.TextRenderer;
 import net.minecraft.client.render.VertexConsumerProvider;
@@ -51,7 +51,7 @@ public MessageRenderer(MessageLifecycleManager lifecycleManager, MessageParticle
                 return;
             }
 
-            MatrixStack matrices = context.matrixStack();
+            MatrixStack matrices = context.matrices();
             TextRenderer textRenderer = client.textRenderer;
             VertexConsumerProvider consumers = context.consumers();
 

src/client/java/takeyourminestream/modid/messages/MessageRenderer.java

@@ -0,0 +1,23 @@
+package takeyourminestream.modid.mixin.client;
+
+import net.minecraft.client.render.GameRenderer;
+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 takeyourminestream.modid.rendering.CustomRenderPipeline;
+
+/**
+ * Mixin для очистки ресурсов кастомного рендер-пайплайна
+ */
+@Mixin(GameRenderer.class)
+public class GameRendererMixin {
+    
+    @Inject(method = "close", at = @At("TAIL"))
+    private void onClose(CallbackInfo ci) {
+        CustomRenderPipeline instance = CustomRenderPipeline.getInstance();
+        if (instance != null) {
+            instance.close();
+        }
+    }
+}

src/client/java/takeyourminestream/modid/mixin/client/GameRendererMixin.java

@@ -0,0 +1,199 @@
+package takeyourminestream.modid.rendering;
+
+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.platform.DepthTestFunction;
+import com.mojang.blaze3d.systems.CommandEncoder;
+import com.mojang.blaze3d.systems.RenderPass;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.VertexFormat;
+import org.joml.Vector3f;
+import org.joml.Vector4f;
+import org.lwjgl.system.MemoryUtil;
+
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gl.MappableRingBuffer;
+import net.minecraft.client.gl.RenderPipelines;
+import net.minecraft.client.render.BufferBuilder;
+import net.minecraft.client.render.BuiltBuffer;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexFormats;
+import net.minecraft.client.render.VertexRendering;
+import net.minecraft.client.util.BufferAllocator;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.Vec3d;
+
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.rendering.v1.world.WorldRenderContext;
+import net.fabricmc.fabric.api.client.rendering.v1.world.WorldRenderEvents;
+
+/**
+ * Пример кастомного рендер-пайплайна для Minecraft 1.21.1+
+ * Рендерит waypoint через стены
+ */
+public class CustomRenderPipeline implements ClientModInitializer {
+    private static CustomRenderPipeline instance;
+    
+    // Определяем кастомный рендер-пайплайн
+    private static final RenderPipeline FILLED_THROUGH_WALLS = RenderPipelines.register(
+        RenderPipeline.builder(RenderPipelines.POSITION_COLOR_SNIPPET)
+            .withLocation(Identifier.of("take-your-minestream", "pipeline/debug_filled_box_through_walls"))
+            .withVertexFormat(VertexFormats.POSITION_COLOR, VertexFormat.DrawMode.TRIANGLE_STRIP)
+            .withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST)
+            .build()
+    );
+    
+    // Фаза extraction
+    private static final BufferAllocator allocator = new BufferAllocator(RenderLayer.CUTOUT_BUFFER_SIZE);
+    private BufferBuilder buffer;
+    
+    // Фаза drawing
+    private static final Vector4f COLOR_MODULATOR = new Vector4f(1f, 1f, 1f, 1f);
+    private MappableRingBuffer vertexBuffer;
+
+    public static CustomRenderPipeline getInstance() {
+        return instance;
+    }
+
+    @Override
+    public void onInitializeClient() {
+        instance = this;
+        WorldRenderEvents.AFTER_ENTITIES.register(this::extractAndDrawWaypoint);
+    }
+
+    private void extractAndDrawWaypoint(WorldRenderContext context) {
+        renderWaypoint(context);
+        drawFilledThroughWalls(MinecraftClient.getInstance(), FILLED_THROUGH_WALLS);
+    }
+
+    /**
+     * Фаза extraction - добавляем waypoint в буфер
+     */
+    private void renderWaypoint(WorldRenderContext context) {
+        MatrixStack matrices = context.matrices();
+        MinecraftClient client = MinecraftClient.getInstance();
+        Vec3d camera = client.gameRenderer.getCamera().getPos();
+
+        assert matrices != null;
+        matrices.push();
+        matrices.translate(-camera.x, -camera.y, -camera.z);
+
+        if (buffer == null) {
+            buffer = new BufferBuilder(allocator, FILLED_THROUGH_WALLS.getVertexFormatMode(), FILLED_THROUGH_WALLS.getVertexFormat());
+        }
+
+        // Рендерим зеленый куб на координатах (0, 100, 0)
+        VertexRendering.drawFilledBox(matrices, buffer, 0f, 100f, 0f, 1f, 101f, 1f, 0f, 1f, 0f, 0.5f);
+
+        matrices.pop();
+    }
+
+    /**
+     * Фаза drawing - отрисовываем буфер на экран
+     */
+    private void drawFilledThroughWalls(MinecraftClient client, RenderPipeline pipeline) {
+        // Строим буфер
+        BuiltBuffer builtBuffer = buffer.end();
+        BuiltBuffer.DrawParameters drawParameters = builtBuffer.getDrawParameters();
+        VertexFormat format = drawParameters.format();
+
+        GpuBuffer vertices = upload(drawParameters, format, builtBuffer);
+
+        draw(client, pipeline, builtBuffer, drawParameters, vertices, format);
+
+        // Ротируем vertex buffer чтобы избежать конфликтов с GPU
+        vertexBuffer.rotate();
+        buffer = null;
+    }
+
+    private GpuBuffer upload(BuiltBuffer.DrawParameters drawParameters, VertexFormat format, BuiltBuffer builtBuffer) {
+        // Вычисляем размер vertex buffer
+        int vertexBufferSize = drawParameters.vertexCount() * format.getVertexSize();
+
+        // Инициализируем или изменяем размер vertex buffer
+        if (vertexBuffer == null || vertexBuffer.size() < vertexBufferSize) {
+            vertexBuffer = new MappableRingBuffer(
+                () -> "take-your-minestream example render pipeline", 
+                GpuBuffer.USAGE_VERTEX | GpuBuffer.USAGE_MAP_WRITE, 
+                vertexBufferSize
+            );
+        }
+
+        // Копируем данные вершин в vertex buffer
+        CommandEncoder commandEncoder = RenderSystem.getDevice().createCommandEncoder();
+
+        try (GpuBuffer.MappedView mappedView = commandEncoder.mapBuffer(
+                vertexBuffer.getBlocking().slice(0, builtBuffer.getBuffer().remaining()), false, true)) {
+            MemoryUtil.memCopy(builtBuffer.getBuffer(), mappedView.data());
+        }
+
+        return vertexBuffer.getBlocking();
+    }
+
+    private static void draw(MinecraftClient client, RenderPipeline pipeline, BuiltBuffer builtBuffer, 
+                           BuiltBuffer.DrawParameters drawParameters, GpuBuffer vertices, VertexFormat format) {
+        GpuBuffer indices;
+        VertexFormat.IndexType indexType;
+
+        if (pipeline.getVertexFormatMode() == VertexFormat.DrawMode.QUADS) {
+            // Сортируем квады если есть прозрачность
+            builtBuffer.sortQuads(allocator, RenderSystem.getProjectionType().getVertexSorter());
+            // Загружаем index buffer
+            indices = pipeline.getVertexFormat().uploadImmediateIndexBuffer(builtBuffer.getSortedBuffer());
+            indexType = builtBuffer.getDrawParameters().indexType();
+        } else {
+            // Используем общий shape index buffer для не-quad режимов
+            RenderSystem.ShapeIndexBuffer shapeIndexBuffer = RenderSystem.getSequentialBuffer(pipeline.getVertexFormatMode());
+            indices = shapeIndexBuffer.getIndexBuffer(drawParameters.indexCount());
+            indexType = shapeIndexBuffer.getIndexType();
+        }
+
+        // Выполняем отрисовку
+        GpuBufferSlice dynamicTransforms = RenderSystem.getDynamicUniforms()
+                .write(RenderSystem.getModelViewMatrix(), COLOR_MODULATOR, new Vector3f(), RenderSystem.getTextureMatrix(), 1f);
+        
+        try (RenderPass renderPass = RenderSystem.getDevice()
+                .createCommandEncoder()
+                .createRenderPass(
+                    () -> "take-your-minestream example render pipeline rendering", 
+                    client.getFramebuffer().getColorAttachmentView(), 
+                    OptionalInt.empty(), 
+                    client.getFramebuffer().getDepthAttachmentView(), 
+                    OptionalDouble.empty()
+                )) {
+            renderPass.setPipeline(pipeline);
+
+            RenderSystem.bindDefaultUniforms(renderPass);
+            renderPass.setUniform("DynamicTransforms", dynamicTransforms);
+
+            // Привязываем текстуру если нужно:
+            // Sampler0 используется для текстурных входов в вершинах
+            // renderPass.bindSampler("Sampler0", textureView);
+
+            renderPass.setVertexBuffer(0, vertices);
+            renderPass.setIndexBuffer(indices, indexType);
+
+            // Base vertex - это начальный индекс когда мы копировали данные в vertex buffer деленный на размер вершины
+            renderPass.drawIndexed(0 / format.getVertexSize(), 0, drawParameters.indexCount(), 1);
+        }
+
+        builtBuffer.close();
+    }
+
+    /**
+     * Очистка ресурсов - должна вызываться при закрытии GameRenderer
+     */
+    public void close() {
+        allocator.close();
+
+        if (vertexBuffer != null) {
+            vertexBuffer.close();
+            vertexBuffer = null;
+        }
+    }
+}