net.minecraft.client.renderer.entity.Render Java Examples

public static <T extends Render> T unregisterRenderer(Class<? extends Entity> entityClass, Class<T> renderClass) {
    Injector registry = new Injector(RenderingRegistry.instance());
    List entityRenderers = registry.getField("entityRenderers");

    if(entityRenderers == null) {
        FMLLog.severe("Failed to get entityRenderers field in RenderingRegistry!");
        return null;
    }

    for(int i = 0; i < entityRenderers.size(); i++) {
        Injector pair = new Injector(entityRenderers.get(i));

        Class<? extends Entity> target = pair.getField("target");

        if(entityClass.equals(target)) {
            Render render = pair.getField("renderer");
            if(renderClass.isInstance(render)) {
                entityRenderers.remove(i);
                return (T)render;
            }
        }
    }
    return null;
}
 

private void renderArm(EnumHandSide p_187455_1_)
{
	this.mc.getTextureManager().bindTexture(this.mc.thePlayer.getLocationSkin());
	Render<AbstractClientPlayer> render = getEntityRenderObject(this.mc.thePlayer, p_187455_1_);
	RenderPlayer renderplayer = (RenderPlayer)render;
	GlStateManager.pushMatrix();
	float f = p_187455_1_ == EnumHandSide.RIGHT ? 1.0F : -1.0F;
	GlStateManager.rotate(92.0F, 0.0F, 1.0F, 0.0F);
	GlStateManager.rotate(45.0F, 1.0F, 0.0F, 0.0F);
	GlStateManager.rotate(f * -41.0F, 0.0F, 0.0F, 1.0F);
	GlStateManager.translate(f * 0.3F, -1.1F, 0.45F);

	if (p_187455_1_ == EnumHandSide.RIGHT)
	{
		renderplayer.renderRightArm(this.mc.thePlayer);
	}
	else
	{
		renderplayer.renderLeftArm(this.mc.thePlayer);
	}

	GlStateManager.popMatrix();
}
 

@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));
		}
	}
}
 

private void setRenderHead(EntityLivingBase entity, boolean setRender){
    if(entity.getEquipmentInSlot(4) != null && entity.getEquipmentInSlot(4).getItem() == Itemss.pneumaticHelmet && (Config.useHelmetModel || DateEventHandler.isIronManEvent())) {
        Render renderer = RenderManager.instance.getEntityRenderObject(entity);
        if(renderer instanceof RenderBiped) {
            ((RenderBiped)renderer).modelBipedMain.bipedHead.showModel = setRender;
        }
    }
}
 

public static net.minecraftforge.fml.client.registry.IRenderFactory entityVillagerRenderer(){
	return new net.minecraftforge.fml.client.registry.IRenderFactory(){
		@Override
		public Render createRenderFor(RenderManager manager) {
			return new net.minecraft.client.renderer.entity.RenderVillager(manager);
		}
	};

}
 

/** Ensures that the specified entity class' renderer has a backpack layer - if possible. */
public static void ensureHasBackpackLayer(Class<? extends EntityLivingBase> entityClass) {
	if (!_hasLayerChecked.add(entityClass)) return;
	RenderManager manager = Minecraft.getMinecraft().getRenderManager();
	Render<?> render = manager.getEntityClassRenderObject(entityClass);
	if (!(render instanceof RenderLivingBase)) return;
	((RenderLivingBase<?>)render).addLayer(new RendererBackpack.Layer((RenderLivingBase<?>)render));
}
 

/**
 * Run during mod init.
 */
@Override
public void init() {
	// We register the portal renderer here
	Render render;
	render = new RenderPortal();
	render.setRenderManager(RenderManager.instance);
	RenderingRegistry.registerEntityRenderingHandler(EntityPortal.class, render);
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntityToro.class, new IRenderFactory<EntityToro>() {
		@Override
		public Render<EntityToro> createRenderFor(RenderManager manager) {
			return new RenderToro(manager, new ModelToro(), 0.7F);
		}
	});
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntityRainbowGuard.class, new IRenderFactory<EntityRainbowGuard>() {
		@Override
		public Render<EntityRainbowGuard> createRenderFor(RenderManager manager) {
			return new RenderRainbowGuard(manager);
		}
	});
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntityBas.class, new IRenderFactory<EntityBas>() {
		@Override
		public Render<EntityBas> createRenderFor(RenderManager manager) {
			return new RenderBas(manager);
		}
	});
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntityGuard.class, new IRenderFactory<EntityGuard>() {
		@Override
		public Render<EntityGuard> createRenderFor(RenderManager manager) {
			return new RenderGuard(manager);
		}
	});
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntitySentry.class, new IRenderFactory<EntitySentry>() {
		@Override
		public Render<EntitySentry> createRenderFor(RenderManager manager) {
			return new RenderSentry(manager);
		}
	});
}
 

