net.minecraft.client.model.ModelBiped Java Examples

public static ModelBiped getArmorModel(PackBase pack, EntityLivingBase entity) {
    ModelBiped model = null;
    switch (pack.armorModel) {
    case JETPACK:
        model = ModelJetpack.INSTANCE;
        break;
    case FLUX_PACK:
        model = ModelFluxPack.INSTANCE;
    default:
    }
    if (model == null) {
        return null;
    }
    model.isSneak = entity.isSneaking();
    model.isRiding = entity.isRiding();
    model.isChild = entity.isChild();
    model.heldItemRight = entity.getEquipmentInSlot(0) != null ? 1 : 0;
    if (entity instanceof EntityPlayer) {
        model.aimedBow = ((EntityPlayer) entity).getItemInUseDuration() > 2;
    }
    return model;
}
 

@Override
public void init(FMLInitializationEvent event) {
	super.init(event);

	MinecraftForge.EVENT_BUS.register(CapeHandler.instance());

	Map<String, RenderPlayer> skinMap = Minecraft.getMinecraft().getRenderManager().getSkinMap();
	for (RenderPlayer render : skinMap.values()) {
		//	render.addLayer(new BloodRenderLayer(render));
		render.addLayer(new RenderHaloEntity(render.getMainModel().bipedHead));
	}

	Map<Class<? extends Entity>, Render<? extends Entity>> map = Minecraft.getMinecraft().getRenderManager().entityRenderMap;
	for (ResourceLocation entity : EntityList.getEntityNameList()) {
		Class<? extends Entity> clazz = EntityList.getClass(entity);
		Render<? extends Entity> entityRenderer = map.get(clazz);
		if (entityRenderer instanceof RenderLiving<?>) {
			ModelBase main = ((RenderLiving<?>) entityRenderer).getMainModel();
			ModelRenderer renderer = null;
			if (main instanceof ModelBiped) renderer = ((ModelBiped) main).bipedHead;

			((RenderLiving<?>) entityRenderer).addLayer(new RenderHaloEntity(renderer));
		}
	}
}
 

@SideOnly(Side.CLIENT)
@Override
public ModelBiped getArmorModel(EntityLiving entityLiving, ItemStack itemStack, int armorSlot) {
    if (armorSlot == 0)
        return new ModelScaleHelmet();
    return null;
}
 

@SideOnly(Side.CLIENT)
@Override
public ModelBiped getArmorModel(EntityLiving entityLiving, ItemStack itemStack, int armorSlot) {
    if (armorSlot == 0)
        return new ModelHoodHelmet();
    return null;
}
 

@SideOnly(Side.CLIENT)
@Override
public ModelBiped getArmorModel(EntityLiving entityLiving, ItemStack itemStack, int armorSlot) {
    if (armorSlot == 0)
        return new ModelSkullHelmet();
    return null;
}
 

@Override
@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack stack, int armorSlot) {
    T pack = this.getPack(stack);
    if (pack != null && pack.armorModel != null && Config.enableArmor3DModels) {
        ModelBiped model = RenderUtils.getArmorModel(pack, entityLiving);
        if (model != null) {
            return model;
        }
    }
    return super.getArmorModel(entityLiving, stack, armorSlot);
}
 

public RenderJetPack(ModelBiped _default) {
	if(model == null)
		try {
			model = new WavefrontObject(new ResourceLocation("advancedrocketry:models/jetPack.obj"));
		} catch (ModelFormatException e) {
			e.printStackTrace();
		}
	biped = _default;
}
 

@Override
@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving,
		ItemStack itemStack, EntityEquipmentSlot armorSlot,
		ModelBiped _default) {

	if(armorSlot == EntityEquipmentSlot.CHEST) {
		for(ItemStack stack : getComponents(itemStack)) {
			if(stack.getItem() instanceof IJetPack)
				return new RenderJetPack(_default);
		}
	}
	return super.getArmorModel(entityLiving, itemStack, armorSlot, _default);
}
 

private void setModel(EntityPlayer player) {
	boolean isAlex;

	NBTTagCompound nbt = player.getEntityData();
	if (nbt.hasKey(SetPlayerModelCommand.MODEL_KEY, Constants.NBT.TAG_BYTE))
		isAlex = nbt.getBoolean(SetPlayerModelCommand.MODEL_KEY);
	else
		isAlex = PlayerModelManager.isPlayerModelAlex(getEntityTexture(player));

	mainModel = isAlex ? ALEX : STEVE;
	modelBipedMain = (ModelBiped) mainModel;
}
 

