PonyMirrors/MineLittlePony
1
0
Fork 0
mirror of https://github.com/MineLittlePony/MineLittlePony.git synced 2025-02-13 08:14:23 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update mson and switch to using entity renderer conditions rather than re-registering when configs change

Browse source
This commit is contained in:
Sollace 2024-11-22 15:18:59 +00:00
parent f72fdaaebe
commit 088175a862
No known key found for this signature in database
GPG key ID: E52FACE7B5C773DB
6 changed files with 70 additions and 115 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
gradle.properties
View file

@ -22,4 +22,4 @@ org.gradle.daemon=false
modmenu_version=12.0.0-beta.1
kirin_version=1.20.1+1.21.3
hd_skins_version=6.14.0+1.21.3
mson_version=1.11.0+1.21.3
mson_version=1.11.1-beta.2+1.21.3

17
src/main/java/com/minelittlepony/client/MineLittlePony.java
View file

@ -14,6 +14,7 @@ import com.minelittlepony.common.event.SkinFilterCallback;
import com.minelittlepony.common.util.GamePaths;
import java.nio.file.Path;
import java.util.concurrent.atomic.AtomicBoolean;
import net.fabricmc.api.ClientModInitializer;
import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
@ -47,7 +48,8 @@ public class MineLittlePony implements ClientModInitializer {
private final KeyBinding keyBinding = new KeyBinding("key.minelittlepony.settings", InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_F9, "key.categories.misc");
private final PonyRenderDispatcher renderDispatcher = new PonyRenderDispatcher();
private boolean initialized;
private final AtomicBoolean initialized = new AtomicBoolean();
private final AtomicBoolean configChanged = new AtomicBoolean();
private boolean hasHdSkins;
private boolean hasModMenu;
@ -92,7 +94,7 @@ public class MineLittlePony implements ClientModInitializer {
new ClientSkinsProxy();
config.load();
config.onChangedExternally(c -> initialized = false);
config.onChangedExternally(c -> configChanged.set(true));
ClientChannel.bootstrap();
ModelType.bootstrap();
@ -101,13 +103,12 @@ public class MineLittlePony implements ClientModInitializer {
}
private void onTick(MinecraftClient client) {
if (!initialized) {
initialized = true;
if (!initialized.getAndSet(true)) {
renderDispatcher.initialise(client.getEntityRenderDispatcher(), false);
if (client.currentScreen instanceof PonySettingsScreen screen) {
screen.init(client, screen.width, screen.height);
}
if (configChanged.getAndSet(false) && client.currentScreen instanceof PonySettingsScreen screen) {
screen.init(client, screen.width, screen.height);
}
boolean inGame = client.world != null && client.player != null && client.currentScreen == null;
@ -163,7 +164,7 @@ public class MineLittlePony implements ClientModInitializer {
private static final class ClientPonyConfig extends PonyConfig {
public ClientPonyConfig(Path path) {
super(path);
MobRenderers.REGISTRY.values().forEach(r -> value("entities", r.name, true));
MobRenderers.REGISTRY.values().forEach(r -> value("entities", r.name(), true));
disablePonifiedArmour.onChanged(t -> ArmourTextureResolver.INSTANCE.invalidate());
}

6
src/main/java/com/minelittlepony/client/PonySettingsScreen.java
View file

@ -157,9 +157,9 @@ public class PonySettingsScreen extends GameGui {
content.addButton(new Label(RIGHT, row)).getStyle().setText(MOB_PREFIX + "title");
for (MobRenderers i : MobRenderers.REGISTRY.values()) {
content.addButton(new Toggle(RIGHT, row += 20, i.get()))
.onChange(i::set)
.getStyle().setText(MOB_PREFIX + i.name);
content.addButton(new Toggle(RIGHT, row += 20, i.option()))
.onChange(i.option())
.getStyle().setText(MOB_PREFIX + i.name());
}
row += 15;

132
src/main/java/com/minelittlepony/client/render/MobRenderers.java
View file

@ -1,106 +1,82 @@
package com.minelittlepony.client.render;
import com.minelittlepony.api.config.PonyConfig;
import com.minelittlepony.client.MineLittlePony;
import com.minelittlepony.client.render.entity.*;
import com.minelittlepony.client.render.entity.npc.*;
import com.minelittlepony.common.util.settings.Setting;
import com.minelittlepony.mson.api.EntityRendererRegistry;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Predicate;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityType;
/**
* Central location where new entity renderers are registered and applied.
*/
public class MobRenderers {
public record MobRenderers (String name, BiConsumer<MobRenderers, EntityRendererRegistry> changer) implements Predicate<Entity> {
public static final Map<String, MobRenderers> REGISTRY = new HashMap<>();
public static final MobRenderers VILLAGER = register("villagers", (state, pony) -> {
pony.switchRenderer(state, EntityType.VILLAGER, VillagerPonyRenderer::new);
pony.switchRenderer(state, EntityType.WITCH, WitchRenderer::new);
pony.switchRenderer(state, EntityType.ZOMBIE_VILLAGER, ZomponyVillagerRenderer::new);
pony.switchRenderer(state, EntityType.WANDERING_TRADER, TraderRenderer::new);
});
public static final MobRenderers ILLAGER = register("illagers", (state, pony) -> {
pony.switchRenderer(state, EntityType.VEX, VexRenderer::new);
pony.switchRenderer(state, EntityType.EVOKER, IllagerPonyRenderer::evoker);
pony.switchRenderer(state, EntityType.VINDICATOR, IllagerPonyRenderer::vindicator);
pony.switchRenderer(state, EntityType.ILLUSIONER, IllusionistPonyRenderer::new);
pony.switchRenderer(state, EntityType.PILLAGER, IllagerPonyRenderer::pillager);
});
public static final MobRenderers ZOMBIE = register("zombies", (state, pony) -> {
pony.switchRenderer(state, EntityType.ZOMBIE, ZomponyRenderer::zombie);
pony.switchRenderer(state, EntityType.HUSK, ZomponyRenderer::husk);
pony.switchRenderer(state, EntityType.GIANT, ZomponyRenderer::giant);
pony.switchRenderer(state, EntityType.DROWNED, ZomponyRenderer::drowned);
});
public static final MobRenderers PIGLIN = register("pigzombies", (state, pony) -> {
pony.switchRenderer(state, EntityType.PIGLIN, PonyPiglinRenderer::piglin);
pony.switchRenderer(state, EntityType.PIGLIN_BRUTE, PonyPiglinRenderer::brute);
pony.switchRenderer(state, EntityType.ZOMBIFIED_PIGLIN, PonyPiglinRenderer::zombified);
if (!PonyConfig.getInstance().noFun.get()) {
pony.switchRenderer(state, EntityType.PIG, PonyPigRenderer::new);
public static MobRenderers register(String name, BiConsumer<MobRenderers, EntityRendererRegistry> changer) {
return REGISTRY.computeIfAbsent(name, n -> new MobRenderers(name, changer));
}
});
public static final MobRenderers SKELETON = register("skeletons", (state, pony) -> {
pony.switchRenderer(state, EntityType.SKELETON, SkeleponyRenderer::skeleton);
pony.switchRenderer(state, EntityType.STRAY, SkeleponyRenderer::stray);
pony.switchRenderer(state, EntityType.WITHER_SKELETON, SkeleponyRenderer::wither);
});
public static final MobRenderers GUARDIAN = register("guardians", (state, pony) -> {
pony.switchRenderer(state, EntityType.GUARDIAN, SeaponyRenderer::guardian);
pony.switchRenderer(state, EntityType.ELDER_GUARDIAN, SeaponyRenderer::elder);
});
public static final MobRenderers ENDERMAN = register("endermen", (state, pony) -> {
pony.switchRenderer(state, EntityType.ENDERMAN, EnderStallionRenderer::new);
});
public static final MobRenderers INANIMATE = register("inanimates", (state, pony) -> {
pony.switchRenderer(state, EntityType.ARMOR_STAND, PonyStandRenderer::new);
});
public static final MobRenderers STRIDER = register("striders", (state, pony) -> {
pony.switchRenderer(state, EntityType.STRIDER, StriderRenderer::new);
});
public static final MobRenderers ALLAY = register("allays", (state, pony) -> {
pony.switchRenderer(state, EntityType.ALLAY, AllayRenderer::new);
});
private final BiConsumer<MobRenderers, PonyRenderDispatcher> changer;
public final String name;
private boolean lastState;
private MobRenderers(String name, BiConsumer<MobRenderers, PonyRenderDispatcher> changer) {
this.name = name;
this.changer = changer;
}
public static final MobRenderers VILLAGER = register("villagers", (state, registry) -> {
registry.registerEntityRenderer(EntityType.VILLAGER, state, VillagerPonyRenderer::new);
registry.registerEntityRenderer(EntityType.WITCH, state, WitchRenderer::new);
registry.registerEntityRenderer(EntityType.ZOMBIE_VILLAGER, state, ZomponyVillagerRenderer::new);
registry.registerEntityRenderer(EntityType.WANDERING_TRADER, state, TraderRenderer::new);
});
public static final MobRenderers ILLAGER = register("illagers", (state, registry) -> {
registry.registerEntityRenderer(EntityType.VEX, state, VexRenderer::new);
registry.registerEntityRenderer(EntityType.EVOKER, state, IllagerPonyRenderer::evoker);
registry.registerEntityRenderer(EntityType.VINDICATOR, state, IllagerPonyRenderer::vindicator);
registry.registerEntityRenderer(EntityType.ILLUSIONER, state, IllusionistPonyRenderer::new);
registry.registerEntityRenderer(EntityType.PILLAGER, state, IllagerPonyRenderer::pillager);
});
public static final MobRenderers ZOMBIE = register("zombies", (state, registry) -> {
registry.registerEntityRenderer(EntityType.ZOMBIE, state, ZomponyRenderer::zombie);
registry.registerEntityRenderer(EntityType.HUSK, state, ZomponyRenderer::husk);
registry.registerEntityRenderer(EntityType.GIANT, state, ZomponyRenderer::giant);
registry.registerEntityRenderer(EntityType.DROWNED, state, ZomponyRenderer::drowned);
});
public static final MobRenderers PIGLIN = register("pigzombies", (state, registry) -> {
registry.registerEntityRenderer(EntityType.PIGLIN, state, PonyPiglinRenderer::piglin);
registry.registerEntityRenderer(EntityType.PIGLIN_BRUTE, state, PonyPiglinRenderer::brute);
registry.registerEntityRenderer(EntityType.ZOMBIFIED_PIGLIN, state, PonyPiglinRenderer::zombified);
registry.registerEntityRenderer(EntityType.PIG, entity -> state.option().get() && !PonyConfig.getInstance().noFun.get(), PonyPigRenderer::new);
});
public static final MobRenderers SKELETON = register("skeletons", (state, registry) -> {
registry.registerEntityRenderer(EntityType.SKELETON, state, SkeleponyRenderer::skeleton);
registry.registerEntityRenderer(EntityType.STRAY, state, SkeleponyRenderer::stray);
registry.registerEntityRenderer(EntityType.WITHER_SKELETON, state, SkeleponyRenderer::wither);
});
public static final MobRenderers GUARDIAN = register("guardians", (state, registry) -> {
registry.registerEntityRenderer(EntityType.GUARDIAN, state, SeaponyRenderer::guardian);
registry.registerEntityRenderer(EntityType.ELDER_GUARDIAN, state, SeaponyRenderer::elder);
});
public static final MobRenderers ENDERMAN = register("endermen", (state, registry) -> {
registry.registerEntityRenderer(EntityType.ENDERMAN, state, EnderStallionRenderer::new);
});
public static final MobRenderers INANIMATE = register("inanimates", (state, registry) -> {
registry.registerEntityRenderer(EntityType.ARMOR_STAND, state, PonyStandRenderer::new);
});
public static final MobRenderers STRIDER = register("striders", (state, registry) -> {
registry.registerEntityRenderer(EntityType.STRIDER, state, StriderRenderer::new);
});
public static final MobRenderers ALLAY = register("allays", (state, registry) -> {
registry.registerEntityRenderer(EntityType.ALLAY, state, AllayRenderer::new);
});
public Setting<Boolean> option() {
return PonyConfig.getInstance().getCategory("entities").<Boolean>get(name);
}
public boolean set(boolean value) {
value = option().set(value);
apply(MineLittlePony.getInstance().getRenderDispatcher(), false);
return value;
}
public boolean get() {
@Override
public boolean test(Entity entity) {
return option().get();
}
public static MobRenderers register(String name, BiConsumer<MobRenderers, PonyRenderDispatcher> changer) {
return REGISTRY.computeIfAbsent(name, n -> new MobRenderers(name, changer));
}
void apply(PonyRenderDispatcher dispatcher, boolean force) {
boolean state = get();
if (state != lastState || force) {
lastState = state;
changer.accept(this, dispatcher);
}
}
}

24
src/main/java/com/minelittlepony/client/render/PonyRenderDispatcher.java
View file

@ -1,11 +1,8 @@
package com.minelittlepony.client.render;
import java.util.function.Function;
import com.google.common.base.Predicates;
import com.minelittlepony.api.model.PreviewModel;
import com.minelittlepony.api.pony.*;
import com.minelittlepony.client.mixin.MixinEntityRenderers;
import com.minelittlepony.client.model.ClientPonyModel;
import com.minelittlepony.client.render.entity.*;
import com.minelittlepony.client.render.entity.state.PonyRenderState;
@ -16,10 +13,7 @@ import com.minelittlepony.mson.api.Mson;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.render.entity.*;
import net.minecraft.client.render.entity.state.EntityRenderState;
import net.minecraft.client.util.SkinTextures;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityType;
import net.minecraft.entity.LivingEntity;
/**
@ -58,23 +52,7 @@ public class PonyRenderDispatcher {
);
}
});
MobRenderers.REGISTRY.values().forEach(i -> i.apply(this, force));
}
/**
*
* 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
*/
<T extends Entity, S extends EntityRenderState, V extends T> void switchRenderer(MobRenderers state, EntityType<V> type, Function<EntityRendererFactory.Context, EntityRenderer<T, S>> factory) {
Mson.getInstance().getEntityRendererRegistry().registerEntityRenderer(type, ctx -> state.get()
? factory.apply(ctx)
: MixinEntityRenderers.getRendererFactories().get(type).create(ctx)
);
MobRenderers.REGISTRY.values().forEach(i -> i.changer().accept(i, Mson.getInstance().getEntityRendererRegistry()));
}
@SuppressWarnings("unchecked")

2
src/main/java/com/minelittlepony/client/render/blockentity/skull/MobSkull.java
View file

@ -34,7 +34,7 @@ public class MobSkull implements ISkull {
@Override
public boolean canRender(PonyConfig config) {
return config.ponyskulls.get() && type.get();
return config.ponyskulls.get() && type.option().get();
}
@Override