30654791264

Committed 31 Jul 2026 06:20PM UTC coverage: 53.973% (-0.02%) from 53.993%

Build # 30654791264

Build Type

push

github

Committed by

rubensworks

Commit Message

Fix facade rendering being incompatible with ModernFix dynamic resources

Closes #1690

Coverage Stats

3101 of 8995 branches covered (34.47%)

Branch coverage included in aggregate %.

18936 of 31835 relevant lines covered (59.48%)

3.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/cyclops/integrateddynamics/block/BlockCableClientConfig.java

package org.cyclops.integrateddynamics.block;

import net.minecraft.client.Minecraft;
import net.minecraft.client.color.block.BlockTintSource;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.client.particle.ParticleEngine;
import net.minecraft.client.renderer.block.BlockAndTintGetter;
import net.minecraft.client.renderer.block.dispatch.BlockStateModel;
import net.minecraft.client.renderer.item.ItemModel;
import net.minecraft.client.renderer.texture.TextureAtlas;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.resources.model.ModelBaker;
import net.minecraft.client.resources.model.ModelDebugName;
import net.minecraft.core.BlockPos;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.Identifier;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.HitResult;
import net.neoforged.neoforge.client.event.ModelEvent;
import net.neoforged.neoforge.client.event.RegisterColorHandlersEvent;
import net.neoforged.neoforge.client.event.RegisterItemModelsEvent;
import net.neoforged.neoforge.client.event.TextureAtlasStitchedEvent;
import net.neoforged.neoforge.client.extensions.common.IClientBlockExtensions;
import net.neoforged.neoforge.client.extensions.common.RegisterClientExtensionsEvent;
import net.neoforged.neoforge.client.model.standalone.StandaloneModelKey;
import net.neoforged.neoforge.client.model.standalone.UnbakedStandaloneModel;
import org.apache.commons.lang3.tuple.Pair;
import org.cyclops.cyclopscore.client.model.IDynamicModelElementCommon;
import org.cyclops.cyclopscore.config.extendedconfig.BlockClientConfig;
import org.cyclops.cyclopscore.config.extendedconfig.BlockConfigCommon;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.Reference;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.client.model.CableModel;
import org.cyclops.integrateddynamics.core.client.model.ItemModelCable;
import org.cyclops.integrateddynamics.core.helper.CableHelpers;

import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;

public class BlockCableClientConfig extends BlockClientConfig<IntegratedDynamics> {

    public static TextureAtlasSprite BLOCK_TEXTURE;

    public BlockCableClientConfig(BlockConfigCommon<IntegratedDynamics> blockConfig) {
        super(blockConfig);
        blockConfig.getMod().getModEventBus().addListener(this::onRegisterColors);
        blockConfig.getMod().getModEventBus().addListener(this::registerClientExtensions);
        blockConfig.getMod().getModEventBus().addListener(this::postTextureStitch);
        blockConfig.getMod().getModEventBus().addListener((RegisterItemModelsEvent event) -> event.register(Identifier.fromNamespaceAndPath(Reference.MOD_ID, "cable"), ItemModelCable.Unbaked.MAP_CODEC));
        blockConfig.getMod().getModEventBus().addListener((ModelEvent.RegisterStandalone event) -> event.register(new StandaloneModelKey<>(() -> Reference.MOD_ID + ":CableModelHack"), new StandaloneCableModel()));
    }

    public void onRegisterColors(RegisterColorHandlersEvent.BlockTintSources event) {
        event.register(List.of(new BlockCableClientConfig.BlockColor()), getBlockConfig().getInstance());
    }

    public void postTextureStitch(TextureAtlasStitchedEvent event) {
        if (event.getAtlas().location().equals(TextureAtlas.LOCATION_BLOCKS)) {
            BLOCK_TEXTURE = event.getAtlas().getSprite(Identifier.fromNamespaceAndPath(Reference.MOD_ID, "block/cable"));
        }
    }

    public void registerClientExtensions(RegisterClientExtensionsEvent event) {
        event.registerBlock(new IClientBlockExtensions() {
            @Override
            public boolean addHitEffects(BlockState blockState, Level world, HitResult target, ParticleEngine particleManager) {
                BlockPos blockPos = ((BlockHitResult) target).getBlockPos();
                if(CableHelpers.hasFacade(world, blockPos, blockState)) {
                    CableHelpers.getFacade(world, blockPos, blockState)
                            .ifPresent(facadeState -> IModHelpers.get().getRenderHelpers().addBlockHitEffects(particleManager, (ClientLevel) world, facadeState, blockPos, ((BlockHitResult) target).getDirection()));
                    return true;
                } else {
                    return false;
                }
            }
        }, getBlockConfig().getInstance());
    }

    @Override
    public IDynamicModelElementCommon getDynamicModelElement() {
        return new DynamicModel();
    }

    public static class BlockColor implements BlockTintSource {
        @Override
        public int color(BlockState blockState) {
            return -1;
        }

