7 15 2

src/main/java/com/equilibrium/MITEequilibrium.java

@@ -2,14 +2,20 @@
 
 import com.equilibrium.block.ModBlocks;
 
+import com.equilibrium.entity.ModEntities;
+import com.equilibrium.entity.mob.TestZombieEntity;
 import com.equilibrium.item.Ingots;
 import com.equilibrium.item.ModItemGroup;
 import com.equilibrium.item.ModItems;
 import com.equilibrium.item.Tools;
 import net.fabricmc.api.ModInitializer;
+import net.fabricmc.fabric.api.object.builder.v1.entity.FabricDefaultAttributeRegistry;
+import net.minecraft.util.Identifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import static com.equilibrium.entity.ModEntities.TEST_ZOMBIE;
+import static com.equilibrium.entity.ModEntities.registerModEntities;
 import static com.equilibrium.worldgen.ModOreGenerator.registerModOre;
 
 
@@ -47,7 +53,7 @@ public void onInitialize() {
 
 
 
-
+		registerModEntities();
 
 
 
@@ -56,4 +62,5 @@ public void onInitialize() {
 
 		LOGGER.info("Hello Fabric world!");
 	}
+
 }

src/main/java/com/equilibrium/MITEequilibriumClient.java

@@ -1,10 +1,29 @@
 package com.equilibrium;
 
+
+import com.equilibrium.client.render.entity.InvisibleStalker;
+import com.equilibrium.client.render.entity.ZombieEntityRendererTransparent;
 import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.rendering.v1.EntityRendererRegistry;
+
+import static com.equilibrium.entity.ModEntities.INVISIBLE_STALKER;
+import static com.equilibrium.entity.ModEntities.TEST_ZOMBIE;
+
 
 public class MITEequilibriumClient implements ClientModInitializer {
     @Override
     public void onInitializeClient() {
+    //将注册的实体和模型结合起来
+
+
+        EntityRendererRegistry.register(TEST_ZOMBIE, ZombieEntityRendererTransparent::new);
+        EntityRendererRegistry.register(INVISIBLE_STALKER, InvisibleStalker::new);
+
+
+
+
+
+
 
     }
 }

src/main/java/com/equilibrium/client/render/entity/InvisibleStalker.java

@@ -0,0 +1,34 @@
+package com.equilibrium.client.render.entity;
+
+import com.equilibrium.client.render.entity.model.SZombieEntityModel;
+import net.minecraft.client.render.entity.EntityRendererFactory;
+import net.minecraft.client.render.entity.model.EntityModelLayer;
+import net.minecraft.client.render.entity.model.EntityModelLayers;
+import net.minecraft.client.render.entity.model.ZombieEntityModel;
+import net.minecraft.entity.mob.ZombieEntity;
+import net.minecraft.util.Identifier;
+
+public class InvisibleStalker extends TransparentZombieEntityRenderer<ZombieEntity, ZombieEntityModel<ZombieEntity>> {
+    private static final Identifier TEXTURE = Identifier.of("miteequilibrium","textures/entity/invisible_stalker.png");
+
+    public Identifier getTexture(ZombieEntity zombieEntity) {
+        return TEXTURE;
+    }
+
+    public InvisibleStalker(EntityRendererFactory.Context context) {
+        this(context, EntityModelLayers.ZOMBIE, EntityModelLayers.ZOMBIE_INNER_ARMOR, EntityModelLayers.ZOMBIE_OUTER_ARMOR);
+    }
+
+    public InvisibleStalker(EntityRendererFactory.Context ctx, EntityModelLayer layer, EntityModelLayer legsArmorLayer, EntityModelLayer bodyArmorLayer) {
+        super(
+                ctx, new ZombieEntityModel<>(ctx.getPart(layer)), new ZombieEntityModel<>(ctx.getPart(legsArmorLayer)), new ZombieEntityModel<>(ctx.getPart(bodyArmorLayer))
+        );
+
+    }
+
+
+
+
+
+    }
+

src/main/java/com/equilibrium/client/render/entity/TransparentArmorFeatureRenderer.java

