00
:
00
:
00
:
00
•Corso SEO AI - Usa SEOEMAIL al checkout per il 30% di sconto

Rendering Custom

Edoardo Midali
Edoardo Midali

Introduzione al Rendering

Il sistema di rendering di Minecraft gestisce come blocchi, entità e item vengono visualizzati. Con Fabric, puoi creare renderer personalizzati per:

  • Block Entity Renderer: Blocchi con animazioni o rendering dinamico (chest, beacon, ecc.)
  • Entity Renderer: Entità custom con modelli e texture
  • Item Renderer: Item con rendering speciale

Block Entity Renderer

I Block Entity Renderer permettono di renderizzare blocchi in modo dinamico, oltre ai semplici modelli JSON.

1. Creare il Block Entity

```java public class CustomBlockEntity extends BlockEntity { private float rotation = 0f;

public CustomBlockEntity(BlockPos pos, BlockState state) {
    super(ModBlockEntities.CUSTOM_BLOCK_ENTITY, pos, state);
}

public static void tick(World world, BlockPos pos, BlockState state, CustomBlockEntity be) {
    if (world.isClient) {
        be.rotation += 2f; // Ruota di 2 gradi per tick
    }
}

public float getRotation(float tickDelta) {
    return rotation + tickDelta * 2f;
}

} ```

2. Creare il Renderer

```java public class CustomBlockEntityRenderer implements BlockEntityRenderer {

public CustomBlockEntityRenderer(BlockEntityRendererFactory.Context ctx) {
    // Costruttore richiesto
}

@Override
public void render(CustomBlockEntity entity, float tickDelta, MatrixStack matrices,
                   VertexConsumerProvider vertexConsumers, int light, int overlay) {
    
    matrices.push();

    // Centra il rendering
    matrices.translate(0.5, 0.5, 0.5);

    // Ruota in base al tempo
    matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(entity.getRotation(tickDelta)));

    // Renderizza un cubo colorato
    VertexConsumer buffer = vertexConsumers.getBuffer(RenderLayer.getSolid());
    
    // Esempio: renderizza facce del cubo
    renderCubeFace(matrices, buffer, light, overlay);

    matrices.pop();
}

private void renderCubeFace(MatrixStack matrices, VertexConsumer buffer, int light, int overlay) {
    Matrix4f matrix = matrices.peek().getPositionMatrix();
    Matrix3f normalMatrix = matrices.peek().getNormalMatrix();

    // Faccia frontale (esempio semplificato)
    buffer.vertex(matrix, -0.25f, -0.25f, 0.25f).color(255, 0, 0, 255)
          .texture(0, 0).overlay(overlay).light(light)
          .normal(normalMatrix, 0, 0, 1).next();
    buffer.vertex(matrix, 0.25f, -0.25f, 0.25f).color(255, 0, 0, 255)
          .texture(1, 0).overlay(overlay).light(light)
          .normal(normalMatrix, 0, 0, 1).next();
    buffer.vertex(matrix, 0.25f, 0.25f, 0.25f).color(255, 0, 0, 255)
          .texture(1, 1).overlay(overlay).light(light)
          .normal(normalMatrix, 0, 0, 1).next();
    buffer.vertex(matrix, -0.25f, 0.25f, 0.25f).color(255, 0, 0, 255)
          .texture(0, 1).overlay(overlay).light(light)
          .normal(normalMatrix, 0, 0, 1).next();
}

} ```

3. Registrare il Renderer (Client-side)

```java @Environment(EnvType.CLIENT) public class ModClient implements ClientModInitializer { @Override public void onInitializeClient() { BlockEntityRendererRegistry.register( ModBlockEntities.CUSTOM_BLOCK_ENTITY, CustomBlockEntityRenderer::new ); } } ```

Entity Renderer

Per entità custom, serve un renderer che gestisce il modello e la texture.

1. Creare l’Entity Model