        @Override
        public int colorInWorld(BlockState blockState, BlockAndTintGetter world, BlockPos blockPos) {
            return CableHelpers.getFacadeMultipartTicking(world, blockPos)
                    .map(facadeState -> {
                        BlockTintSource tintSource = Minecraft.getInstance().getBlockColors().getTintSource(facadeState, 0);
                        if (tintSource != null) {
                            return tintSource.colorInWorld(facadeState, world, blockPos);
                        }
                        return -1;
                    })
                    .orElse(-1);
        }
    }

    public static class DynamicModel implements IDynamicModelElementCommon {
        @Override
        public BlockStateModel createDynamicBlockModel(Consumer<Pair<BlockState, BlockStateModel>> modelConsumer, Function<BlockState, BlockStateModel> modelRetriever) {
            CableModel model = new CableModel();
            modelConsumer.accept(Pair.of(RegistryEntries.BLOCK_CABLE.get().defaultBlockState(), model));
            modelConsumer.accept(Pair.of(RegistryEntries.BLOCK_CABLE.get().defaultBlockState().setValue(BlockCable.WATERLOGGED, true), model));
            return model;
        }

        @Override
        public ItemModel createDynamicItemModel(Consumer<Pair<Identifier, ItemModel>> modelConsumer, Function<Identifier, ItemModel> modelRetriever) {
            ItemModelCable model = new ItemModelCable(new CableModel());
            Identifier registryName = BuiltInRegistries.BLOCK.getKey(RegistryEntries.BLOCK_CABLE.get());
            modelConsumer.accept(Pair.of(registryName, model));
            return model;
        }
    }

    // This class is only necessary to gain access to the ModelBaker,
    // since it's needed at CableModel.MODEL_BAKER.
    // Yes, this is a hack, and may be possible to do in a cleaner way, but would probably require a CableModel rewrite.
    public static class StandaloneCableModel implements UnbakedStandaloneModel<Object> {
        @Override
        public void resolveDependencies(Resolver resolver) {
            // Do nothing
        }

        @Override
        public Object bake(ModelBaker baker, ModelDebugName name) {
            CableModel.MODEL_BAKER = baker;
            return null;
        }
    }
}