@@ -0,0 +1,138 @@
+package com.equilibrium.client.render.entity;
+
+import com.equilibrium.client.render.entity.model.TransparentBipedEntityModel;
+import com.google.common.collect.Maps;
+import java.util.Map;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.TexturedRenderLayers;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.feature.FeatureRenderer;
+import net.minecraft.client.render.entity.feature.FeatureRendererContext;
+import net.minecraft.client.render.entity.model.BipedEntityModel;
+import net.minecraft.client.render.model.BakedModelManager;
+import net.minecraft.client.texture.Sprite;
+import net.minecraft.client.texture.SpriteAtlasTexture;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.component.DataComponentTypes;
+import net.minecraft.component.type.DyedColorComponent;
+import net.minecraft.entity.EquipmentSlot;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ArmorItem;
+import net.minecraft.item.ArmorMaterial;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.trim.ArmorTrim;
+import net.minecraft.registry.entry.RegistryEntry;
+import net.minecraft.registry.tag.ItemTags;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.ColorHelper;
+
+@Environment(EnvType.CLIENT)
+public class TransparentArmorFeatureRenderer<T extends LivingEntity, M extends BipedEntityModel<T>, A extends TransparentBipedEntityModel<T>> extends FeatureRenderer<T, M> {
+    private static final Map<String, Identifier> ARMOR_TEXTURE_CACHE = Maps.<String, Identifier>newHashMap();
+    private final A innerModel;
+    private final A outerModel;
+    private final SpriteAtlasTexture armorTrimsAtlas;
+
+    public TransparentArmorFeatureRenderer(FeatureRendererContext<T, M> context, A innerModel, A outerModel, BakedModelManager bakery) {
+        super(context);
+        this.innerModel = innerModel;
+        this.outerModel = outerModel;
+        this.armorTrimsAtlas = bakery.getAtlas(TexturedRenderLayers.ARMOR_TRIMS_ATLAS_TEXTURE);
+    }
+
+    public void render(
+            MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, T livingEntity, float f, float g, float h, float j, float k, float l
+    ) {
+        this.renderArmor(matrixStack, vertexConsumerProvider, livingEntity, EquipmentSlot.CHEST, i, this.getModel(EquipmentSlot.CHEST));
+        this.renderArmor(matrixStack, vertexConsumerProvider, livingEntity, EquipmentSlot.LEGS, i, this.getModel(EquipmentSlot.LEGS));
+        this.renderArmor(matrixStack, vertexConsumerProvider, livingEntity, EquipmentSlot.FEET, i, this.getModel(EquipmentSlot.FEET));
+        this.renderArmor(matrixStack, vertexConsumerProvider, livingEntity, EquipmentSlot.HEAD, i, this.getModel(EquipmentSlot.HEAD));
+    }
+
+    private void renderArmor(MatrixStack matrices, VertexConsumerProvider vertexConsumers, T entity, EquipmentSlot armorSlot, int light, A model) {
+        ItemStack itemStack = entity.getEquippedStack(armorSlot);
+        if (itemStack.getItem() instanceof ArmorItem armorItem) {
+            if (armorItem.getSlotType() == armorSlot) {
+                this.getContextModel().copyBipedStateTo(model);
+                this.setVisible(model, armorSlot);
+                boolean bl = this.usesInnerModel(armorSlot);
+                ArmorMaterial armorMaterial = armorItem.getMaterial().value();
+                int i = itemStack.isIn(ItemTags.DYEABLE) ? ColorHelper.Argb.fullAlpha(DyedColorComponent.getColor(itemStack, -6265536)) : -1;
+
+                for (ArmorMaterial.Layer layer : armorMaterial.layers()) {
+                    int j = layer.isDyeable() ? i : -1;
+                    this.renderArmorParts(matrices, vertexConsumers, light, model, j, layer.getTexture(bl));
+                }
+
+                ArmorTrim armorTrim = itemStack.get(DataComponentTypes.TRIM);
+                if (armorTrim != null) {
+                    this.renderTrim(armorItem.getMaterial(), matrices, vertexConsumers, light, armorTrim, model, bl);
+                }
+
+                if (itemStack.hasGlint()) {
+                    this.renderGlint(matrices, vertexConsumers, light, model);
+                }
+            }
+        }
+    }
+
+    protected void setVisible(A bipedModel, EquipmentSlot slot) {
+        bipedModel.setVisible(false);
+        switch (slot) {
+            case HEAD:
+                bipedModel.head.visible = true;
+                bipedModel.hat.visible = true;
+                break;
+            case CHEST:
+                bipedModel.body.visible = true;
+                bipedModel.rightArm.visible = true;
+                bipedModel.leftArm.visible = true;
+                break;
+            case LEGS:
+                bipedModel.body.visible = true;
+                bipedModel.rightLeg.visible = true;
+                bipedModel.leftLeg.visible = true;
+                break;
+            case FEET:
+                bipedModel.rightLeg.visible = true;
+                bipedModel.leftLeg.visible = true;
+        }
+    }
+
+    private void renderArmorParts(MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, A model, int i, Identifier identifier) {
+        VertexConsumer vertexConsumer = vertexConsumers.getBuffer(RenderLayer.getArmorCutoutNoCull(identifier));
+        model.render(matrices, vertexConsumer, light, OverlayTexture.DEFAULT_UV, i);
+    }
+
+    private void renderTrim(
+            RegistryEntry<ArmorMaterial> armorMaterial,
+            MatrixStack matrices,
+            VertexConsumerProvider vertexConsumers,
+            int light,
+            ArmorTrim trim,
+            A model,
+            boolean leggings
+    ) {
+        Sprite sprite = this.armorTrimsAtlas.getSprite(leggings ? trim.getLeggingsModelId(armorMaterial) : trim.getGenericModelId(armorMaterial));
+        VertexConsumer vertexConsumer = sprite.getTextureSpecificVertexConsumer(
+                vertexConsumers.getBuffer(TexturedRenderLayers.getArmorTrims(trim.getPattern().value().decal()))
+        );
+        model.render(matrices, vertexConsumer, light, OverlayTexture.DEFAULT_UV);
+    }
+
+    private void renderGlint(MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, A model) {
+        model.render(matrices, vertexConsumers.getBuffer(RenderLayer.getArmorEntityGlint()), light, OverlayTexture.DEFAULT_UV);
+    }
+
+    private A getModel(EquipmentSlot slot) {
+        return this.usesInnerModel(slot) ? this.innerModel : this.outerModel;
+    }
+
+    private boolean usesInnerModel(EquipmentSlot slot) {
+        return slot == EquipmentSlot.LEGS;
+    }
+}