@Override
@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, EntityEquipmentSlot armorSlot, net.minecraft.client.model.ModelBiped _default)
{
	ClientUtils.trench.setModelAttributes(_default);
	ClientUtils.armor.setModelAttributes(_default);
	ClientUtils.trench.bipedRightArm.isHidden = !(entityLiving instanceof EntityPlayer) && !(entityLiving instanceof EntityArmorStand);
	ClientUtils.trench.bipedLeftArm.isHidden = !(entityLiving instanceof EntityPlayer) && !(entityLiving instanceof EntityArmorStand);
	ClientUtils.armor.bipedRightArm.isHidden = ClientUtils.trench.bipedRightArm.isHidden;
	ClientUtils.armor.bipedLeftArm.isHidden = ClientUtils.trench.bipedLeftArm.isHidden;

	if (itemStack != null && itemStack.getItem() == CyberwareContent.trenchcoat) return ClientUtils.trench;
	
	return ClientUtils.armor;
}
 

@Inject(method = "setInvisible", at = @At("RETURN"))
private void setInvisible(boolean invisible, CallbackInfo ci) {
    if (getClass().equals(ModelBiped.class)) {
        bipedLeftForeArm.showModel = invisible;
        bipedRightForeArm.showModel = invisible;
        bipedLeftLowerLeg.showModel = invisible;
        bipedRightLowerLeg.showModel = invisible;
    }
}
 

/**
 * @author 9Y0, Mojang
 * @reason body parts
 */
@Overwrite
public void render(Entity entityIn, float p_78088_2_, float p_78088_3_, float p_78088_4_, float p_78088_5_, float p_78088_6_, float scale) {
    setRotationAngles(p_78088_2_, p_78088_3_, p_78088_4_, p_78088_5_, p_78088_6_, scale, entityIn);
    GlStateManager.pushMatrix();
    if (isChild) {
        float f = 2.0F;
        GlStateManager.scale(1.5F / f, 1.5F / f, 1.5F / f);
        GlStateManager.translate(0.0F, 16.0F * scale, 0.0F);
        bipedHead.render(scale);
        GlStateManager.popMatrix();
        GlStateManager.pushMatrix();
        GlStateManager.scale(1.0F / f, 1.0F / f, 1.0F / f);
        GlStateManager.translate(0.0F, 24.0F * scale, 0.0F);
    } else {
        if (entityIn.isSneaking()) GlStateManager.translate(0.0F, 0.2F, 0.0F);
        bipedHead.render(scale);
    }

    // Adding our parts
    bipedBody.render(scale);
    bipedRightArm.render(scale);
    bipedLeftArm.render(scale);
    bipedRightLeg.render(scale);
    bipedLeftLeg.render(scale);
    bipedHeadwear.render(scale);
    if (getClass().equals(ModelBiped.class)) renderBiped(scale);
    GlStateManager.popMatrix();
}
 

/**
 * The only method which is edited. Shows some more model te make everything
 * render properly.
 *
 * @param model     The model which gets rendered
 * @param armorSlot The slot of the armor (1 = boots, 2 = leggins, etc..). Don't ask
 *                  me why it doesn't start at 0.
 * @author 9Y0
 */
protected void setModelPartVisible(ModelBiped model, int armorSlot) {
    model.setInvisible(false);
    IMixinModelBiped modelBiped = (IMixinModelBiped) model;

    switch (armorSlot) {
        case 1: {
            model.bipedRightLeg.showModel = true;
            model.bipedLeftLeg.showModel = true;
            modelBiped.getBipedRightLowerLeg().showModel = true;
            modelBiped.getBipedLeftLowerLeg().showModel = true;
            break;
        }
        case 2: {
            model.bipedBody.showModel = true;
            model.bipedRightLeg.showModel = true;
            model.bipedLeftLeg.showModel = true;
            modelBiped.getBipedRightLowerLeg().showModel = true;
            modelBiped.getBipedLeftLowerLeg().showModel = true;
            break;
        }
        case 3: {
            model.bipedBody.showModel = true;
            model.bipedRightArm.showModel = true;
            model.bipedLeftArm.showModel = true;
            modelBiped.getBipedRightForeArm().showModel = true;
            modelBiped.getBipedLeftForeArm().showModel = true;
            break;
        }
        case 4: {
            model.bipedHead.showModel = true;
            model.bipedHeadwear.showModel = true;
            break;
        }
    }
}
 

