Fabric Wiki

User Tools

Site Tools

Trace:
zh_cn:tutorial:blockentityrenderers

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Next revision		Previous revision
zh_cn:tutorial:blockentityrenderers [2019/12/19 10:02] – created lightcolourzh_cn:tutorial:blockentityrenderers [2023/08/29 10:31] (current) – [例子] wjz_p
Line 1: Line 1:
-====== Rendering blocks and items dynamically using block entity renderers ======+====== 使用方块实体渲染器动态渲染方块和物品 ====== 
 +// 
 +这是本教程的 1.15 以上版本。对于 1.14 版本，请参见[[zh_cn:tutorial:1.14:blockentityrenderers|使用方块实体渲染器动态渲染方块和物品（1.14）]]。//
  
-//This is the 1.15 version of this tutorial. For the 1.14 version, see [[tutorial:1.14:blockentityrenderers|Rendering blocks and items dynamically using block entity renderers (1.14)]].// +阅读本教程之前，请确保您已[[blockentity|添加方块实体]]！ 
- +===== 介绍 ===== 
-Make sure you [[tutorial:blockentity|added a block entity]] before reading this tutorial!  +方块本身并不是那么有趣，只是在某个位置和某个大小保持静止直到损坏。我们可以使用方块实体渲染器（block entity renderer）更加动态地渲染与方块实体有关的物品和方块——在不同的位置、以不同的大小渲染多个物品。 
-===== Introduction ===== +===== 例子 ===== 
-Blocks by themselves aren't that interesting,  +在本教程中，我们将通过向其添加 ''BlockEntityRenderer'' 来构建所创建的方块实体。渲染器将显示一个唱片机，漂浮在方块上方，上下移动并旋转。
-they just stay static at a certain location and a certain size until broken. +
-We can use block entity renderers to render items and blocks associated with a block entity far more dynamically - render multiple different items,  +
-at differing locations and sizes, and more.   +
-===== Example ===== +
-In this tutorial we'll build off the block entity we created by adding a ''BlockEntityRenderer'' to it.  +
-The renderer will display a jukebox floating above the block, going up and down and spinning.  +
      
-The first thing we need to do is create our ''BlockEntityRenderer'' class:+我们需要做的第一件事是创建我们的 ''BlockEntityRenderer'' 类：
 <code java> <code java>
-public class MyBlockEntityRenderer extends BlockEntityRenderer<DemoBlockEntity> { +@Environment(EnvType.CLIENT) 
-    // A jukebox itemstack+public class DemoBlockEntityRenderer implements BlockEntityRenderer<DemoBlockEntity> { 
 +    // 唱片机物品堆
     private static ItemStack stack = new ItemStack(Items.JUKEBOX, 1);     private static ItemStack stack = new ItemStack(Items.JUKEBOX, 1);
          
-    public MyBlockEntityRenderer(BlockEntityRenderDispatcher dispatcher) { +    public DemoBlockEntityRenderer(BlockEntityRendererFactory.Context ctx) {}
-        super(dispatcher); +
-    }+
          
     @Override     @Override
Line 28: Line 23:
 } }
 </code> </code>
-We're going to need to register our ''BlockEntityRenderer'', but only for the client.  
-This wouldn't matter in a single-player setting, since the server runs in the same process as the client.  
-However, in a multiplayer setting, where the server runs in a different process than the client, the server code 
-has no concept of a "BlockEntityRenderer", and as a result would not accept registering one.  
-To run initialization code only for the client, we need to setup a ''client'' entrypoint.   
  
-Create a new class next to your main class that implements ''ClientModInitializer'':+我们将需要注册我们的 ''BlockEntityRenderer''，但仅针对客户端。在单人游戏设置中这无关紧要，因为服务器与客户端在同一进程中运行。但是，在多人游戏设置中，服务器在与客户端不同的进程中运行，服务器代码没有 ''BlockEntityRenderer'' 的概念，因此不接受注册。要仅为客户端运行初始化代码，我们需要设置一个 ''client'' 入口点（entrypoint）。 
 + 
 +在实现 ''ClientModInitializer'' 的主类旁边创建一个新类： 
 <code java> <code java>
 +@Environment(EnvType.CLIENT)
 public class ExampleModClient implements ClientModInitializer { public class ExampleModClient implements ClientModInitializer {
     @Override     @Override
     public void onInitializeClient() {     public void onInitializeClient() {
-        // Here we will put client-only registration code+        // 这里我们放置只在客户端注册的代码
     }     }
 } }
 </code> </code>