src/main/java/com/equilibrium/client/render/entity/TransparentBipedEntityRenderer.java

@@ -0,0 +1,26 @@
+package com.equilibrium.client.render.entity;
+
+import com.equilibrium.client.render.entity.model.TransparentBipedEntityModel;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.client.render.entity.EntityRendererFactory;
+import net.minecraft.client.render.entity.MobEntityRenderer;
+import net.minecraft.client.render.entity.feature.ElytraFeatureRenderer;
+import net.minecraft.client.render.entity.feature.HeadFeatureRenderer;
+import net.minecraft.client.render.entity.feature.HeldItemFeatureRenderer;
+import net.minecraft.client.render.entity.model.BipedEntityModel;
+import net.minecraft.entity.mob.MobEntity;
+
+@Environment(EnvType.CLIENT)
+public abstract class TransparentBipedEntityRenderer<T extends MobEntity, M extends TransparentBipedEntityModel<T>> extends MobEntityRenderer<T, M> {
+    public TransparentBipedEntityRenderer(EntityRendererFactory.Context ctx, M model, float shadowRadius) {
+        this(ctx, model, shadowRadius, 1.0F, 1.0F, 1.0F);
+    }
+
+    public TransparentBipedEntityRenderer(EntityRendererFactory.Context ctx, M model, float shadowRadius, float scaleX, float scaleY, float scaleZ) {
+        super(ctx, model, shadowRadius);
+        this.addFeature(new HeadFeatureRenderer<>(this, ctx.getModelLoader(), scaleX, scaleY, scaleZ, ctx.getHeldItemRenderer()));
+        this.addFeature(new ElytraFeatureRenderer<>(this, ctx.getModelLoader()));
+        this.addFeature(new HeldItemFeatureRenderer<>(this, ctx.getHeldItemRenderer()));
+    }
+}

src/main/java/com/equilibrium/client/render/entity/TransparentZombieEntityRenderer.java