@SideOnly(Side.CLIENT)
private ModelBiped getArmorModel() {
    if (armorModel == null) {
        this.armorModel = new ModelBiped(1.0f, 0.0f, 32, 32);
        this.armorModel.bipedHeadwear.isHidden = true;
        ModelRenderer bipedHead = this.armorModel.bipedHead;
        bipedHead.cubeList.add(new ModelBox(bipedHead, 0, 16, -2.0F, -6.0F, 4.0f, 4, 4, 4, 0.0f));
    }
    return armorModel;
}
 

@Nullable
@Override
@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, EntityEquipmentSlot armorSlot, ModelBiped _default) {
    IArmorLogic armorLogic = getArmorLogic(itemStack);
    return armorLogic.getArmorModel(entityLiving, itemStack, armorSlot, _default);
}
 

public static void renderArmorLayer(LayerArmorBase<ModelBase> layer, EntityLivingBase entity, float limbSwing, float limbSwingAmount, float partialTicks, float ageInTicks, float netHeadYaw, float headPitch, float scale, EntityEquipmentSlot slotIn) {
    ItemStack itemStack = entity.getItemStackFromSlot(slotIn);

    if (isArmorItem(itemStack, slotIn)) {
        IArmorItem armorItem = (IArmorItem) itemStack.getItem();
        ModelBase armorModel = layer.getModelFromSlot(slotIn);
        if (armorModel instanceof ModelBiped) {
            armorModel = ForgeHooksClient.getArmorModel(entity, itemStack, slotIn, (ModelBiped) armorModel);
        }
        armorModel.setModelAttributes(layer.renderer.getMainModel());
        armorModel.setLivingAnimations(entity, limbSwing, limbSwingAmount, partialTicks);
        layer.setModelSlotVisible(armorModel, slotIn);

        GlStateManager.enableBlend();
        GlStateManager.blendFunc(SourceFactor.ONE, DestFactor.ONE_MINUS_SRC_ALPHA);

        int layers = armorItem.getArmorLayersAmount(itemStack);
        for (int layerIndex = 0; layerIndex < layers; layerIndex++) {
            int i = armorItem.getArmorLayerColor(itemStack, layerIndex);
            float f = (float) (i >> 16 & 255) / 255.0F;
            float f1 = (float) (i >> 8 & 255) / 255.0F;
            float f2 = (float) (i & 255) / 255.0F;
            GlStateManager.color(f, f1, f2, 1.0f);
            String type = layerIndex == 0 ? null : "layer_" + layerIndex;
            layer.renderer.bindTexture(getArmorTexture(entity, itemStack, slotIn, type));
            armorModel.render(entity, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale);
        }
        if (itemStack.hasEffect()) {
            LayerArmorBase.renderEnchantedGlint(layer.renderer, entity, armorModel, limbSwing, limbSwingAmount, partialTicks, ageInTicks, netHeadYaw, headPitch, scale);
        }
    }
}
 

@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, EntityEquipmentSlot armorSlot, ModelBiped _default)
{
  if (this.model1 == null) {
    this.model1 = new ModelSamuraiArmors(armorSlot,3,1.0F);
  }
  if (this.model2 == null) {
    this.model2 = new ModelSamuraiArmors(armorSlot,3,0.5F);
  }
  
  this.model = ClientUtils.getCustomArmorModel(entityLiving, itemStack, armorSlot, this.model, this.model1, this.model2);
  return this.model;
}
 

public ArmourStandRenderer() {
	super(new ModelArmorStand(), 0.0F);
	modelBipedMain = (ModelBiped) mainModel;
	field_82423_g = new ModelArmorStandArmor(1.0F);
	field_82425_h = new ModelArmorStandArmor(0.5F);
}
 

protected void translateToHand(EnumHandSide p_191361_1_)
{
    ((ModelBiped)this.livingEntityRenderer.getMainModel()).postRenderArm(0.0625F, p_191361_1_);
}
 

@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, EntityEquipmentSlot armorSlot, net.minecraft.client.model.ModelBiped _default) {
	return getKimonoModel(entityLiving, itemStack, new ModelKimono());
}
 