```java public class CustomEntityModel extends EntityModel { private final ModelPart body; private final ModelPart head;

public CustomEntityModel(ModelPart root) {
    this.body = root.getChild("body");
    this.head = root.getChild("head");
}

public static TexturedModelData getTexturedModelData() {
    ModelData modelData = new ModelData();
    ModelPartData modelPartData = modelData.getRoot();

    // Corpo (cubo 8x8x8)
    modelPartData.addChild("body",
        ModelPartBuilder.create()
            .uv(0, 0)
            .cuboid(-4F, -4F, -4F, 8F, 8F, 8F),
        ModelTransform.pivot(0F, 20F, 0F));

    // Testa (cubo 6x6x6)
    modelPartData.addChild("head",
        ModelPartBuilder.create()
            .uv(0, 16)
            .cuboid(-3F, -3F, -3F, 6F, 6F, 6F),
        ModelTransform.pivot(0F, 14F, 0F));

    return TexturedModelData.of(modelData, 64, 32);
}

@Override
public void setAngles(CustomEntity entity, float limbAngle, float limbDistance,
                      float animationProgress, float headYaw, float headPitch) {
    // Animazioni (es. testa che segue il movimento)
    this.head.yaw = headYaw * 0.017453292F;
    this.head.pitch = headPitch * 0.017453292F;
}

@Override
public void render(MatrixStack matrices, VertexConsumer vertices, int light, int overlay,
                   float red, float green, float blue, float alpha) {
    body.render(matrices, vertices, light, overlay, red, green, blue, alpha);
    head.render(matrices, vertices, light, overlay, red, green, blue, alpha);
}

} ```

2. Creare l’Entity Renderer

```java public class CustomEntityRenderer extends MobEntityRenderer<CustomEntity, CustomEntityModel> { private static final Identifier TEXTURE = new Identifier(“mymod”, “textures/entity/custom_entity.png”);

public CustomEntityRenderer(EntityRendererFactory.Context context) {
    super(context, new CustomEntityModel(context.getPart(ModEntityModelLayers.CUSTOM)), 0.5f);
}

@Override
public Identifier getTexture(CustomEntity entity) {
    return TEXTURE;
}

} ```

3. Registrare Model Layer e Renderer

```java public class ModEntityModelLayers { public static final EntityModelLayer CUSTOM = new EntityModelLayer(new Identifier(“mymod”, “custom”), “main”); }

@Environment(EnvType.CLIENT) public class ModClient implements ClientModInitializer { @Override public void onInitializeClient() { // Registra il model layer EntityModelLayerRegistry.registerModelLayer( ModEntityModelLayers.CUSTOM, CustomEntityModel::getTexturedModelData );

    // Registra il renderer
    EntityRendererRegistry.register(
        ModEntities.CUSTOM_ENTITY,
        CustomEntityRenderer::new
    );
}

} ```

Rendering con Texture

Texture per Block Entity

Usa RenderLayer con texture:

```java private static final Identifier TEXTURE = new Identifier(“mymod”, “textures/block/custom_block.png”);

@Override public void render(…) { matrices.push();

VertexConsumer buffer = vertexConsumers.getBuffer(
    RenderLayer.getEntityCutout(TEXTURE)
);

// Renderizza con la texture

matrices.pop();

} ```

Texture per Entity

La texture va in:

src/main/resources/assets/mymod/textures/entity/custom_entity.png

Dimensioni standard: 64x32 pixel (può variare in base al modello).

Render Layers

Minecraft offre diversi RenderLayer per effetti diversi:

  • RenderLayer.getSolid(): Blocchi opachi
  • RenderLayer.getCutout(): Blocchi con trasparenza binaria (vetro)
  • RenderLayer.getTranslucent(): Blocchi semi-trasparenti (acqua)
  • RenderLayer.getEntityCutout(texture): Entità con trasparenza
  • RenderLayer.getEntityTranslucent(texture): Entità semi-trasparenti

Best Practices

  • Ottimizza il rendering: Evita calcoli pesanti nel metodo render(), viene chiamato ogni frame
  • Usa il tickDelta: Per animazioni fluide, interpola tra tick usando tickDelta
  • Gestisci la luce: Usa light e overlay per integrare il rendering con l’illuminazione del mondo
  • Testa le performance: Renderer complessi possono impattare gli FPS, specialmente con molte entità/blocchi

Conclusione

Il rendering custom in Fabric permette di creare effetti visivi avanzati, da semplici animazioni a modelli completamente personalizzati. Combinando Block Entity Renderer ed Entity Renderer, puoi dare vita a blocchi e creature uniche nel tuo mondo Minecraft.

PrecedenteMixins & InjectionSuccessivoOres & Features