@@ -0,0 +1,26 @@
+package com.equilibrium.client.render.entity;
+
+import com.equilibrium.client.render.entity.model.SZombieEntityModel;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.client.render.entity.BipedEntityRenderer;
+import net.minecraft.client.render.entity.EntityRendererFactory;
+import net.minecraft.client.render.entity.feature.ArmorFeatureRenderer;
+import net.minecraft.client.render.entity.model.ZombieEntityModel;
+import net.minecraft.entity.mob.ZombieEntity;
+import net.minecraft.util.Identifier;
+
+@Environment(EnvType.CLIENT)
+public abstract class TransparentZombieEntityRenderer<T extends ZombieEntity, M extends ZombieEntityModel<T>> extends BipedEntityRenderer<T, M> {
+
+
+    protected TransparentZombieEntityRenderer(EntityRendererFactory.Context ctx, M bodyModel, M legsArmorModel, M bodyArmorModel) {
+        super(ctx, bodyModel, 0.5F);
+        this.addFeature(new ArmorFeatureRenderer<>(this, legsArmorModel, bodyArmorModel, ctx.getModelManager()));
+    }
+
+
+    protected boolean isShaking(T zombieEntity) {
+        return super.isShaking(zombieEntity) || zombieEntity.isConvertingInWater();
+    }
+}

src/main/java/com/equilibrium/client/render/entity/ZombieEntityRendererTransparent.java

@@ -0,0 +1,30 @@
+package com.equilibrium.client.render.entity;
+
+import com.equilibrium.client.render.entity.model.SZombieEntityModel;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.client.render.entity.EntityRendererFactory;
+import net.minecraft.client.render.entity.model.EntityModelLayer;
+import net.minecraft.client.render.entity.model.EntityModelLayers;
+import net.minecraft.entity.mob.ZombieEntity;
+import net.minecraft.util.Identifier;
+
+@Environment(EnvType.CLIENT)
+public class ZombieEntityRendererTransparent extends TransparentZombieEntityRenderer<ZombieEntity, SZombieEntityModel<ZombieEntity>> {
+
+
+    private static final Identifier TEXTURE = Identifier.ofVanilla("textures/entity/player/wide/steve.png");
+    public Identifier getTexture(ZombieEntity zombieEntity) {
+        return TEXTURE;
+    }
+    public ZombieEntityRendererTransparent(EntityRendererFactory.Context context) {
+        this(context, EntityModelLayers.ZOMBIE, EntityModelLayers.ZOMBIE_INNER_ARMOR, EntityModelLayers.ZOMBIE_OUTER_ARMOR);
+
+    }
+    public ZombieEntityRendererTransparent(EntityRendererFactory.Context ctx, EntityModelLayer layer, EntityModelLayer legsArmorLayer, EntityModelLayer bodyArmorLayer) {
+        super(
+                ctx, new SZombieEntityModel<>(ctx.getPart(layer)), new SZombieEntityModel<>(ctx.getPart(legsArmorLayer)), new SZombieEntityModel<>(ctx.getPart(bodyArmorLayer))
+        );
+    }
+
+}

src/main/java/com/equilibrium/client/render/entity/model/SZombieEntityModel.java

@@ -0,0 +1,19 @@
+package com.equilibrium.client.render.entity.model;
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.entity.model.AbstractZombieModel;
+import net.minecraft.entity.mob.ZombieEntity;
+
+@Environment(EnvType.CLIENT)
+public class SZombieEntityModel<T extends ZombieEntity> extends TransparentAbstractZombieModel<T> {
+    public SZombieEntityModel(ModelPart modelPart) {
+        super(modelPart);
+
+    }
+    public boolean isAttacking(T zombieEntity) {
+        return zombieEntity.isAttacking();
+    }
+
+}

src/main/java/com/equilibrium/client/render/entity/model/TransparentAbstractZombieModel.java

@@ -0,0 +1,23 @@
+package com.equilibrium.client.render.entity.model;
+
+
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.entity.model.CrossbowPosing;
+import net.minecraft.entity.mob.HostileEntity;
+
+@Environment(EnvType.CLIENT)
+public abstract class TransparentAbstractZombieModel<T extends HostileEntity> extends TransparentBipedEntityModel<T> {
+    protected TransparentAbstractZombieModel(ModelPart modelPart) {
+        super(modelPart);
+    }
+
+    public void setAngles(T hostileEntity, float f, float g, float h, float i, float j) {
+        super.setAngles(hostileEntity, f, g, h, i, j);
+        CrossbowPosing.meleeAttack(this.leftArm, this.rightArm, this.isAttacking(hostileEntity), this.handSwingProgress, h);
+    }
+
+    public abstract boolean isAttacking(T entity);
+}