@SideOnly(Side.CLIENT)
public static ModelBiped getKimonoModel(EntityLivingBase entityLiving, ItemStack itemStack,ModelBiped model)
{
  if (model != null)
  {
    model.setVisible(true);
    
    model.isSneak = entityLiving.isSneaking();
    
    model.isRiding = entityLiving.isRiding();
    model.isChild = entityLiving.isChild();
    ItemStack itemstack = entityLiving.getHeldItemMainhand();
    ItemStack itemstack1 = entityLiving.getHeldItemOffhand();
    ModelBiped.ArmPose modelbiped$armpose = ModelBiped.ArmPose.EMPTY;
    ModelBiped.ArmPose modelbiped$armpose1 = ModelBiped.ArmPose.EMPTY;
    if ((itemstack != null) && (!itemstack.isEmpty()))
    {
      modelbiped$armpose = ModelBiped.ArmPose.ITEM;
      if (entityLiving.getItemInUseCount() > 0)
      {
        EnumAction enumaction = itemstack.getItemUseAction();
        if (enumaction == EnumAction.BLOCK) {
          modelbiped$armpose = ModelBiped.ArmPose.BLOCK;
        } else if (enumaction == EnumAction.BOW) {
          modelbiped$armpose = ModelBiped.ArmPose.BOW_AND_ARROW;
        }
      }
    }
    if ((itemstack1 != null) && (!itemstack1.isEmpty()))
    {
      modelbiped$armpose1 = ModelBiped.ArmPose.ITEM;
      if (entityLiving.getItemInUseCount() > 0)
      {
        EnumAction enumaction1 = itemstack1.getItemUseAction();
        if (enumaction1 == EnumAction.BLOCK) {
          modelbiped$armpose1 = ModelBiped.ArmPose.BLOCK;
        }
      }
    }
    if (entityLiving.getPrimaryHand() == EnumHandSide.RIGHT)
    {
      model.rightArmPose = modelbiped$armpose;
      model.leftArmPose = modelbiped$armpose1;
    }
    else
    {
      model.rightArmPose = modelbiped$armpose1;
      model.leftArmPose = modelbiped$armpose;
    }
  }
  return model;
}
 

public MoCRenderWraith(ModelBiped modelbiped, float f)
{
    //super(modelbiped, f, 1.0F);
    super(modelbiped, f);
    //modelBipedMain = modelbiped;
}
 

public void doRenderLayer(EntityLivingBase entity, float limbSwing, float limbSwingAmount,
                          float partialTicks, float ageInTicks, float netHeadYaw, float headPitch, float scale) {
	
	IBackpack backpack;
	RenderOptions renderOptions;
	if (_overrideBackpack != null) {
		backpack = _overrideBackpack;
		renderOptions = _overrideRenderOptions;
	} else {
		backpack = BackpackHelper.getBackpack(entity);
		BackpackEntityEntry entry = BackpackRegistry.getEntityEntry(entity.getClass());
		renderOptions = (entry != null) ? entry.renderOptions : null;
	}
	if ((backpack == null) || (renderOptions == null)) return;
	
	GlStateManager.pushMatrix();
	
	if (entity.isChild()) {
		GlStateManager.scale(0.5F, 0.5F, 0.5F);
		GlStateManager.translate(0.0F, 24.0F * scale, 0.0F);
	}
	
	ModelBase modelBase = this.livingEntityRenderer.getMainModel();
	if (modelBase instanceof ModelBiped) {
		ModelRenderer bipedBody = ((ModelBiped) modelBase).bipedBody;
		
		if (entity.isSneaking()) {
			// FIXME: Can be sneaking while flying with the elytra, then backpack is misaligned..?
			GlStateManager.translate(0.0F, 0.2F, 0.0F);
		}
		
		bipedBody.postRender(scale);
	} else {
		// Fallback to the custom way of transforming the backpack.
		// Make backpack swing with body as players swing their arms.
		float swingProgress = entity.getSwingProgress(partialTicks);
		float swingAngle = MathHelper.sin(MathHelper.sqrt(swingProgress) * ((float)Math.PI * 2.0F)) * 0.2F;
		if ((entity.swingingHand == EnumHand.OFF_HAND) ^
		    (entity.getPrimaryHand() == EnumHandSide.LEFT)) swingAngle *= -1;
		if (swingAngle != 0) GlStateManager.rotate((float)Math.toDegrees(swingAngle), 0.0F, 1.0F, 0.0F);
		
		// Rotate backpack if entity is sneaking.
		if (entity.isSneaking()) {
			// FIXME: Can be sneaking while flying with the elytra, then backpack is misaligned..?
			GlStateManager.translate(0.0F, 0.2F, 0.0F);
			GlStateManager.rotate(90.0F / (float)Math.PI, 1.0F, 0.0F, 0.0F);
		}
	}
	
	GlStateManager.scale(renderOptions.scale, renderOptions.scale, renderOptions.scale);
	GlStateManager.translate(8.0F * scale, renderOptions.y * scale, renderOptions.z * scale);
	GlStateManager.rotate(180.0F, 0.0F, 0.0F, 1.0F);
	GlStateManager.rotate((float)renderOptions.rotate, 1.0F, 0.0F, 0.0F);
	GlStateManager.translate(0, ProxyClient.MODEL_BACKPACK_BOX.maxY * scale * -16,
	                            ProxyClient.MODEL_BACKPACK_BOX.minZ * scale * -16);
	
	renderBackpack(backpack, entity.ticksExisted + partialTicks, false);
	
	GlStateManager.popMatrix();
	
}
 