- +将此类设置为 ''fabric.mod.json'' 中的“client”入口点（根据需要修改路径）：
-Set this class as the ''client'' entrypoint in your ''fabric.mod.json'' (modify the path as needed):+
 <code javascript "fabric.mod.json"> <code javascript "fabric.mod.json">
 "entrypoints": { "entrypoints": {
Line 50: Line 43:
     "client": [     "client": [
       {       {
-        "value": "tutorial.path.to.ExampleModClient"+        "value": "net.fabricmc.example.ExampleModClient"
       }       }
     ]     ]
Line 56: Line 49:
 </code> </code>
  
-And register the ''BlockEntityRenderer'' in our ClientModInitializer:+在我们的 ClientModInitializer 中注册 ''BlockEntityRenderer''： 
 <code java> <code java>
-@Override +    @Override 
-public void onInitializeClient() { +    public void onInitializeClient() { 
-    BlockEntityRendererRegistry.INSTANCE.register(DEMO_BLOCK_ENTITY, MyBlockEntityRenderer::new); +        BlockEntityRendererRegistry.register(DEMO_BLOCK_ENTITY, DemoBlockEntityRenderer::new); 
-}+        //不行就试试BlockEntityRendererRegistry.INSTANCE.register(DEMO_BLOCK_ENTITY, DemoBlockEntityRenderer::new); 
 +    }
 </code> </code>
-We override the ''render'' method which gets called every frame(!), and in it we will do our rendering +我们重写在每一帧都会被调用的 ''render'' 方法，我们将在其中进行渲染——对于初学者，请调用 ''matrices.push();''，这在进行GL调用时是必需的（我们将在紧接之后进行）： 
- - for starters, call ''matrices.push();'' which is mandatory when doing GL calls (we will doing those right after):+
 <code java> <code java>
     public void render(DemoBlockEntity blockEntity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {     public void render(DemoBlockEntity blockEntity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {
Line 70: Line 65:
     }     }
 </code> </code>
-We then perform the movement of the jukebox (matrices.translate) and rotation (matrices.multiply). +然后，我们对唱片机进行平移（matrices.translate）和旋转（matrices.multiply）。平移分为两部分：将其平移到高于方块中心的 0.5、1.25 和 0.5。第二部分是变化的部分：y 值的偏移量。偏移量是任何给定帧的物品高度。每次我们都要重新计算，因为我们希望它可以动画上下跳跃。我们通过以下方式计算： 
-There are two parts to the translation: we translate it to 0.5, 1.25, and 0.5 which is above the center of our block.  +   *获取当前世界时间，该时间会随着时间而变化。 
-The second part is the part that changes: the offset in the y value. The offset is the height of the item for any given frame. +   *添加部分刻。（部分刻是一个小数值，代表最后一次完整刻和现在之间的时间间隔。我们使用此方法，要不然动画会抖动，因为每秒的刻数少于每秒的帧数。） 
-We recalculate this each time because we want it to be animating bouncing up and down. We calculate this by: +   *将其除以8以减慢运动速度。 
-  * Getting the current world time, which changes over time. +   *以正弦值产生介于-1和1之间的值，类似于[[https://www.electronicshub.org/wp-content/uploads/2015/07/11.jpg|正弦波]]。 
-  * Adding the partial ticks. (The partial ticks is a fractional value representing the amount of time that’s passed between the last full tick and now. We use this because otherwise the animation would be jittery because there are fewer ticks per second than frames per second.) +   * 将其除以4可垂直压缩正弦波，这样该物品不会过度上下移动。
-  * Dividing that by 8 to slow the movement down. +
-  * Taking the sine of that to produce a value that ranges between -1 and 1, like a [[https://www.electronicshub.org/wp-content/uploads/2015/07/11.jpg|sine wave]]. +
-  * Dividing that by 4 to compress the sine wave vertically so the item doesn’t move up and down as much.+
 <code java> <code java>
     public void render(DemoBlockEntity blockEntity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {     public void render(DemoBlockEntity blockEntity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {
         [...]         [...]
-        // Calculate the current offset in the y value+        // 计算当前y值的偏移
         double offset = Math.sin((blockEntity.getWorld().getTime() + tickDelta) / 8.0) / 4.0;         double offset = Math.sin((blockEntity.getWorld().getTime() + tickDelta) / 8.0) / 4.0;
-        // Move the item+        // 移动物品
         matrices.translate(0.5, 1.25 + offset, 0.5);         matrices.translate(0.5, 1.25 + offset, 0.5);
  
-        // Rotate the item +        // 旋转物品 
-        matrices.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion((blockEntity.getWorld().getTime() + tickDelta) * 4));+        matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees((blockEntity.getWorld().getTime() + tickDelta) * 4));
     }     }
 </code> </code>
-Finally, we will get the Minecraft 'ItemRenderer' and render the jukebox item by using ''renderItem''.  +最后，我们将获得 Minecraft 的 ''ItemRenderer''，并使用 ''renderItem'' 渲染唱片机物品。我们还将 ''ModelTransformation.Type.GROUND'' 传递给 ''renderItem''，因为我们希望有类似与物品置于地上的效果。尝试对此值进行试验，看看会发生什么（这是一个枚举）。在这些 GL 调用之后，我们还需要调用''matrices.pop();''：
-We also pass ''ModelTransformation.Type.GROUND'' to ''renderItem'' because we want a similiar effect to  +
-an item lying on the ground. Try experimenting with this value and see what happens (it's an enum).  +
-We also need to call ''matrices.pop();'' after these GL calls:+
 <code java> <code java>
     public void render(DemoBlockEntity blockEntity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {     public void render(DemoBlockEntity blockEntity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {
         [...]         [...]
-        MinecraftClient.getInstance().getItemRenderer().renderItem(stack, ModelTransformation.Type.GROUND, light, overlay, matrices, vertexConsumers);+        MinecraftClient.getInstance().getItemRenderer().renderItem(stack, ModelTransformation.Mode.GROUND, light, overlay, matrices, vertexConsumers, 0);
  
-        // Mandatory call after GL calls+        // GL 调用之后的必要调用
         matrices.pop();         matrices.pop();
     }     }
 </code> </code>
  
-You can try your newly created block entity renderer right now.  +您现在就可以尝试新创建的方块实体渲染器。但是，如果您没有使方块透明，您会发现有些不对劲——这个浮动的方块，即唱片机，是黑色的！这是因为默认情况下，//无论您在方块实体中渲染什么，都将接收该方块实体所在位置的光照度//。所以浮动的方块接收这个不透明方块内部的光照，这意味着接收不到光。为了解决此问题，我们会让Minecraft接收方块实体上方位置的光照强度。
-However, if you didn't make your block transparent, you will notice something is amiss - the floating block, the jukebox, is pitch black!   +
-This is because by default, //whatever you render in the block entity, will receive light as if it's in the same position as the block entity//. +
-So the floating block receives light from //inside// our opaque block, which means it receives no light!  +
-To fix this, we will tell Minecraft to receive light from //one block above// the location of the block entity.  +
  
-To get the light, we call ''WorldRenderer#getLightmapCoordinates()'' on the position above our block entity,  +要获取光照，我们在方块实体上方的位置调用 ''WorldRenderer#getLightmapCoordinates();''，并在 ''renderItem()'' 使用这个光照。
-and to use the light we use it in ''renderItem()'':+
 <code java> <code java>
     @Override     @Override
Line 119: Line 103:
                  
         int lightAbove = WorldRenderer.getLightmapCoordinates(blockEntity.getWorld(), blockEntity.getPos().up());         int lightAbove = WorldRenderer.getLightmapCoordinates(blockEntity.getWorld(), blockEntity.getPos().up());
-        MinecraftClient.getInstance().getItemRenderer().renderItem(stack, ModelTransformation.Type.GROUND, lightAbove, OverlayTexture.DEFAULT_UV, matrices, vertexConsumers);+        MinecraftClient.getInstance().getItemRenderer().renderItem(stack, ModelTransformation.Mode.GROUND, lightAbove, OverlayTexture.DEFAULT_UV, matrices, vertexConsumers, 0);
                  
         [...]         [...]
Line 125: Line 109:
 </code> </code>
  
-The jukebox should now have the proper lighting. +唱片机现在应该得到了适当的光照。 
 + 
 +===== 根据方块实体数据进行渲染 ===== 
 +有时候你需要根据方块实体的数据（nbt）进行渲染，结果发现这些数据全是空的，尽管通过 ''/data get block'' 命令可以正常访问数据。这是因为你没有将服务器的数据同步至客户端。参见[[zh_cn:tutorial:blockentity#将服务器数据同步至客户端]]。
zh_cn/tutorial/blockentityrenderers.1576749775.txt.gz · Last modified: 2019/12/19 10:02 by lightcolour