net.minecraft.client.render.entity.EntityRenderDispatcher Java Examples

public SeaponyRenderer(EntityRenderDispatcher manager) {
    super(manager);

    features.clear();
    ponyRenderer = new Proxy<GuardianEntity, GuardianPonyModel>(features, manager, ModelType.GUARDIAN) {
        @Override
        public Identifier findTexture(GuardianEntity entity) {
            return SEAPONY;
        }

        @Override
        protected HeldItemFeature<GuardianEntity, GuardianPonyModel> createItemHoldingLayer() {
            return new GlowingItemFeature<>(this);
        }
    };
    model = ponyRenderer.getModel();
}
 

public MoonVillagerRenderer(EntityRenderDispatcher renderManager) {
    super(renderManager, new MoonVillagerModel(0, 64, 64), 0.5F);

    this.addFeature(new HeadFeatureRenderer<>(this));
    //this.addFeature(new VillagerClothingFeatureRenderer<>(this, reloadableResourceManager, "villager"));
    this.addFeature(new VillagerHeldItemFeatureRenderer<>(this));
}
 

public AbstractNpcRenderer(EntityRenderDispatcher manager, ModelKey<? super M> key, String type, TextureSupplier<String> formatter) {
    super(manager, key);

    entityType = type;
    baseTextures = new PonyTextures<>(formatter);
    addFeature(new NpcClothingFeature<>(this, entityType));
}
 

public PonyStandRenderer(EntityRenderDispatcher entityRenderDispatcher) {
    super(entityRenderDispatcher);

    features.clear();
    addFeature(new Armour(this));
    addFeature(new HeldItemFeatureRenderer<>(this));
    addFeature(new ElytraFeatureRenderer<>(this));
    addFeature(new HeadFeatureRenderer<>(this));
}
 

/**
 *
 * Replaces an entity renderer depending on whether we want ponies or not.
 *
 * @param state   True if we want ponies (the original will be stored)
 * @param type    The type to replace
 * @param factory The replacement value
 * @param <T> The entity type
 */
@SuppressWarnings("unchecked")
<T extends Entity, V extends T> void switchRenderer(boolean state, EntityType<V> type, Function<EntityRenderDispatcher, EntityRenderer<T>> factory) {
    if (state) {
        if (!renderMap.containsKey(type)) {
            renderMap.put(type, ((MixinEntityRenderDispatcher)MinecraftClient.getInstance().getEntityRenderManager()).getEntityRenderers().get(type));
        }
        Mson.getInstance().getEntityRendererRegistry().registerEntityRenderer(type, factory);
    } else {
        if (renderMap.containsKey(type)) {
            Mson.getInstance().getEntityRendererRegistry().registerEntityRenderer(type, m -> (EntityRenderer<T>)renderMap.get(type));
        }
    }
}
 

public PillagerRenderer(EntityRenderDispatcher manager) {
    super(manager, ModelType.PILLAGER);
}
 

public Caster(EntityRenderDispatcher manager, ModelKey<? super M> key) {
    super(manager, key);
}
 

@SuppressWarnings({"rawtypes", "unchecked"})
public Proxy(List exportedLayers, EntityRenderDispatcher manager, ModelKey<M> key) {
    super(manager, key);

    exportedLayers.addAll(features);
}
 

PlayerEntityRenderer create(
        EntityRenderDispatcher dispatcher,
        boolean slim,
        ModelKey<? extends ClientPonyModel<AbstractClientPlayerEntity>> key
);
 

public ZomponyVillagerRenderer(EntityRenderDispatcher manager) {
    super(manager, ModelType.ZOMBIE_VILLAGER, TYPE, FORMATTER);
}
 

public VillagerPonyRenderer(EntityRenderDispatcher manager) {
    super(manager, ModelType.VILLAGER, TYPE, FORMATTER);
}
 

public IllagerPonyRenderer(EntityRenderDispatcher manager) {
    super(manager, ModelType.ILLAGER);
}
 

public Evoker(EntityRenderDispatcher manager) {
    super(manager);
}
 

public Illusionist(EntityRenderDispatcher manager) {
    super(manager);
}
 

public TraderRenderer(EntityRenderDispatcher manager) {
    super(manager, ModelType.ALICORN.getKey(false));
}
 

private void addPlayerSkin(EntityRenderDispatcher manager, boolean slimArms, PlayerModels playerModel) {
    Mson.getInstance().getEntityRendererRegistry().registerPlayerRenderer(
            playerModel.getId(slimArms),
            playerModel.getModelKey().getRendererFactory(slimArms)
    );
}
 

@SuppressWarnings("unchecked")
public Function<EntityRenderDispatcher, PlayerEntityRenderer> getRendererFactory(boolean slimArms) {
    return d -> rendererFactory.create(d, slimArms, (ModelKey<? extends ClientPonyModel<AbstractClientPlayerEntity>>)getKey(slimArms));
}
 

public PlayerSeaponyRenderer(EntityRenderDispatcher manager, boolean slim, ModelKey<? extends ClientPonyModel<AbstractClientPlayerEntity>> key) {
    super(manager, slim, key);

    normalPony = new ModelWrapper<>(ModelType.<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>>getPlayerModel(Race.UNICORN).getKey(slim));
    seapony = this.manager.getModelWrapper();
}
 

public SkeleponyRenderer(EntityRenderDispatcher manager) {
    super(manager, ModelType.SKELETON);
}
 

public Stray(EntityRenderDispatcher manager) {
    super(manager);
    addFeature(new StrayClothingFeature<>(this));
}
 

public Wither(EntityRenderDispatcher manager) {
    super(manager);
}
 

/**
 * Registers all new player skin types. (currently only pony and slimpony).
 */
public void initialise(EntityRenderDispatcher manager) {
    PlayerModels.registry.forEach(i -> registerPlayerSkin(manager, i));
    MobRenderers.REGISTRY.values().forEach(i -> i.apply(this));
}
 

private void registerPlayerSkin(EntityRenderDispatcher manager, PlayerModels playerModel) {
    if (playerModel != PlayerModels.DEFAULT) {
        addPlayerSkin(manager, false, playerModel);
        addPlayerSkin(manager, true, playerModel);
    }
}
 

public ParaspriteRenderer(EntityRenderDispatcher dispatcher) {
    super(dispatcher, ModelType.PARASPRITE.createModel(), 0.5F);
    addFeature(new SaddleFeatureRenderer<>(this, ModelType.PARASPRITE.createModel(), SADDLE));
}
 

public EvolvedZombieRenderer(EntityRenderDispatcher entityRenderDispatcher_1) {
    super(entityRenderDispatcher_1, new EvolvedZombieModel(1, 64, 64), 0.5F);
}
 

public EvolvedCreeperEntityRenderer(EntityRenderDispatcher dispatcher) {
    super(dispatcher, new EvolvedCreeperEntityModel(0.0F), 0.5F);
    this.addFeature(new EvolvedCreeperChargeFeatureRenderer(this));
}
 

public PumpcownEntityRenderer(EntityRenderDispatcher dispatcher) {
	super(dispatcher, new CowEntityModel(), 0.7F);
	this.addFeature(new PumpcownStemFeatureRenderer(this));
}
 

public MummyEntityRenderer(EntityRenderDispatcher erd) {
	super(erd);
}
 

public CultistEntityRenderer(EntityRenderDispatcher erd) {
	super(erd, new CultistModel(), 0.5F);
}
 

public HallowedTreasureChestEntityRenderer(EntityRenderDispatcher dispatcher) {
	super(dispatcher);
}