@Override
@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, int armorSlot) {
    return new ModelWings();
}
 

@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, EntityEquipmentSlot armorSlot, net.minecraft.client.model.ModelBiped _default) {
	return ItemKimono.getKimonoModel(entityLiving, itemStack, new ModelHaori());
}
 

@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, EntityEquipmentSlot armorSlot, net.minecraft.client.model.ModelBiped _default) {
    return new ModelStrawHat();
}
 

public ModelGnome()
{
	textureWidth = 64;
	textureHeight = 32;
       this.leftArmPose = ModelBiped.ArmPose.EMPTY;
       this.rightArmPose = ModelBiped.ArmPose.EMPTY;
	
	bipedHead = new ModelRenderer(this, 0, 0);
	bipedHead.addBox(-4F, -7F, -4F, 8, 7, 8);
	bipedHead.setRotationPoint(0F, 16F, 0F);
	bipedHead.setTextureSize(64, 32);
	bipedHead.mirror = true;
	setRotation(bipedHead, 0F, 0F, 0F);
	bipedBody = new ModelRenderer(this, 16, 16);
	bipedBody.addBox(-3F, 0F, -3F, 6, 5, 6);
	bipedBody.setRotationPoint(0F, 16F, 0F);
	bipedBody.setTextureSize(64, 32);
	bipedBody.mirror = true;
	setRotation(bipedBody, 0F, 0F, 0F);
	bipedRightArm = new ModelRenderer(this, 40, 13);
	bipedRightArm.addBox(-3F, -2F, -2F, 4, 5, 4);
	bipedRightArm.setRotationPoint(-4F, 18F, 0F);
	bipedRightArm.setTextureSize(64, 32);
	bipedRightArm.mirror = true;
	setRotation(bipedRightArm, 0F, 0F, 0F);
	bipedLeftArm = new ModelRenderer(this, 40, 22);
	bipedLeftArm.addBox(-1F, -2F, -2F, 4, 5, 4);
	bipedLeftArm.setRotationPoint(4F, 18F, 0F);
	bipedLeftArm.setTextureSize(64, 32);
	bipedLeftArm.mirror = true;
	setRotation(bipedLeftArm, 0F, 0F, 0F);
	bipedRightLeg = new ModelRenderer(this, 0, 16);
	bipedRightLeg.addBox(-2F, 0F, -2F, 4, 3, 4);
	bipedRightLeg.setRotationPoint(-2F, 21F, 0F);
	bipedRightLeg.setTextureSize(64, 32);
	bipedRightLeg.mirror = true;
	setRotation(bipedRightLeg, 0F, 0F, 0F);
	bipedLeftLeg = new ModelRenderer(this, 36, 6);
	bipedLeftLeg.addBox(-2F, 0F, -2F, 4, 3, 4);
	bipedLeftLeg.setRotationPoint(2F, 21F, 0F);
	bipedLeftLeg.setTextureSize(64, 32);
	bipedLeftLeg.mirror = true;
	setRotation(bipedLeftLeg, 0F, 0F, 0F);
	beard1 = new ModelRenderer(this, 45, 0);
	beard1.addBox(-2.5F, 0F, -4F, 5, 3, 1);
	beard1.setRotationPoint(0F, 16F, 0F);
	beard1.setTextureSize(64, 32);
	beard1.mirror = true;
	setRotation(beard1, -0.4363323F, 0F, 0F);
	nose = new ModelRenderer(this, 34, 0);
	nose.addBox(-1.5F, -4.5F, -6F, 3, 2, 2);
	nose.setRotationPoint(0F, 16F, 0F);
	nose.setTextureSize(64, 32);
	nose.mirror = true;
	setRotation(nose, 0F, 0F, 0F);
}
 

@Override
@SideOnly(Side.CLIENT)
public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, int armorSlot) {
	return new ModelElytra();
}
 

protected void initArmor() {
    modelLeggings = new ModelBiped(0.5F);
    modelArmor = new ModelBiped(1.0F);
}
 

public NotchButWithWorsererPantsRenderer(RenderManager manager) {
    super(manager, new ModelBiped(0.0F), 1.5F);
}