public static void registerMonolithEyeRenderer() {
	RenderingRegistry.registerEntityRenderingHandler(EntityMonolithEye.class, new IRenderFactory<EntityMonolithEye>() {
		@Override 
		public Render<EntityMonolithEye> createRenderFor(RenderManager manager) { 
			return new RenderMonolithEye(manager); 
		}
	});
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntityFugitive.class, new IRenderFactory<EntityFugitive>() {
		@Override
		public Render<EntityFugitive> createRenderFor(RenderManager manager) {
			return new RenderFugitive(manager);
		}
	});
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntityVampireBat.class, new IRenderFactory<EntityVampireBat>() {
		@Override
		public Render<EntityVampireBat> createRenderFor(RenderManager manager) {
			return new RenderVampireBat(manager);
		}
	});
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntityVillageLord.class, new IRenderFactory<EntityVillageLord>() {
		@Override
		public Render<EntityVillageLord> createRenderFor(RenderManager manager) {
			return new RenderVillageLord(manager);
		}
	});
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntityShopkeeper.class, new IRenderFactory<EntityShopkeeper>() {
		@Override
		public Render<EntityShopkeeper> createRenderFor(RenderManager manager) {
			return new RenderShopkeeper(manager);
		}
	});
}
 

public static void registerRenders() {
	RenderingRegistry.registerEntityRenderingHandler(EntityRainbowKing.class, new IRenderFactory<EntityRainbowKing>() {
		@Override
		public Render<? super EntityRainbowKing> createRenderFor(RenderManager manager) {
			return new RenderRainbowKing(manager);
		}
	});
}
 

public void registerModEntity(Class entityClass, Render render,
		String entityName, int entityId, int foregroundColor,
		int backgroundColor) {
	EntityRegistry.registerGlobalEntityID(entityClass, entityName,
			entityId, foregroundColor, backgroundColor);
	EntityRegistry.registerModEntity(entityClass, entityName, entityId,
			this, 80, 1, false);
	RenderingRegistry.registerEntityRenderingHandler(entityClass, render);
}
 

public static void registerMageRenderer() {
	RenderingRegistry.registerEntityRenderingHandler(EntityMage.class, new IRenderFactory<EntityMage>() {
		@Override 
		public Render<EntityMage> createRenderFor(RenderManager manager) { 
			return new RenderMage(manager); 
		}
	});
}
 

@Override
public Render<? super EntityFluidCow> createRenderFor(RenderManager renderManager) {
  return new RenderFluidCow(renderManager);
}
 

@Override
public Render<? super Entity> createRenderFor(RenderManager manager) {
	return new RendererRocket(manager);
}
 

@Override
public Render<? super EntityCow> createRenderFor(RenderManager renderManager) {
  return new RenderEventCow(renderManager);
}
 

public RenderFireflyWrapper () {
    try {
        render = (Render) TwilightForestIntegration.constRenderFirefly.newInstance();
    }
    catch (Throwable t) { }
}
 

@Override
public Render<? super EntityPrimedCharge> createRenderFor(RenderManager manager) {
  return new RenderPrimedCharge(manager);
}
 

@Override
public Render<? super EntityOwlEgg> createRenderFor(RenderManager manager) {
  return new RenderEntityOwlEgg(manager, Minecraft.getMinecraft().getRenderItem());
}
 

@Override
public Render<? super EntityWitherCat> createRenderFor(RenderManager manager) {
  return new RenderWitherCat(manager);
}
 

@Override
public Render<? super EntityEnderminy> createRenderFor(RenderManager manager) {
  return new RenderEnderminy(manager);
}
 

@Override
public Render<? super EntityCreeper> createRenderFor(RenderManager manager) {
  return new RenderConcussionCreeper(manager);
}
 

@Override
public Render<? super EntityOwl> createRenderFor(RenderManager manager) {
  return new RenderOwl(manager);
}