1	package org.cyclops.integrateddynamics.block;
2
3	import net.minecraft.client.Minecraft;
4	import net.minecraft.client.color.block.BlockTintSource;
5	import net.minecraft.client.multiplayer.ClientLevel;
6	import net.minecraft.client.particle.ParticleEngine;
7	import net.minecraft.client.renderer.block.BlockAndTintGetter;
8	import net.minecraft.client.renderer.block.dispatch.BlockStateModel;
9	import net.minecraft.client.renderer.item.ItemModel;
10	import net.minecraft.client.renderer.texture.TextureAtlas;
11	import net.minecraft.client.renderer.texture.TextureAtlasSprite;
12	import net.minecraft.client.resources.model.ModelBaker;
13	import net.minecraft.client.resources.model.ModelDebugName;
14	import net.minecraft.core.BlockPos;
15	import net.minecraft.core.registries.BuiltInRegistries;
16	import net.minecraft.resources.Identifier;
17	import net.minecraft.world.level.Level;
18	import net.minecraft.world.level.block.state.BlockState;
19	import net.minecraft.world.phys.BlockHitResult;
20	import net.minecraft.world.phys.HitResult;
21	import net.neoforged.neoforge.client.event.ModelEvent;
22	import net.neoforged.neoforge.client.event.RegisterColorHandlersEvent;
23	import net.neoforged.neoforge.client.event.RegisterItemModelsEvent;
24	import net.neoforged.neoforge.client.event.TextureAtlasStitchedEvent;
25	import net.neoforged.neoforge.client.extensions.common.IClientBlockExtensions;
26	import net.neoforged.neoforge.client.extensions.common.RegisterClientExtensionsEvent;
27	import net.neoforged.neoforge.client.model.standalone.StandaloneModelKey;
28	import net.neoforged.neoforge.client.model.standalone.UnbakedStandaloneModel;
29	import org.apache.commons.lang3.tuple.Pair;
30	import org.cyclops.cyclopscore.client.model.IDynamicModelElementCommon;
31	import org.cyclops.cyclopscore.config.extendedconfig.BlockClientConfig;
32	import org.cyclops.cyclopscore.config.extendedconfig.BlockConfigCommon;
33	import org.cyclops.cyclopscore.helper.IModHelpers;
34	import org.cyclops.integrateddynamics.IntegratedDynamics;
35	import org.cyclops.integrateddynamics.Reference;
36	import org.cyclops.integrateddynamics.RegistryEntries;
37	import org.cyclops.integrateddynamics.client.model.CableModel;
38	import org.cyclops.integrateddynamics.core.client.model.ItemModelCable;
39	import org.cyclops.integrateddynamics.core.helper.CableHelpers;
40
41	import java.util.List;
42	import java.util.function.Consumer;
43	import java.util.function.Function;
44
45	public class BlockCableClientConfig extends BlockClientConfig<IntegratedDynamics> {
46
47	public static TextureAtlasSprite BLOCK_TEXTURE;
48
49	public BlockCableClientConfig(BlockConfigCommon<IntegratedDynamics> blockConfig) {
50	super(blockConfig);	×
51	blockConfig.getMod().getModEventBus().addListener(this::onRegisterColors);	×
52	blockConfig.getMod().getModEventBus().addListener(this::registerClientExtensions);	×
53	blockConfig.getMod().getModEventBus().addListener(this::postTextureStitch);	×
54	blockConfig.getMod().getModEventBus().addListener((RegisterItemModelsEvent event) -> event.register(Identifier.fromNamespaceAndPath(Reference.MOD_ID, "cable"), ItemModelCable.Unbaked.MAP_CODEC));	×
55	blockConfig.getMod().getModEventBus().addListener((ModelEvent.RegisterStandalone event) -> event.register(new StandaloneModelKey<>(() -> Reference.MOD_ID + ":CableModelHack"), new StandaloneCableModel()));	×
56	}	×
57
58	public void onRegisterColors(RegisterColorHandlersEvent.BlockTintSources event) {
59	event.register(List.of(new BlockCableClientConfig.BlockColor()), getBlockConfig().getInstance());	×
60	}	×
61
62	public void postTextureStitch(TextureAtlasStitchedEvent event) {
63	if (event.getAtlas().location().equals(TextureAtlas.LOCATION_BLOCKS)) {	×
64	BLOCK_TEXTURE = event.getAtlas().getSprite(Identifier.fromNamespaceAndPath(Reference.MOD_ID, "block/cable"));	×
65	}
66	}	×
67
68	public void registerClientExtensions(RegisterClientExtensionsEvent event) {
69	event.registerBlock(new IClientBlockExtensions() {	×
70	@Override
71	public boolean addHitEffects(BlockState blockState, Level world, HitResult target, ParticleEngine particleManager) {
72	BlockPos blockPos = ((BlockHitResult) target).getBlockPos();	×
73	if(CableHelpers.hasFacade(world, blockPos, blockState)) {	×
74	CableHelpers.getFacade(world, blockPos, blockState)	×
75	.ifPresent(facadeState -> IModHelpers.get().getRenderHelpers().addBlockHitEffects(particleManager, (ClientLevel) world, facadeState, blockPos, ((BlockHitResult) target).getDirection()));	×
76	return true;	×
77	} else {
78	return false;	×
79	}
80	}
81	}, getBlockConfig().getInstance());	×
82	}	×
83
84	@Override
85	public IDynamicModelElementCommon getDynamicModelElement() {
86	return new DynamicModel();	×
87	}
88
89	public static class BlockColor implements BlockTintSource {	×
90	@Override
91	public int color(BlockState blockState) {
92	return -1;	×
93	}
94
95	@Override
96	public int colorInWorld(BlockState blockState, BlockAndTintGetter world, BlockPos blockPos) {
97	return CableHelpers.getFacadeMultipartTicking(world, blockPos)	×
98	.map(facadeState -> {	×
99	BlockTintSource tintSource = Minecraft.getInstance().getBlockColors().getTintSource(facadeState, 0);	×
100	if (tintSource != null) {	×
101	return tintSource.colorInWorld(facadeState, world, blockPos);	×
102	}
103	return -1;	×
104	})
105	.orElse(-1);	×
106	}
107	}
108
109	public static class DynamicModel implements IDynamicModelElementCommon {	×
110	@Override
111	public BlockStateModel createDynamicBlockModel(Consumer<Pair<BlockState, BlockStateModel>> modelConsumer, Function<BlockState, BlockStateModel> modelRetriever) {
112	CableModel model = new CableModel();	×
113	modelConsumer.accept(Pair.of(RegistryEntries.BLOCK_CABLE.get().defaultBlockState(), model));	×
114	modelConsumer.accept(Pair.of(RegistryEntries.BLOCK_CABLE.get().defaultBlockState().setValue(BlockCable.WATERLOGGED, true), model));	×
115	return model;	×
116	}
117
118	@Override
119	public ItemModel createDynamicItemModel(Consumer<Pair<Identifier, ItemModel>> modelConsumer, Function<Identifier, ItemModel> modelRetriever) {
120	ItemModelCable model = new ItemModelCable(new CableModel());	×
121	Identifier registryName = BuiltInRegistries.BLOCK.getKey(RegistryEntries.BLOCK_CABLE.get());	×
122	modelConsumer.accept(Pair.of(registryName, model));	×
123	return model;	×
124	}
125	}
126
127	// This class is only necessary to gain access to the ModelBaker,
128	// since it's needed at CableModel.MODEL_BAKER.
129	// Yes, this is a hack, and may be possible to do in a cleaner way, but would probably require a CableModel rewrite.
130	public static class StandaloneCableModel implements UnbakedStandaloneModel<Object> {	×
131	@Override
132	public void resolveDependencies(Resolver resolver) {
133	// Do nothing
134	}	×
135
136	@Override
137	public Object bake(ModelBaker baker, ModelDebugName name) {
138	CableModel.MODEL_BAKER = baker;	×
139	return null;	×
140	}
141	}
142	}

CyclopsMC / IntegratedDynamics / 30654791264

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous