Merge pull request 'version 1.5.6 fix for server imports + support for continuity and MoreCulling compat' (#11) from dev into master

Reviewed-on: #11

.gitignore

@@ -33,3 +33,4 @@ local.properties
 *-autosave.kra
 *.kra~
 /src/generated/
+/libs/

LICENSE

@@ -1,15 +1 @@
-Copyright (c) 2019 B0undarybreaker (Meredith Espinosa)
+MIT AND LGPL-3.0
-Copyright (c) 2024 Adrien1106
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE.LGPL-3.0

@@ -0,0 +1,165 @@
+GNU LESSER GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+
+This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+0. Additional Definitions.
+
+As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+"The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+a) under this License, provided that you make a good faith effort to
+ensure that, in the event an Application does not supply the
+function or data, the facility still operates, and performs
+whatever part of its purpose remains meaningful, or
+
+b) under the GNU GPL, with none of the additional permissions of
+this License applicable to that copy.
+
+3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+a) Give prominent notice with each copy of the object code that the
+Library is used in it and that the Library and its use are
+covered by this License.
+
+b) Accompany the object code with a copy of the GNU GPL and this license
+document.
+
+4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+a) Give prominent notice with each copy of the Combined Work that
+the Library is used in it and that the Library and its use are
+covered by this License.
+
+b) Accompany the Combined Work with a copy of the GNU GPL and this license
+document.
+
+c) For a Combined Work that displays copyright notices during
+execution, include the copyright notice for the Library among
+these notices, as well as a reference directing the user to the
+copies of the GNU GPL and this license document.
+
+d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+e) Provide Installation Information, but only if you would otherwise
+be required to provide such information under section 6 of the
+GNU GPL, and only to the extent that such information is
+necessary to install and execute a modified version of the
+Combined Work produced by recombining or relinking the
+Application with a modified version of the Linked Version. (If
+you use option 4d0, the Installation Information must accompany
+the Minimal Corresponding Source and Corresponding Application
+Code. If you use option 4d1, you must provide the Installation
+Information in the manner specified by section 6 of the GNU GPL
+for conveying Corresponding Source.)
+
+5. Combined Libraries.
+
+You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+a) Accompany the combined library with a copy of the same work based
+on the Library, uncombined with any other library facilities,
+conveyed under the terms of this License.
+
+b) Give prominent notice with the combined library that part of it
+is a work based on the Library, and explaining where to find the
+accompanying uncombined form of the same work.
+
+6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

LICENSE.MIT

@@ -0,0 +1,15 @@
+Copyright (c) 2019 B0undarybreaker (Meredith Espinosa)\
+Copyright (c) 2024 Adrien1106
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,43 @@
+# ReFramed
+## Overview
+This Project is an unofficial port of [FramedBlocks](https://github.com/XFactHD/FramedBlocks) 
+forked from [Templates 2](https://github.com/quat1024/templates-mod). 
+It aims to add the same mechanics as [FramedBlocks](https://github.com/XFactHD/FramedBlocks) into Fabric.
+
+For a complete Feature list please have a look at the [Modrinth](https://modrinth.com/mod/reframed) page.
+
+## Information
+### Where to get it?
+The mod can be downloaded on [Modrinth](https://modrinth.com/mod/reframed).
+
+### Issues/requests
+Any issues/requests may be addressed on this repository in the [Issues](https://github.com/DriHut/ReFramed/issues) section.
+
+### Out of date?
+I will be adding new shapes as time passes, but I am currently not planing on keeping up with the newer versions of the game.
+That said this mod is under permissive licenses and make it easy for anyone to create their own fork. 
+If anyone in the future plans to do so, I will gladly either link it from here and the modrinth page,
+or based on preferences add the person(s) to the project
+
+### What Shapes are planed to be added
+Currently, the list of shapes to be added is pretty simple as the mod is still under development:
+- Wall
+- Fence
+- Pane
+- Button
+- Pressure Plate
+- Trapdoor
+- Door
+- Carpet
+- Post
+- Half Slab (maybe redundant with Layer)
+- Slabs Stair (a stair with one end being of a second theme, might be done in multiple blocks)
+
+Any Ideas feel free to make a suggestion [here](https://github.com/DriHut/ReFramed/issues).
+
+## License
+This work is dual-licensed under MIT and LGPL 3.0 both applying to different part of this project:
+- The LGPL 3.0 license applies to all the textures that can be found in [`assets/reframed/textures`](src/main/resources/assets/reframed/textures)
+- The MIT license applied to everything else so including all the code present within this project
+
+`SPDX-License-Identifier: MIT AND LGPL-3.0`

build.gradle

@@ -110,11 +110,15 @@ dependencies {
 	modCompileOnly "earth.terrarium.athena:athena-fabric-${project.minecraft_version}:${project.athena_version}"
 	modRuntimeOnly "earth.terrarium.athena:athena-fabric-${project.minecraft_version}:${project.athena_version}"
 
+	// Continuity for connectedTextures
+	modCompileOnly "maven.modrinth:continuity:${project.continuity_version}"
+	modRuntimeOnly "maven.modrinth:continuity:${project.continuity_version}"
+
 	// Chipped to test athena implementation
 	modRuntimeOnly "com.teamresourceful.resourcefullib:resourcefullib-fabric-${project.minecraft_version}:2.4.7"
 	modRuntimeOnly "earth.terrarium.chipped:Chipped-fabric-${project.minecraft_version}:3.1.2"
 
-	// Fabric API. This is technically optional, but you probably want it anyway.
+	// Fabric API.
 	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
 }
 
@@ -126,6 +130,7 @@ processResources {
 	inputs.property "athena_version", project.athena_version
 	inputs.property "indium_version", project.indium_version
 	inputs.property "sodium_version", project.sodium_version
+	inputs.property "continuity_version", project.continuity_version
 	filteringCharset "UTF-8"
 
 	filesMatching("fabric.mod.json") {

gradle.properties

@@ -9,7 +9,7 @@ loader_version=0.15.6
 
 # Mod Properties
 modrinth_id = jCpoCBpn
-mod_version = 1.5
+mod_version = 1.5.6
 maven_group = fr.adrien1106
 archives_base_name = ReFramed
 mod_id = reframed
@@ -24,3 +24,4 @@ git_repo=ReFramed
 athena_version=3.3.0
 sodium_version=0.5.8
 indium_version=1.0.30
+continuity_version=3.0.0-beta.4+1.20.2

src/main/java/fr/adrien1106/reframed/ReFramed.java

@@ -1,6 +1,10 @@
 package fr.adrien1106.reframed;
 
 import fr.adrien1106.reframed.block.*;
+import fr.adrien1106.reframed.item.ReFramedHammerItem;
+import fr.adrien1106.reframed.item.ReFramedBlueprintItem;
+import fr.adrien1106.reframed.item.ReFramedBlueprintWrittenItem;
+import fr.adrien1106.reframed.item.ReFramedScrewdriverItem;
 import net.fabricmc.api.ModInitializer;
 import net.fabricmc.fabric.api.itemgroup.v1.FabricItemGroup;
 import net.fabricmc.fabric.api.object.builder.v1.block.entity.FabricBlockEntityTypeBuilder;
@@ -8,10 +12,7 @@ import net.minecraft.block.AbstractBlock;
 import net.minecraft.block.Block;
 import net.minecraft.block.Blocks;
 import net.minecraft.block.entity.BlockEntityType;
-import net.minecraft.item.BlockItem;
+import net.minecraft.item.*;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemGroup;
-import net.minecraft.item.ItemStack;
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.Registry;
 import net.minecraft.sound.BlockSoundGroup;
@@ -22,23 +23,26 @@ import net.minecraft.world.World;
 
 import java.util.ArrayList;
 import java.util.function.BiConsumer;
-import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static fr.adrien1106.reframed.util.blocks.BlockProperties.LIGHT;
 
 /**
  * TODO make block pairable by right click                                 -> for v1.6
- * TODO add Hammer from framed ( removes theme )                           -> for v1.5.5
+ * TODO Dynamic Ambient Occlusion                                          -> for v1.6
- * TODO add screwdriver ( iterate over theme states ) ?
- * TODO add blueprint for survival friendly copy paste of a theme.         -> for v1.5.5
  * TODO add minecraft models like wall fence etc                           -> for v1.6
  * TODO better connected textures                                          -> maybe v1.6 ?
+ * TODO support continuity overlays                                        -> not scheduled
  */
 public class ReFramed implements ModInitializer {
 	public static final String MODID = "reframed";
 
 	public static final ArrayList<Block> BLOCKS = new ArrayList<>();
 	public static Block CUBE, SMALL_CUBE, SMALL_CUBES_STEP, STAIR, HALF_STAIR, STAIRS_CUBE, HALF_STAIRS_SLAB, HALF_STAIRS_STAIR, SLAB, SLABS_CUBE, STEP, STEPS_SLAB, LAYER;
+
+	public static final ArrayList<Item> ITEMS = new ArrayList<>();
+	public static Item HAMMER, SCREWDRIVER, BLUEPRINT, BLUEPRINT_WRITTEN;
+
 	public static ItemGroup ITEM_GROUP;
 
 	public static BlockEntityType<ReFramedEntity> REFRAMED_BLOCK_ENTITY;
@@ -48,19 +52,24 @@ public class ReFramed implements ModInitializer {
 	
 	@Override
 	public void onInitialize() {
-		CUBE              = registerReFramed("cube"              , new ReFramedBlock(cp(Blocks.OAK_PLANKS)));
+		CUBE              = registerBlock("cube"              , new ReFramedBlock(cp(Blocks.OAK_PLANKS)));
-		SMALL_CUBE        = registerReFramed("small_cube"        , new ReFramedSmallCubeBlock(cp(Blocks.OAK_PLANKS)));
+		SMALL_CUBE        = registerBlock("small_cube"        , new ReFramedSmallCubeBlock(cp(Blocks.OAK_PLANKS)));
-	  	SMALL_CUBES_STEP  = registerReFramed("small_cubes_step"  , new ReFramedSmallCubesStepBlock(cp(Blocks.OAK_PLANKS)));
+	  	SMALL_CUBES_STEP  = registerBlock("small_cubes_step"  , new ReFramedSmallCubesStepBlock(cp(Blocks.OAK_PLANKS)));
-		STAIR             = registerReFramed("stair"             , new ReFramedStairBlock(cp(Blocks.OAK_STAIRS)));
+		STAIR             = registerBlock("stair"             , new ReFramedStairBlock(cp(Blocks.OAK_STAIRS)));
-		STAIRS_CUBE       = registerReFramed("stairs_cube"       , new ReFramedStairsCubeBlock(cp(Blocks.OAK_STAIRS)));
+		STAIRS_CUBE       = registerBlock("stairs_cube"       , new ReFramedStairsCubeBlock(cp(Blocks.OAK_STAIRS)));
-		HALF_STAIR        = registerReFramed("half_stair"        , new ReFramedHalfStairBlock(cp(Blocks.OAK_STAIRS)));
+		HALF_STAIR        = registerBlock("half_stair"        , new ReFramedHalfStairBlock(cp(Blocks.OAK_STAIRS)));
-		HALF_STAIRS_SLAB  = registerReFramed("half_stairs_slab"  , new ReFramedHalfStairsSlabBlock(cp(Blocks.OAK_STAIRS)));
+		HALF_STAIRS_SLAB  = registerBlock("half_stairs_slab"  , new ReFramedHalfStairsSlabBlock(cp(Blocks.OAK_STAIRS)));
-		HALF_STAIRS_STAIR = registerReFramed("half_stairs_stair" , new ReFramedHalfStairsStairBlock(cp(Blocks.OAK_STAIRS)));
+		HALF_STAIRS_STAIR = registerBlock("half_stairs_stair" , new ReFramedHalfStairsStairBlock(cp(Blocks.OAK_STAIRS)));
-		LAYER             = registerReFramed("layer"             , new ReFramedLayerBlock(cp(Blocks.OAK_SLAB)));
+		LAYER             = registerBlock("layer"             , new ReFramedLayerBlock(cp(Blocks.OAK_SLAB)));
-		SLAB              = registerReFramed("slab"              , new ReFramedSlabBlock(cp(Blocks.OAK_SLAB)));
+		SLAB              = registerBlock("slab"              , new ReFramedSlabBlock(cp(Blocks.OAK_SLAB)));
-		SLABS_CUBE        = registerReFramed("slabs_cube"        , new ReFramedSlabsCubeBlock(cp(Blocks.OAK_SLAB)));
+		SLABS_CUBE        = registerBlock("slabs_cube"        , new ReFramedSlabsCubeBlock(cp(Blocks.OAK_SLAB)));
-		STEP              = registerReFramed("step"              , new ReFramedStepBlock(cp(Blocks.OAK_SLAB)));
+		STEP              = registerBlock("step"              , new ReFramedStepBlock(cp(Blocks.OAK_SLAB)));
-		STEPS_SLAB        = registerReFramed("steps_slab"        , new ReFramedStepsSlabBlock(cp(Blocks.OAK_SLAB)));
+		STEPS_SLAB        = registerBlock("steps_slab"        , new ReFramedStepsSlabBlock(cp(Blocks.OAK_SLAB)));
+
+		HAMMER            = registerItem("hammer"             , new ReFramedHammerItem(new Item.Settings().maxCount(1)));
+		SCREWDRIVER       = registerItem("screwdriver"        , new ReFramedScrewdriverItem(new Item.Settings().maxCount(1)));
+		BLUEPRINT         = registerItem("blueprint"          , new ReFramedBlueprintItem(new Item.Settings()));
+		BLUEPRINT_WRITTEN = registerItem("blueprint_written"  , new ReFramedBlueprintWrittenItem(new Item.Settings().maxCount(1)));
 
 		REFRAMED_BLOCK_ENTITY = Registry.register(Registries.BLOCK_ENTITY_TYPE, id("camo"),
 			FabricBlockEntityTypeBuilder.create(
@@ -81,7 +90,12 @@ public class ReFramed implements ModInitializer {
 		ITEM_GROUP = Registry.register(Registries.ITEM_GROUP, id("tab"), FabricItemGroup.builder()
 			.displayName(Text.translatable("itemGroup.reframed.tab"))
 			.icon(() -> new ItemStack(SLAB))
-			.entries((ctx, e) -> e.addAll(BLOCKS.stream().map(ItemStack::new).collect(Collectors.toList()))).build()
+			.entries((ctx, e) -> e.addAll(
+				Stream.concat(
+					ITEMS.stream().filter(item -> item != BLUEPRINT_WRITTEN),
+					BLOCKS.stream().map(Block::asItem)
+				).map(Item::getDefaultStack).toList())
+			).build()
 		);
 	}
 
@@ -94,8 +108,15 @@ public class ReFramed implements ModInitializer {
 			.suffocates((a,b,c) -> false)
 			.blockVision((a,b,c) -> false);
 	}
+
+	private static <I extends Item> I registerItem(String path, I item) {
+		Identifier id = id(path);
+		Registry.register(Registries.ITEM, id, item);
+		ITEMS.add(item);
+		return item;
+	}
 	
-	private static <B extends Block> B registerReFramed(String path, B block) {
+	private static <B extends Block> B registerBlock(String path, B block) {
 		Identifier id = id(path);
 		
 		Registry.register(Registries.BLOCK, id, block);

src/main/java/fr/adrien1106/reframed/block/ReFramedDoubleBlock.java

@@ -31,8 +31,11 @@ public abstract class ReFramedDoubleBlock extends ReFramedBlock {
         return ReFramed.REFRAMED_DOUBLE_BLOCK_ENTITY.instantiate(pos, state);
     }
 
-    protected int getHitShape(BlockState state, BlockHitResult hit) {
+    public int getHitShape(BlockState state, BlockHitResult hit) {
-        Direction side = hit.getSide();
+        return getHitShape(state, hit.getPos(), hit.getBlockPos(), hit.getSide());
+    }
+
+    public int getHitShape(BlockState state, Vec3d hit, BlockPos pos, Direction side) {
         VoxelShape first_shape = getShape(state, 1);
         VoxelShape second_shape = getShape(state, 2);
 
@@ -40,10 +43,9 @@ public abstract class ReFramedDoubleBlock extends ReFramedBlock {
         if (isFaceFullSquare(first_shape, side)) return 1;
         if (isFaceFullSquare(second_shape, side)) return 2;
 
-        Vec3d pos = BlockHelper.getRelativePos(hit.getPos(), hit.getBlockPos());
+        Vec3d rel = BlockHelper.getRelativePos(hit, pos);
-//        System.out.println(side.getAxis().choose(hit.getPos().x, hit.getPos().y, hit.getPos().z));
+        if (BlockHelper.cursorMatchesFace(first_shape, rel)) return 1;
-        if (BlockHelper.cursorMatchesFace(first_shape, pos)) return 1;
+        if (BlockHelper.cursorMatchesFace(second_shape, rel)) return 2;
-        if (BlockHelper.cursorMatchesFace(second_shape, pos)) return 2;
         return 0;
     }
 

src/main/java/fr/adrien1106/reframed/client/ReFramedClient.java

@@ -105,7 +105,7 @@ public class ReFramedClient implements ClientModInitializer {
 		//supporting code for the TemplatesModelProvider
 		ModelLoadingRegistry.INSTANCE.registerResourceProvider(rm -> PROVIDER); //block models
 		ModelLoadingRegistry.INSTANCE.registerVariantProvider(rm -> PROVIDER); //item models
-		
+
 		ResourceManagerHelper.get(ResourceType.CLIENT_RESOURCES).registerReloadListener(new SimpleSynchronousResourceReloadListener() {
 			@Override public Identifier getFabricId() { return ReFramed.id("dump-caches"); }
 			@Override public void reload(ResourceManager blah) { PROVIDER.dumpCache(); }

src/main/java/fr/adrien1106/reframed/client/ReFramedModelProvider.java

@@ -70,6 +70,7 @@ public class ReFramedModelProvider implements ModelResourceProvider, ModelVarian
 	}
 	
 	public void dumpCache() {
+		CamoAppearanceManager.dumpCahe();
 		appearanceManager = null; //volatile write
 	}
 	

src/main/java/fr/adrien1106/reframed/client/model/DynamicBakedModel.java

@@ -4,7 +4,8 @@ import net.minecraft.block.BlockState;
 import net.minecraft.client.render.model.BakedModel;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.BlockRenderView;
+import org.jetbrains.annotations.Nullable;
 
 public interface DynamicBakedModel {
-    BakedModel computeQuads(BlockRenderView level, BlockState state, BlockPos pos, int theme_index);
+    BakedModel computeQuads(@Nullable BlockRenderView level, BlockState origin_state, @Nullable BlockPos pos, int theme_index);
 }

src/main/java/fr/adrien1106/reframed/client/model/apperance/CamoAppearanceManager.java

@@ -6,6 +6,7 @@ import fr.adrien1106.reframed.ReFramed;
 import fr.adrien1106.reframed.client.ReFramedClient;
 import fr.adrien1106.reframed.client.model.DynamicBakedModel;
 import fr.adrien1106.reframed.client.model.QuadPosBounds;
+import fr.adrien1106.reframed.compat.RebakedModel;
 import fr.adrien1106.reframed.mixin.model.WeightedBakedModelAccessor;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
@@ -39,6 +40,12 @@ import java.util.function.Function;
 @Environment(EnvType.CLIENT)
 public class CamoAppearanceManager {
 
+
+	protected static final SpriteIdentifier DEFAULT_SPRITE_MAIN = new SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, new Identifier(ReFramed.MODID, "block/framed_block"));
+	protected static final SpriteIdentifier DEFAULT_SPRITE_SECONDARY = new SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, new Identifier(ReFramed.MODID, "block/framed_accent_block"));
+	private static final SpriteIdentifier BARRIER_SPRITE_ID = new SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, new Identifier("minecraft:item/barrier"));
+	private static final Cache<BlockState, CamoAppearance> APPEARANCE_CACHE = CacheBuilder.newBuilder().maximumSize(2048).build();
+
 	public CamoAppearanceManager(Function<SpriteIdentifier, Sprite> spriteLookup) {
 		MaterialFinder finder = ReFramedClient.HELPER.getFabricRenderer().materialFinder();
 		for(BlendMode blend : BlendMode.values()) {
@@ -59,22 +66,20 @@ public class CamoAppearanceManager {
 		sprite = spriteLookup.apply(BARRIER_SPRITE_ID);
 		this.barrierItemAppearance = new SingleSpriteAppearance(sprite, materials.get(BlendMode.CUTOUT), serial_number.getAndIncrement());
 	}
-
-	protected static final SpriteIdentifier DEFAULT_SPRITE_MAIN = new SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, new Identifier(ReFramed.MODID, "block/framed_block"));
-	protected static final SpriteIdentifier DEFAULT_SPRITE_SECONDARY = new SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, new Identifier(ReFramed.MODID, "block/framed_accent_block"));
-	private static final SpriteIdentifier BARRIER_SPRITE_ID = new SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, new Identifier("minecraft:item/barrier"));
 	
 	private final CamoAppearance default_appearance;
 	private final CamoAppearance accent_appearance;
 	private final CamoAppearance barrierItemAppearance;
 
-	private static final Cache<BlockState, CamoAppearance> APPEARANCE_CACHE = CacheBuilder.newBuilder().maximumSize(2048).build();
-
 	private final AtomicInteger serial_number = new AtomicInteger(0); //Mutable
 	
 	private final EnumMap<BlendMode, RenderMaterial> ao_materials = new EnumMap<>(BlendMode.class);
 	private final EnumMap<BlendMode, RenderMaterial> materials = new EnumMap<>(BlendMode.class); //Immutable contents
-	
+
+	public static void dumpCahe() {
+		APPEARANCE_CACHE.invalidateAll();
+	}
+
 	public CamoAppearance getDefaultAppearance(int appearance) {
 		return appearance == 2 ? accent_appearance: default_appearance;
 	}
@@ -82,14 +87,18 @@ public class CamoAppearanceManager {
 	public CamoAppearance getCamoAppearance(BlockRenderView world, BlockState state, BlockPos pos, int theme_index, boolean item) {
 		BakedModel model = MinecraftClient.getInstance().getBlockRenderManager().getModel(state);
 
-		// add support for connected textures and more generally any compatible models injected so that they return baked quads
+		// add support for connected textures that uses dynamic baking
 		if (model instanceof DynamicBakedModel dynamic_model) {
 			// cache items as they get rendered more often
 			if (item && APPEARANCE_CACHE.asMap().containsKey(state)) return APPEARANCE_CACHE.getIfPresent(state);
 
-			CamoAppearance appearance = computeAppearance(dynamic_model.computeQuads(world, state, pos, theme_index), state);
+			model = dynamic_model.computeQuads(world, state, pos, theme_index);
-			if (item) APPEARANCE_CACHE.put(state, appearance);
+			// if model isn't rebaked its just wrapped (i.e. not dynamic and may be cached)
-			return appearance;
+			if (model instanceof RebakedModel) {
+				CamoAppearance appearance = computeAppearance(model, state);
+				if (item) APPEARANCE_CACHE.put(state, appearance);
+				return appearance;
+			}
 		}
 
 		// refresh cache

src/main/java/fr/adrien1106/reframed/client/util/RenderHelper.java

@@ -0,0 +1,177 @@
+package fr.adrien1106.reframed.client.util;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import fr.adrien1106.reframed.block.ReFramedBlock;
+import fr.adrien1106.reframed.client.ReFramedClient;
+import fr.adrien1106.reframed.client.model.QuadPosBounds;
+import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.fabric.api.renderer.v1.Renderer;
+import net.fabricmc.fabric.api.renderer.v1.material.RenderMaterial;
+import net.fabricmc.fabric.api.renderer.v1.mesh.QuadEmitter;
+import net.fabricmc.fabric.api.renderer.v1.model.ForwardingBakedModel;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.function.BooleanBiFunction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.util.math.random.Random;
+import net.minecraft.util.shape.VoxelShape;
+import net.minecraft.util.shape.VoxelShapes;
+import net.minecraft.world.BlockRenderView;
+import net.minecraft.world.BlockView;
+
+import java.util.List;
+import java.util.Objects;
+
+import static net.minecraft.util.shape.VoxelShapes.combine;
+
+@Environment(EnvType.CLIENT)
+public class RenderHelper {
+
+
+    // self culling cache of the models not made thread local so that it is only computed once
+    private static final Cache<CullElement, Integer[]> INNER_CULL_MAP = CacheBuilder.newBuilder().maximumSize(1024).build();
+    private record CullElement(Block block, Object state_key, int model) {}
+
+    /**
+     * compute which quad might cull with another model quad
+     * @param state - the state of the model
+     * @param models - list of models on the same block
+     */
+    public static void computeInnerCull(BlockState state, List<ForwardingBakedModel> models) {
+        if (!(state.getBlock() instanceof ReFramedBlock frame_block)) return;
+        Object key = frame_block.getModelCacheKey(state);
+        if (INNER_CULL_MAP.asMap().containsKey(new CullElement(frame_block, key, 1))) return;
+
+        Renderer r = ReFramedClient.HELPER.getFabricRenderer();
+        QuadEmitter quad_emitter = r.meshBuilder().getEmitter();
+        RenderMaterial material = r.materialFinder().clear().find();
+        Random random = Random.create();
+
+        List<List<QuadPosBounds>> model_bounds = models.stream()
+            .map(ForwardingBakedModel::getWrappedModel)
+            .filter(Objects::nonNull)
+            .map(wrapped -> wrapped.getQuads(state, null, random))
+            .map(quads -> quads.stream().map(quad -> {
+                quad_emitter.fromVanilla(quad, material, null);
+                return QuadPosBounds.read(quad_emitter, false);
+            }).toList()).toList();
+
+        Integer[] cull_array;
+        for(int self_id = 1; self_id <= model_bounds.size(); self_id++) {
+            List<QuadPosBounds> self_bounds = model_bounds.get(self_id - 1);
+            cull_array = new Integer[self_bounds.size()];
+            for (int self_quad = 0; self_quad < cull_array.length; self_quad++) {
+                QuadPosBounds self_bound = self_bounds.get(self_quad);
+                for(int other_id = 1; other_id <= model_bounds.size(); other_id++) {
+                    if (other_id == self_id) continue;
+                    if (model_bounds.get(other_id - 1).stream().anyMatch(other_bound -> other_bound.equals(self_bound))) {
+                        cull_array[self_quad] = other_id;
+                        break;
+                    }
+                }
+            }
+            INNER_CULL_MAP.put(new CullElement(frame_block, key, self_id), cull_array);
+        }
+    }
+
+    public static boolean shouldDrawInnerFace(BlockState state, BlockRenderView view, BlockPos pos, int quad_index, int theme_index) {
+        if ( !(state.getBlock() instanceof ReFramedBlock frame_block)
+            || !(view.getBlockEntity(pos) instanceof ThemeableBlockEntity frame_entity)
+        ) return true;
+        CullElement key = new CullElement(frame_block, frame_block.getModelCacheKey(state), theme_index);
+        if (!INNER_CULL_MAP.asMap().containsKey(key)) return true;
+
+        // needs to be Integer object because array is initialized with null not 0
+        Integer cull_theme = Objects.requireNonNull(INNER_CULL_MAP.getIfPresent(key))[quad_index];
+        if (cull_theme == null) return true; // no culling possible
+
+        BlockState self_theme = frame_entity.getTheme(theme_index);
+        BlockState other_theme = frame_entity.getTheme(cull_theme);
+
+        if (self_theme.isSideInvisible(other_theme, null)) return false;
+        return !self_theme.isOpaque() || !other_theme.isOpaque();
+    }
+
+    // Doing this method from scratch as it is simpler to do than injecting everywhere
+    public static boolean shouldDrawSide(BlockState self_state, BlockView world, BlockPos pos, Direction side, BlockPos other_pos, int theme_index) {
+        ThemeableBlockEntity self = world.getBlockEntity(pos) instanceof ThemeableBlockEntity e ? e : null;
+        ThemeableBlockEntity other = world.getBlockEntity(other_pos) instanceof ThemeableBlockEntity e ? e : null;
+        BlockState other_state = world.getBlockState(other_pos);
+
+        // normal behaviour
+        if (self == null && other == null) return Block.shouldDrawSide(self_state, world, pos, side, other_pos);
+
+        // self is a normal Block
+        if (self == null && other_state.getBlock() instanceof ReFramedBlock other_block) {
+            VoxelShape self_shape = self_state.getCullingShape(world, pos);
+            if (self_shape.isEmpty()) return true;
+
+            int i = 0;
+            VoxelShape other_shape = VoxelShapes.empty();
+            for (BlockState s: other.getThemes()) {
+                i++;
+                if (self_state.isSideInvisible(s, side) || s.isOpaque())
+                    other_shape = combine(
+                        other_shape,
+                        other_block
+                            .getShape(other_state, i)
+                            .getFace(side.getOpposite()),
+                        BooleanBiFunction.OR
+                    );
+            }
+
+            // determine if side needs to be rendered
+            return VoxelShapes.matchesAnywhere(self_shape, other_shape, BooleanBiFunction.ONLY_FIRST);
+        }
+
+        BlockState self_theme = self.getTheme(theme_index);
+        // other is normal Block
+        if (other == null && self_state.getBlock() instanceof ReFramedBlock self_block) {
+            // Transparent is simple if self and the neighbor are invisible don't render side (like default)
+            if (self_theme.isSideInvisible(other_state, side)) return false;
+
+            // Opaque is also simple as each model are rendered one by one
+            if (other_state.isOpaque()) {
+                // no cache section :( because it differs between each instance of the frame
+                VoxelShape self_shape = self_block.getShape(self_state, theme_index).getFace(side);
+                if (self_shape.isEmpty()) return true;
+                VoxelShape other_shape = other_state.getCullingFace(world, other_pos, side.getOpposite());
+
+                // determine if side needs to be rendered
+                return VoxelShapes.matchesAnywhere(self_shape, other_shape, BooleanBiFunction.ONLY_FIRST);
+            }
+
+            return true;
+        }
+
+        // Both are frames
+        // here both are computed in the same zone as there will necessarily a shape comparison
+        if (self_state.getBlock() instanceof ReFramedBlock self_block && other_state.getBlock() instanceof ReFramedBlock other_block) {
+            VoxelShape self_shape = self_block.getShape(self_state, theme_index).getFace(side);
+            if (self_shape.isEmpty()) return true;
+
+            int i = 0;
+            VoxelShape other_shape = VoxelShapes.empty();
+            for (BlockState s: other.getThemes()) {
+                i++;
+                if (self_theme.isSideInvisible(s, side) || s.isOpaque())
+                    other_shape = combine(
+                        other_shape,
+                        other_block
+                            .getShape(other_state, i)
+                            .getFace(side.getOpposite()),
+                        BooleanBiFunction.OR
+                    );
+            }
+
+            // determine if side needs to be rendered
+            return VoxelShapes.matchesAnywhere(self_shape, other_shape, BooleanBiFunction.ONLY_FIRST);
+        }
+
+        return true;
+    }
+}

src/main/java/fr/adrien1106/reframed/compat/ICTMQuadTransform.java

@@ -0,0 +1,22 @@
+package fr.adrien1106.reframed.compat;
+
+import me.pepperbell.continuity.client.model.QuadProcessors;
+import me.pepperbell.continuity.impl.client.ProcessingContextImpl;
+import net.fabricmc.fabric.api.renderer.v1.render.RenderContext;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.texture.Sprite;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.random.Random;
+import net.minecraft.world.BlockRenderView;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public interface ICTMQuadTransform extends RenderContext.QuadTransform {
+
+    void invokePrepare(BlockRenderView view, BlockState state, BlockPos pos, Supplier<Random> random, boolean manual_culling, Function<Sprite, QuadProcessors.Slice> slice);
+
+    ProcessingContextImpl getProcessingContext();
+
+    void invokeReset();
+}

src/main/java/fr/adrien1106/reframed/compat/RebakedModel.java

@@ -12,10 +12,10 @@ import net.minecraft.util.math.random.Random;
 import java.util.List;
 import java.util.Map;
 
-public class RebakedAthenaModel implements BakedModel {
+public class RebakedModel implements BakedModel {
     protected final Map<Direction, List<BakedQuad>> face_quads;
 
-    public RebakedAthenaModel(Map<Direction, List<BakedQuad>> face_quads) {
+    public RebakedModel(Map<Direction, List<BakedQuad>> face_quads) {
         this.face_quads = face_quads;
     }
 
@@ -26,7 +26,7 @@ public class RebakedAthenaModel implements BakedModel {
 
     @Override
     public boolean useAmbientOcclusion() {
-        return false;
+        return true;
     }
 
     @Override
@@ -51,11 +51,11 @@ public class RebakedAthenaModel implements BakedModel {
 
     @Override
     public ModelTransformation getTransformation() {
-        return null;
+        return ModelTransformation.NONE;
     }
 
     @Override
     public ModelOverrideList getOverrides() {
-        return null;
+        return ModelOverrideList.EMPTY;
     }
 }

src/main/java/fr/adrien1106/reframed/generator/GBlockstate.java

@@ -38,7 +38,9 @@ public class GBlockstate extends FabricModelProvider {
     }
 
     @Override
-    public void generateItemModels(ItemModelGenerator itemModelGenerator) {}
+    public void generateItemModels(ItemModelGenerator model_generator) {
+        ReFramed.ITEMS.forEach(item -> model_generator.register(item, Models.GENERATED));
+    }
 
     public static BlockStateVariant variant(Identifier model, boolean uv_lock, VariantSettings.Rotation x, VariantSettings.Rotation y) {
         BlockStateVariant variant = BlockStateVariant.create().put(VariantSettings.MODEL, model);

src/main/java/fr/adrien1106/reframed/generator/GLanguage.java

@@ -18,6 +18,7 @@ public class GLanguage extends FabricLanguageProvider {
         builder.add(Registries.ITEM_GROUP.getKey(ReFramed.ITEM_GROUP).get(), "Frames");
         builder.add("advancements.reframed.description", "Get all the frame types.");
         ReFramed.BLOCKS.forEach(block -> builder.add(block, beautify(Registries.BLOCK.getId(block).getPath()) + " Frame"));
+        ReFramed.ITEMS.forEach(block -> builder.add(block, beautify(Registries.ITEM.getId(block).getPath())));
     }
 
     private static String beautify(String name) {

src/main/java/fr/adrien1106/reframed/generator/GRecipe.java

@@ -15,5 +15,8 @@ public class GRecipe extends FabricRecipeProvider {
         ReFramed.BLOCKS.forEach(block -> {
             if (block instanceof RecipeSetter provider) provider.setRecipe(exporter);
         });
+        ReFramed.ITEMS.forEach(item -> {
+            if (item instanceof RecipeSetter provider) provider.setRecipe(exporter);
+        });
     }
 }

src/main/java/fr/adrien1106/reframed/item/ReFramedBlueprintItem.java

@@ -0,0 +1,55 @@
+package fr.adrien1106.reframed.item;
+
+import fr.adrien1106.reframed.ReFramed;
+import fr.adrien1106.reframed.block.ReFramedEntity;
+import fr.adrien1106.reframed.generator.RecipeSetter;
+import net.fabricmc.fabric.api.datagen.v1.provider.FabricRecipeProvider;
+import net.minecraft.block.Blocks;
+import net.minecraft.data.server.recipe.RecipeExporter;
+import net.minecraft.data.server.recipe.ShapedRecipeJsonBuilder;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUsageContext;
+import net.minecraft.item.Items;
+import net.minecraft.recipe.book.RecipeCategory;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.sound.SoundEvents;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class ReFramedBlueprintItem extends Item implements RecipeSetter {
+    public ReFramedBlueprintItem(Settings settings) {
+        super(settings);
+    }
+
+    @Override
+    public ActionResult useOnBlock(ItemUsageContext context) {
+        BlockPos pos = context.getBlockPos();
+        World world = context.getWorld();
+        if (!(world.getBlockEntity(pos) instanceof ReFramedEntity frame_entity)
+            || frame_entity.getThemes().stream().noneMatch(state -> state.getBlock() != Blocks.AIR)
+        ) return ActionResult.PASS;
+
+        context.getStack().decrement(1);
+        ItemStack stack = ReFramed.BLUEPRINT_WRITTEN.getDefaultStack();
+        frame_entity.setStackNbt(stack);
+        context.getPlayer().giveItemStack(stack);
+        world.playSound(context.getPlayer(), context.getPlayer().getBlockPos(), SoundEvents.ITEM_BOOK_PUT, SoundCategory.PLAYERS);
+
+        return ActionResult.SUCCESS;
+    }
+
+    @Override
+    public void setRecipe(RecipeExporter exporter) {
+        ShapedRecipeJsonBuilder
+            .create(RecipeCategory.BUILDING_BLOCKS, this, 3)
+            .pattern("PI")
+            .pattern("PP")
+            .input('P', Items.PAPER)
+            .input('I', Items.INK_SAC)
+            .criterion(FabricRecipeProvider.hasItem(Items.PAPER), FabricRecipeProvider.conditionsFromItem(Items.PAPER))
+            .criterion(FabricRecipeProvider.hasItem(this), FabricRecipeProvider.conditionsFromItem(this))
+            .offerTo(exporter);
+    }
+}

src/main/java/fr/adrien1106/reframed/item/ReFramedBlueprintWrittenItem.java

@@ -0,0 +1,113 @@
+package fr.adrien1106.reframed.item;
+
+import fr.adrien1106.reframed.ReFramed;
+import fr.adrien1106.reframed.block.ReFramedEntity;
+import net.minecraft.block.AbstractBlock;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.client.item.TooltipContext;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUsageContext;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtHelper;
+import net.minecraft.registry.Registries;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.sound.SoundEvents;
+import net.minecraft.text.Text;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Formatting;
+import net.minecraft.util.Hand;
+import net.minecraft.util.TypedActionResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static fr.adrien1106.reframed.block.ReFramedEntity.BLOCKSTATE_KEY;
+
+public class ReFramedBlueprintWrittenItem extends Item {
+    public ReFramedBlueprintWrittenItem(Settings settings) {
+        super(settings);
+    }
+
+    @Override
+    public TypedActionResult<ItemStack> use(World world, PlayerEntity player, Hand hand) {
+        ItemStack stack = player.getStackInHand(hand);
+        if (!player.isSneaking() || !stack.hasNbt()) return super.use(world, player, hand);
+        stack.decrement(1);
+        player.giveItemStack(ReFramed.BLUEPRINT.getDefaultStack());
+        world.playSound(player, player.getBlockPos(), SoundEvents.ITEM_BOOK_PUT, SoundCategory.PLAYERS);
+
+        return TypedActionResult.success(stack);
+    }
+
+    @Override
+    public ActionResult useOnBlock(ItemUsageContext context) {
+        BlockPos pos = context.getBlockPos();
+        World world = context.getWorld();
+        if (!(world.getBlockEntity(pos) instanceof ReFramedEntity frame_entity)
+            || frame_entity.getThemes().stream().anyMatch(state -> state.getBlock() != Blocks.AIR)
+            || !context.getStack().hasNbt()
+        ) return ActionResult.PASS;
+
+        NbtCompound tag = BlockItem.getBlockEntityNbt(context.getStack());
+        if(tag == null) return ActionResult.FAIL;
+
+        PlayerEntity player = context.getPlayer();
+        if (!player.isCreative()) { // verify player has blocks and remove them
+            PlayerInventory inventory = player.getInventory();
+            List<ItemStack> stacks = getBlockStates(tag).values().stream()
+                .map(AbstractBlock.AbstractBlockState::getBlock)
+                .map(Block::asItem)
+                .map(Item::getDefaultStack)
+                .toList();
+            if (stacks.stream().anyMatch(stack -> !inventory.contains(stack)))
+                return ActionResult.FAIL;
+            stacks.stream().map(inventory::getSlotWithStack).forEach(index -> inventory.removeStack(index, 1));
+            player.playSound(SoundEvents.ENTITY_ITEM_PICKUP, 0.5f, 0.5f);
+        }
+        frame_entity.readNbt(tag);
+        world.playSound(player, player.getBlockPos(), SoundEvents.ITEM_BOOK_PAGE_TURN, SoundCategory.PLAYERS);
+
+        return ActionResult.SUCCESS;
+    }
+
+    @Override
+    public void appendTooltip(ItemStack stack, @Nullable World world, List<Text> tooltip, TooltipContext context) {
+        NbtCompound tag = BlockItem.getBlockEntityNbt(stack);
+        if(tag == null) return;
+
+        Map<Integer, BlockState> states = getBlockStates(tag);
+        states.forEach((index, state) -> tooltip.add(
+            Text.literal("Theme " + index + ": ")
+                .append(
+                    Text.translatable(state.getBlock().getTranslationKey())
+                        .formatted(Formatting.GRAY)
+                )
+        ));
+        super.appendTooltip(stack, world, tooltip, context);
+    }
+
+    private static Map<Integer, BlockState> getBlockStates(NbtCompound tag) {
+        return tag.getKeys().stream()
+            .filter(key ->
+                key.startsWith(BLOCKSTATE_KEY)
+                && key.replace(BLOCKSTATE_KEY,"").chars().allMatch(Character::isDigit)
+            )
+            .collect(Collectors.toMap(
+                key -> Integer.parseInt(key.substring(BLOCKSTATE_KEY.length())),
+                key -> NbtHelper.toBlockState(
+                    Registries.BLOCK.getReadOnlyWrapper(),
+                    tag.getCompound(key)
+                )
+            ));
+    }
+}

src/main/java/fr/adrien1106/reframed/item/ReFramedHammerItem.java

@@ -0,0 +1,70 @@
+package fr.adrien1106.reframed.item;
+
+import fr.adrien1106.reframed.ReFramed;
+import fr.adrien1106.reframed.block.ReFramedDoubleBlock;
+import fr.adrien1106.reframed.generator.RecipeSetter;
+import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
+import net.fabricmc.fabric.api.datagen.v1.provider.FabricRecipeProvider;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.data.server.recipe.RecipeExporter;
+import net.minecraft.data.server.recipe.ShapedRecipeJsonBuilder;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUsageContext;
+import net.minecraft.item.Items;
+import net.minecraft.recipe.book.RecipeCategory;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.sound.SoundEvents;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class ReFramedHammerItem extends Item implements RecipeSetter {
+    public ReFramedHammerItem(Settings settings) {
+        super(settings);
+    }
+
+    @Override
+    public ActionResult useOnBlock(ItemUsageContext context) {
+        World world = context.getWorld();
+        BlockPos pos = context.getBlockPos();
+        if (!(world.getBlockEntity(pos) instanceof ThemeableBlockEntity frame_entity)) return ActionResult.PASS;
+        BlockState state = world.getBlockState(pos);
+        PlayerEntity player = context.getPlayer();
+        int theme_index = state.getBlock() instanceof ReFramedDoubleBlock b
+            ? b.getHitShape(
+            state,
+            context.getHitPos(),
+            context.getBlockPos(),
+            context.getSide()
+        )
+            : 1;
+
+        if (frame_entity.getTheme(theme_index).getBlock() == Blocks.AIR) return ActionResult.PASS;
+
+        if (!player.isCreative()) {
+            player.giveItemStack(new ItemStack(frame_entity.getTheme(theme_index).getBlock()));
+            world.playSound(player, pos, SoundEvents.ENTITY_ITEM_PICKUP, SoundCategory.BLOCKS, 1f, 1.1f);
+        }
+        frame_entity.setTheme(Blocks.AIR.getDefaultState(), theme_index);
+        ReFramed.chunkRerenderProxy.accept(world, pos);
+        return ActionResult.SUCCESS;
+    }
+
+    @Override
+    public void setRecipe(RecipeExporter exporter) {
+        ShapedRecipeJsonBuilder
+            .create(RecipeCategory.BUILDING_BLOCKS, this)
+            .pattern(" CI")
+            .pattern(" ~C")
+            .pattern("~  ")
+            .input('I', Items.IRON_INGOT)
+            .input('C', ReFramed.CUBE)
+            .input('~', Items.STICK)
+            .criterion(FabricRecipeProvider.hasItem(ReFramed.CUBE), FabricRecipeProvider.conditionsFromItem(ReFramed.CUBE))
+            .criterion(FabricRecipeProvider.hasItem(this), FabricRecipeProvider.conditionsFromItem(this))
+            .offerTo(exporter);
+    }
+}

src/main/java/fr/adrien1106/reframed/item/ReFramedScrewdriverItem.java

@@ -0,0 +1,78 @@
+package fr.adrien1106.reframed.item;
+
+import fr.adrien1106.reframed.ReFramed;
+import fr.adrien1106.reframed.block.ReFramedDoubleBlock;
+import fr.adrien1106.reframed.generator.RecipeSetter;
+import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
+import net.fabricmc.fabric.api.datagen.v1.provider.FabricRecipeProvider;
+import net.minecraft.block.BlockState;
+import net.minecraft.data.server.recipe.RecipeExporter;
+import net.minecraft.data.server.recipe.ShapedRecipeJsonBuilder;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemUsageContext;
+import net.minecraft.item.Items;
+import net.minecraft.recipe.book.RecipeCategory;
+import net.minecraft.sound.BlockSoundGroup;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.state.property.Properties;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+
+public class ReFramedScrewdriverItem extends Item implements RecipeSetter {
+
+    public ReFramedScrewdriverItem(Settings settings) {
+        super(settings);
+    }
+
+    @Override
+    public ActionResult useOnBlock(ItemUsageContext context) {
+        World world = context.getWorld();
+        BlockPos pos = context.getBlockPos();
+        if (!(world.getBlockEntity(pos) instanceof ThemeableBlockEntity frame_entity)) return ActionResult.PASS;
+        BlockState state = world.getBlockState(pos);
+        PlayerEntity player = context.getPlayer();
+        int theme_index = state.getBlock() instanceof ReFramedDoubleBlock b
+            ? b.getHitShape(
+                state,
+                context.getHitPos(),
+                context.getBlockPos(),
+                context.getSide()
+            )
+            : 1;
+
+
+        BlockState theme = frame_entity.getTheme(theme_index);
+        if (!theme.contains(Properties.AXIS)) return ActionResult.PASS;
+
+        Direction.Axis axis = theme.get(Properties.AXIS);
+        BlockSoundGroup group = theme.getSoundGroup();
+        world.playSound(player, pos, group.getPlaceSound(), SoundCategory.BLOCKS, group.getVolume(), group.getPitch());
+        frame_entity.setTheme(theme.with(
+            Properties.AXIS,
+            switch (axis) {
+                case X -> Direction.Axis.Y;
+                case Y -> Direction.Axis.Z;
+                case Z -> Direction.Axis.X;
+            }
+        ), theme_index);
+        ReFramed.chunkRerenderProxy.accept(world, pos);
+        return ActionResult.SUCCESS;
+    }
+
+    @Override
+    public void setRecipe(RecipeExporter exporter) {
+        ShapedRecipeJsonBuilder
+            .create(RecipeCategory.BUILDING_BLOCKS, this)
+            .pattern("  I")
+            .pattern(" I ")
+            .pattern("C  ")
+            .input('I', Items.IRON_INGOT)
+            .input('C', ReFramed.CUBE)
+            .criterion(FabricRecipeProvider.hasItem(ReFramed.CUBE), FabricRecipeProvider.conditionsFromItem(ReFramed.CUBE))
+            .criterion(FabricRecipeProvider.hasItem(this), FabricRecipeProvider.conditionsFromItem(this))
+            .offerTo(exporter);
+    }
+}

src/main/java/fr/adrien1106/reframed/mixin/CompatMixinPlugin.java

@@ -7,6 +7,7 @@ import org.slf4j.LoggerFactory;
 import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
 import org.spongepowered.asm.mixin.extensibility.IMixinInfo;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -16,24 +17,27 @@ public class CompatMixinPlugin implements IMixinConfigPlugin {
 
     private static final FabricLoader LOADER = FabricLoader.getInstance();
     private static final Logger LOGGER = LoggerFactory.getLogger("ReFramed MIXIN");
-    private static final List<String> COMPAT_MOD = List.of("athena", "indium", "sodium");
+    private static final List<String> COMPAT_MOD = List.of("athena", "indium", "sodium", "special-model-loader", "continuity");
-    private static final Map<String, Supplier<Boolean>> CONDITIONS = Map.of(
+    private static final Map<String, Supplier<Boolean>> CONDITIONS = new HashMap<>();
-        "fr.adrien1106.reframed.mixin.compat.AthenaBakedModelMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(0)),
+    static {
-        "fr.adrien1106.reframed.mixin.compat.AthenaWrappedGetterMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(0)),
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.AthenaBakedModelMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(0)));
-        "fr.adrien1106.reframed.mixin.render.TerrainRenderContextMixin", () -> !LOADER.isModLoaded(COMPAT_MOD.get(1)),
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.AthenaWrappedGetterMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(0)));
-        "fr.adrien1106.reframed.mixin.render.BlockRenderInfoMixin", () -> !LOADER.isModLoaded(COMPAT_MOD.get(1)),
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.render.TerrainRenderContextMixin", () -> !LOADER.isModLoaded(COMPAT_MOD.get(1)));
-        "fr.adrien1106.reframed.mixin.render.AbstractBlockRenderContextMixin", () -> !LOADER.isModLoaded(COMPAT_MOD.get(1)),
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.render.BlockRenderInfoMixin", () -> !LOADER.isModLoaded(COMPAT_MOD.get(1)));
-        "fr.adrien1106.reframed.mixin.compat.IndiumTerrainRenderContextMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(1)),
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.render.AbstractBlockRenderContextMixin", () -> !LOADER.isModLoaded(COMPAT_MOD.get(1)));
-        "fr.adrien1106.reframed.mixin.compat.IndiumTerrainBlockRenderInfoMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(1)),
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.IndiumTerrainRenderContextMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(1)));
-        "fr.adrien1106.reframed.mixin.compat.IndiumAbstractBlockRenderContextMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(1)),
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.IndiumTerrainBlockRenderInfoMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(1)));
-        "fr.adrien1106.reframed.mixin.compat.SodiumBlockOcclusionCacheMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(2))
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.IndiumAbstractBlockRenderContextMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(1)));
-    );
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.SodiumBlockOcclusionCacheMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(2)));
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.ContinuityConnectionPredicateMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(4)));
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.ContinuityCTMBakedModelMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(4)));
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.ContinuityCTMQuadTransformMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(4)));
+        CONDITIONS.put("fr.adrien1106.reframed.mixin.compat.ContinuityModelWrappingHandlerMixin", () -> LOADER.isModLoaded(COMPAT_MOD.get(4)));
+    }
 
 
     @Override
-    public void onLoad(String mixin_package) {
+    public void onLoad(String mixin_package) {}
-
-    }
 
     @Override
     public String getRefMapperConfig() {
@@ -46,9 +50,7 @@ public class CompatMixinPlugin implements IMixinConfigPlugin {
     }
 
     @Override
-    public void acceptTargets(Set<String> mine, Set<String> others) {
+    public void acceptTargets(Set<String> mine, Set<String> others) {}
-
-    }
 
     @Override
     public List<String> getMixins() {
@@ -56,9 +58,7 @@ public class CompatMixinPlugin implements IMixinConfigPlugin {
     }
 
     @Override
-    public void preApply(String target_class_name, ClassNode target_class, String mixin_class_name, IMixinInfo mixin_info) {
+    public void preApply(String target_class_name, ClassNode target_class, String mixin_class_name, IMixinInfo mixin_info) {}
-
-    }
 
     @Override
     public void postApply(String target_class, ClassNode target, String mixin_class, IMixinInfo mixin_info) {

src/main/java/fr/adrien1106/reframed/mixin/compat/AthenaBakedModelMixin.java

@@ -5,7 +5,7 @@ import earth.terrarium.athena.api.client.fabric.WrappedGetter;
 import earth.terrarium.athena.api.client.models.AthenaBlockModel;
 import fr.adrien1106.reframed.client.ReFramedClient;
 import fr.adrien1106.reframed.client.model.DynamicBakedModel;
-import fr.adrien1106.reframed.compat.RebakedAthenaModel;
+import fr.adrien1106.reframed.compat.RebakedModel;
 import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import net.fabricmc.fabric.api.renderer.v1.Renderer;
@@ -18,6 +18,7 @@ import net.minecraft.client.texture.Sprite;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
 import net.minecraft.world.BlockRenderView;
+import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -35,27 +36,27 @@ public abstract class AthenaBakedModelMixin implements DynamicBakedModel, BakedM
      * Reuses the emitQuad method to compute the quads to be used by the frame
      *
      * @param level - the world
-     * @param state - the current block camo
+     * @param origin_state - the current block camo
      * @param pos   - the block position
      * @return - the rebakedmodel containing the computed quads
      */
     @Override
-    public BakedModel computeQuads(BlockRenderView level, BlockState state, BlockPos pos, int theme_index) {
+    public BakedModel computeQuads(@Nullable BlockRenderView level, BlockState origin_state, @Nullable BlockPos pos, int theme_index) {
         Map<Direction, List<BakedQuad>> face_quads = new HashMap<>();
         Renderer r = ReFramedClient.HELPER.getFabricRenderer();
         QuadEmitter emitter = r.meshBuilder().getEmitter();
 
         WrappedGetter getter = new WrappedGetter(level);
+        BlockState state = level != null && pos != null
+            && level.getBlockEntity(pos) instanceof ThemeableBlockEntity framed_entity
+            ? framed_entity.getTheme(theme_index)
+            : origin_state;
         Arrays.stream(Direction.values()).forEach(direction -> {
             face_quads.put(direction, new ArrayList<>());
 
             (level == null || pos == null
                 ? model.getDefaultQuads(direction).get(direction)
-                : model.getQuads(
+                : model.getQuads(getter, state, pos, direction)
-                    getter,
-                    level.getBlockEntity(pos) instanceof ThemeableBlockEntity framed_entity
-                        ? framed_entity.getTheme(theme_index)
-                        : state, pos, direction)
                 ).forEach(sprite -> face_quads.computeIfPresent(direction, (d, quads) -> {
                     Sprite texture = textures.get(sprite.sprite());
                     if (texture == null) return quads;
@@ -76,6 +77,6 @@ public abstract class AthenaBakedModelMixin implements DynamicBakedModel, BakedM
                 }));
         });
 
-        return new RebakedAthenaModel(face_quads);
+        return new RebakedModel(face_quads);
     }
 }

src/main/java/fr/adrien1106/reframed/mixin/compat/AthenaWrappedGetterMixin.java

@@ -13,10 +13,13 @@ import org.spongepowered.asm.mixin.injection.Redirect;
 @Mixin(WrappedGetter.class)
 public class AthenaWrappedGetterMixin {
 
-    @Redirect(method = "query",
+    @Redirect(
-        at = @At(value = "INVOKE", target = "Lnet/minecraft/world/BlockRenderView;" +
+        method = "query",
-            "getBlockState(Lnet/minecraft/util/math/BlockPos;)" +
+        at = @At(
-            "Lnet/minecraft/block/BlockState;"))
+            value = "INVOKE",
+            target = "Lnet/minecraft/world/BlockRenderView;getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/BlockState;"
+        )
+    ) // TODO better connected textures
     private BlockState queryCamoState(BlockRenderView world, BlockPos pos, @Local(argsOnly = true) BlockState reference_state) {
         // get Any that will connect or return any other (/!\ isOf is an uncertain check)
         if (world.getBlockEntity(pos) instanceof ThemeableBlockEntity framed_entity)

src/main/java/fr/adrien1106/reframed/mixin/compat/ContinuityCTMBakedModelMixin.java

@@ -0,0 +1,94 @@
+package fr.adrien1106.reframed.mixin.compat;
+
+import fr.adrien1106.reframed.client.ReFramedClient;
+import fr.adrien1106.reframed.client.model.DynamicBakedModel;
+import fr.adrien1106.reframed.compat.ICTMQuadTransform;
+import fr.adrien1106.reframed.compat.RebakedModel;
+import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
+import me.pepperbell.continuity.client.config.ContinuityConfig;
+import me.pepperbell.continuity.client.model.CTMBakedModel;
+import me.pepperbell.continuity.client.model.ModelObjectsContainer;
+import me.pepperbell.continuity.client.model.QuadProcessors;
+import me.pepperbell.continuity.client.util.RenderUtil;
+import net.fabricmc.fabric.api.renderer.v1.Renderer;
+import net.fabricmc.fabric.api.renderer.v1.mesh.QuadEmitter;
+import net.fabricmc.fabric.api.renderer.v1.model.ForwardingBakedModel;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.BakedQuad;
+import net.minecraft.client.texture.Sprite;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.util.math.random.Random;
+import net.minecraft.world.BlockRenderView;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+@Mixin(CTMBakedModel.class)
+public abstract class ContinuityCTMBakedModelMixin extends ForwardingBakedModel implements DynamicBakedModel {
+
+    @Shadow protected abstract Function<Sprite, QuadProcessors.Slice> getSliceFunc(BlockState state);
+
+    @Override
+    public BakedModel computeQuads(@Nullable BlockRenderView level, BlockState origin_state, @Nullable BlockPos pos, int theme_index) {
+        if (wrapped instanceof DynamicBakedModel wrapped_dynamic) // support wrap of dynamic models
+            return wrapped_dynamic.computeQuads(level, origin_state, pos, theme_index);
+
+
+        ModelObjectsContainer container = ModelObjectsContainer.get();
+        // normally baked model / wrapped or feature disabled or item (i.e. no need to compute quads)
+        if (level == null || pos == null
+            || !ContinuityConfig.INSTANCE.connectedTextures.get()
+            || !container.featureStates.getConnectedTexturesState().isEnabled()
+        ) return wrapped;
+
+        Map<Direction, List<BakedQuad>> face_quads = new HashMap<>();
+
+        Renderer r = ReFramedClient.HELPER.getFabricRenderer();
+        QuadEmitter emitter = r.meshBuilder().getEmitter();
+
+        // get applicable state
+        BlockState state = level.getBlockEntity(pos) instanceof ThemeableBlockEntity framed_entity
+            ? framed_entity.getTheme(theme_index)
+            : origin_state;
+
+        // get random supplier
+        Random random = Random.create();
+        Supplier<Random> random_supplier = () -> {
+            random.setSeed(state.getRenderingSeed(pos));
+            return random;
+        };
+
+        // get quad transform and prepare
+        ICTMQuadTransform transform = ((ICTMQuadTransform) container.ctmQuadTransform);
+        transform.invokePrepare(
+            level,
+            state,
+            pos,
+            random_supplier,
+            ContinuityConfig.INSTANCE.useManualCulling.get(),
+            getSliceFunc(state)
+        );
+        Arrays.stream(Direction.values()).forEach(direction -> {
+            face_quads.put(direction, new ArrayList<>());
+
+            wrapped.getQuads(state, direction, random_supplier.get()).forEach(quad -> face_quads.computeIfPresent(direction, (d, quads) -> {
+                emitter.fromVanilla(quad, emitter.material(), direction);
+                transform.transform(emitter);
+                quads.add(emitter.toBakedQuad(RenderUtil.getSpriteFinder().find(emitter)));
+                return quads;
+            }));
+//            transform.getProcessingContext().getExtraQuadEmitter(); // TODO start here for overlay support
+        });
+
+        transform.getProcessingContext().reset(); // reset instead of outputting to emitter
+        transform.invokeReset();
+
+        return new RebakedModel(face_quads);
+    }
+}

src/main/java/fr/adrien1106/reframed/mixin/compat/ContinuityCTMQuadTransformMixin.java

@@ -0,0 +1,56 @@
+package fr.adrien1106.reframed.mixin.compat;
+
+import fr.adrien1106.reframed.compat.ICTMQuadTransform;
+import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
+import me.pepperbell.continuity.client.model.CullingCache;
+import me.pepperbell.continuity.client.model.QuadProcessors;
+import me.pepperbell.continuity.impl.client.ProcessingContextImpl;
+import net.fabricmc.fabric.api.renderer.v1.mesh.QuadView;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.texture.Sprite;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.random.Random;
+import net.minecraft.world.BlockRenderView;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+@Mixin(targets = "me.pepperbell.continuity.client.model.CTMBakedModel$CTMQuadTransform")
+public abstract class ContinuityCTMQuadTransformMixin implements ICTMQuadTransform {
+    @Shadow(remap = false) @Final protected ProcessingContextImpl processingContext;
+
+    @Shadow public abstract void prepare(BlockRenderView view, BlockState state, BlockPos pos, Supplier<Random> random, boolean manual_culling, Function<Sprite, QuadProcessors.Slice> slice);
+    @Shadow(remap = false) public abstract void reset();
+
+    @Redirect(
+        method = "transform",
+        at = @At(
+            value = "INVOKE",
+            target = "Lme/pepperbell/continuity/client/model/CullingCache;shouldCull(Lnet/fabricmc/fabric/api/renderer/v1/mesh/QuadView;Lnet/minecraft/world/BlockRenderView;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;)Z"
+        )
+    )
+    private boolean camo_replacement(CullingCache cache, QuadView quad, BlockRenderView view, BlockPos pos, BlockState state) {
+        if (view.getBlockEntity(pos) instanceof ThemeableBlockEntity) return false;
+        return cache.shouldCull(quad, view, pos, state);
+    }
+
+    // uses this because invoker did not want to work for some reason
+    public void invokePrepare(BlockRenderView view, BlockState state, BlockPos pos, Supplier<Random> random, boolean manual_culling, Function<Sprite, QuadProcessors.Slice> slice) {
+        prepare(view, state, pos, random, manual_culling, slice);
+    }
+
+    @Override
+    public ProcessingContextImpl getProcessingContext() {
+        return processingContext;
+    }
+
+    @Override
+    public void invokeReset() {
+        reset();
+    }
+}

src/main/java/fr/adrien1106/reframed/mixin/compat/ContinuityConnectionPredicateMixin.java

@@ -0,0 +1,32 @@
+package fr.adrien1106.reframed.mixin.compat;
+
+import com.llamalad7.mixinextras.sugar.Local;
+import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
+import me.pepperbell.continuity.client.processor.ConnectionPredicate;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.BlockRenderView;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+@Mixin(ConnectionPredicate.class)
+public interface ContinuityConnectionPredicateMixin {
+
+    @Redirect(
+        method = "shouldConnect(Lnet/minecraft/world/BlockRenderView;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/math/Direction;Lnet/minecraft/client/texture/Sprite;)Z",
+        at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/world/BlockRenderView;getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/BlockState;"
+        )
+    ) // TODO better connected textures
+    private BlockState getBlockState(BlockRenderView view, BlockPos pos, @Local(argsOnly = true) BlockState state) {
+        if (!(view.getBlockEntity(pos) instanceof ThemeableBlockEntity frame_entity)) return view.getBlockState(pos);
+        return frame_entity.getThemes()
+            .stream()
+            .filter(theme -> theme.getBlock() == state.getBlock())
+            .findFirst()
+            .orElse(frame_entity.getTheme(0));
+    }
+
+}

src/main/java/fr/adrien1106/reframed/mixin/compat/ContinuityModelWrappingHandlerMixin.java

@@ -0,0 +1,29 @@
+package fr.adrien1106.reframed.mixin.compat;
+
+import fr.adrien1106.reframed.block.ReFramedBlock;
+import me.pepperbell.continuity.client.resource.ModelWrappingHandler;
+import net.minecraft.block.Block;
+import net.minecraft.registry.DefaultedRegistry;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import java.util.Iterator;
+
+@Mixin(ModelWrappingHandler.class)
+public class ContinuityModelWrappingHandlerMixin {
+
+    @Redirect(
+        method = "createBlockStateModelIdMap",
+        at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/registry/DefaultedRegistry;iterator()Ljava/util/Iterator;"
+        )
+    )
+    private static Iterator<Block> filterFrames(DefaultedRegistry<Block> registry) {
+        return registry
+            .stream()
+            .filter(block -> !(block instanceof ReFramedBlock))
+            .iterator();
+    }
+}

src/main/java/fr/adrien1106/reframed/mixin/compat/IndiumAbstractBlockRenderContextMixin.java

@@ -1,7 +1,7 @@
 package fr.adrien1106.reframed.mixin.compat;
 
 import com.llamalad7.mixinextras.sugar.Local;
-import fr.adrien1106.reframed.util.blocks.BlockHelper;
+import fr.adrien1106.reframed.client.util.RenderHelper;
 import fr.adrien1106.reframed.util.mixin.IBlockRenderInfoMixin;
 import link.infra.indium.renderer.mesh.MutableQuadViewImpl;
 import link.infra.indium.renderer.render.AbstractBlockRenderContext;
@@ -24,6 +24,6 @@ public abstract class IndiumAbstractBlockRenderContextMixin {
     private boolean shouldDrawInnerQuad(AbstractBlockRenderContext instance, Direction face, @Local(argsOnly = true) MutableQuadViewImpl quad) {
         if (face != null || quad.tag() == 0 || !(blockInfo instanceof IBlockRenderInfoMixin info) || info.getThemeIndex() == 0) return isFaceCulled(face);
 
-        return !BlockHelper.shouldDrawInnerFace(blockInfo.blockState, blockInfo.blockView, blockInfo.blockPos, quad.tag() >>> 8, info.getThemeIndex());
+        return !RenderHelper.shouldDrawInnerFace(blockInfo.blockState, blockInfo.blockView, blockInfo.blockPos, quad.tag() >>> 8, info.getThemeIndex());
     }
 }

src/main/java/fr/adrien1106/reframed/mixin/compat/IndiumTerrainBlockRenderInfoMixin.java

@@ -1,6 +1,6 @@
 package fr.adrien1106.reframed.mixin.compat;
 
-import fr.adrien1106.reframed.util.blocks.BlockHelper;
+import fr.adrien1106.reframed.client.util.RenderHelper;
 import fr.adrien1106.reframed.util.mixin.IBlockRenderInfoMixin;
 import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
 import link.infra.indium.renderer.render.BlockRenderInfo;
@@ -32,7 +32,7 @@ public abstract class IndiumTerrainBlockRenderInfoMixin extends BlockRenderInfo
         if (!(view.getBlockEntity(pos) instanceof ThemeableBlockEntity
             || view.getBlockEntity(other_pos) instanceof ThemeableBlockEntity))
                 return instance.shouldDrawSide(state, view, pos, face);
-        return BlockHelper.shouldDrawSide(state, view, pos, face, other_pos, theme_index);
+        return RenderHelper.shouldDrawSide(state, view, pos, face, other_pos, theme_index);
     }
 
     @Override

src/main/java/fr/adrien1106/reframed/mixin/compat/IndiumTerrainRenderContextMixin.java

@@ -1,7 +1,7 @@
 package fr.adrien1106.reframed.mixin.compat;
 
 import fr.adrien1106.reframed.client.model.MultiRetexturableModel;
-import fr.adrien1106.reframed.util.blocks.BlockHelper;
+import fr.adrien1106.reframed.client.util.RenderHelper;
 import fr.adrien1106.reframed.util.mixin.IBlockRenderInfoMixin;
 import fr.adrien1106.reframed.util.mixin.IMultipartBakedModelMixin;
 import link.infra.indium.renderer.render.AbstractBlockRenderContext;
@@ -32,7 +32,7 @@ public abstract class IndiumTerrainRenderContextMixin extends AbstractBlockRende
             || !(wrapped.getModel(ctx.state()) instanceof MultiRetexturableModel retexturing_model)) return;
 
         List<ForwardingBakedModel> models = retexturing_model.models();
-        BlockHelper.computeInnerCull(ctx.state(), models);
+        RenderHelper.computeInnerCull(ctx.state(), models);
         int i = 0;
         for (BakedModel model : models) {
             i++;

src/main/java/fr/adrien1106/reframed/mixin/compat/SodiumBlockOcclusionCacheMixin.java

@@ -1,7 +1,7 @@
 package fr.adrien1106.reframed.mixin.compat;
 
 import com.llamalad7.mixinextras.sugar.Local;
-import fr.adrien1106.reframed.util.blocks.BlockHelper;
+import fr.adrien1106.reframed.client.util.RenderHelper;
 import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
 import me.jellysquid.mods.sodium.client.render.chunk.compile.pipeline.BlockOcclusionCache;
 import net.minecraft.block.BlockState;
@@ -19,12 +19,12 @@ public class SodiumBlockOcclusionCacheMixin {
     @Inject(
         method = "shouldDrawSide",
         at = @At(
-            value = "INVOKE_ASSIGN",
+            value = "INVOKE",
-            target = "Lnet/minecraft/world/BlockView;getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/BlockState;",
+            target = "Lnet/minecraft/util/math/BlockPos$Mutable;set(III)Lnet/minecraft/util/math/BlockPos$Mutable;",
             shift = At.Shift.AFTER
         ), cancellable = true)
     private void shouldDrawFrameNeighborSide(BlockState self_state, BlockView view, BlockPos self_pos, Direction face, CallbackInfoReturnable<Boolean> cir, @Local BlockPos.Mutable other_pos) {
         if (!(view.getBlockEntity(other_pos) instanceof ThemeableBlockEntity)) return;
-        cir.setReturnValue(BlockHelper.shouldDrawSide(self_state, view, self_pos, face, other_pos, 0));
+        cir.setReturnValue(RenderHelper.shouldDrawSide(self_state, view, self_pos, face, other_pos, 0));
     }
 }

src/main/java/fr/adrien1106/reframed/mixin/render/AbstractBlockRenderContextMixin.java

@@ -1,7 +1,7 @@
 package fr.adrien1106.reframed.mixin.render;
 
 import com.llamalad7.mixinextras.sugar.Local;
-import fr.adrien1106.reframed.util.blocks.BlockHelper;
+import fr.adrien1106.reframed.client.util.RenderHelper;
 import fr.adrien1106.reframed.util.mixin.IBlockRenderInfoMixin;
 import net.fabricmc.fabric.impl.client.indigo.renderer.mesh.MutableQuadViewImpl;
 import net.fabricmc.fabric.impl.client.indigo.renderer.render.AbstractBlockRenderContext;
@@ -31,6 +31,6 @@ public abstract class AbstractBlockRenderContextMixin {
     private boolean shouldDrawInnerQuad(AbstractBlockRenderContext instance, Direction face, @Local(argsOnly = true) MutableQuadViewImpl quad) {
         if (face != null || quad.tag() == 0 || !(blockInfo instanceof IBlockRenderInfoMixin info) || info.getThemeIndex() == 0) return isFaceCulled(face);
 
-        return !BlockHelper.shouldDrawInnerFace(blockInfo.blockState, blockInfo.blockView, blockInfo.blockPos, quad.tag() >>> 8, info.getThemeIndex());
+        return !RenderHelper.shouldDrawInnerFace(blockInfo.blockState, blockInfo.blockView, blockInfo.blockPos, quad.tag() >>> 8, info.getThemeIndex());
     }
 }

src/main/java/fr/adrien1106/reframed/mixin/render/BlockRenderInfoMixin.java

@@ -1,7 +1,7 @@
 package fr.adrien1106.reframed.mixin.render;
 
 import com.llamalad7.mixinextras.sugar.Local;
-import fr.adrien1106.reframed.util.blocks.BlockHelper;
+import fr.adrien1106.reframed.client.util.RenderHelper;
 import fr.adrien1106.reframed.util.mixin.IBlockRenderInfoMixin;
 import fr.adrien1106.reframed.util.blocks.ThemeableBlockEntity;
 import net.fabricmc.fabric.impl.client.indigo.renderer.render.BlockRenderInfo;
@@ -37,7 +37,7 @@ public abstract class BlockRenderInfoMixin implements IBlockRenderInfoMixin {
 
     @Redirect(method = "shouldDrawFace", at = @At(value = "INVOKE", target = "Lnet/minecraft/block/Block;shouldDrawSide(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/BlockView;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/math/Direction;Lnet/minecraft/util/math/BlockPos;)Z"))
     private boolean shouldDrawAdjacentCamoSide(BlockState state, BlockView world, BlockPos pos, Direction side, BlockPos other_pos) {
-        return BlockHelper.shouldDrawSide(state, world, pos, side, other_pos, theme_index);
+        return RenderHelper.shouldDrawSide(state, world, pos, side, other_pos, theme_index);
     }
 
     @Override

src/main/java/fr/adrien1106/reframed/mixin/render/TerrainRenderContextMixin.java

@@ -1,7 +1,7 @@
 package fr.adrien1106.reframed.mixin.render;
 
 import fr.adrien1106.reframed.client.model.MultiRetexturableModel;
-import fr.adrien1106.reframed.util.blocks.BlockHelper;
+import fr.adrien1106.reframed.client.util.RenderHelper;
 import fr.adrien1106.reframed.util.mixin.IBlockRenderInfoMixin;
 import fr.adrien1106.reframed.util.mixin.IMultipartBakedModelMixin;
 import net.fabricmc.fabric.api.renderer.v1.model.ForwardingBakedModel;
@@ -31,7 +31,7 @@ public abstract class TerrainRenderContextMixin extends AbstractBlockRenderConte
             || !(wrapped.getModel(state) instanceof MultiRetexturableModel retexturing_model)) return;
 
         List<ForwardingBakedModel> models = retexturing_model.models();
-        BlockHelper.computeInnerCull(state, models);
+        RenderHelper.computeInnerCull(state, models);
         int i = 0;
         for (BakedModel model : models) {
             i++;

src/main/java/fr/adrien1106/reframed/util/blocks/BlockHelper.java

@@ -1,19 +1,8 @@
 package fr.adrien1106.reframed.util.blocks;
 
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-import fr.adrien1106.reframed.block.ReFramedBlock;
 import fr.adrien1106.reframed.block.ReFramedEntity;
 import fr.adrien1106.reframed.block.ReFramedStairBlock;
 import fr.adrien1106.reframed.block.ReFramedStairsCubeBlock;
-import fr.adrien1106.reframed.client.ReFramedClient;
-import fr.adrien1106.reframed.client.model.QuadPosBounds;
-import net.fabricmc.api.EnvType;
-import net.fabricmc.api.Environment;
-import net.fabricmc.fabric.api.renderer.v1.Renderer;
-import net.fabricmc.fabric.api.renderer.v1.material.RenderMaterial;
-import net.fabricmc.fabric.api.renderer.v1.mesh.QuadEmitter;
-import net.fabricmc.fabric.api.renderer.v1.model.ForwardingBakedModel;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockEntityProvider;
 import net.minecraft.block.BlockState;
@@ -25,33 +14,27 @@ import net.minecraft.sound.SoundEvents;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
 import net.minecraft.util.Pair;
-import net.minecraft.util.function.BooleanBiFunction;
 import net.minecraft.util.hit.BlockHitResult;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
 import net.minecraft.util.math.Vec3d;
-import net.minecraft.util.math.random.Random;
 import net.minecraft.util.shape.VoxelShape;
-import net.minecraft.util.shape.VoxelShapes;
-import net.minecraft.world.BlockRenderView;
 import net.minecraft.world.BlockView;
 import net.minecraft.world.World;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static fr.adrien1106.reframed.util.blocks.BlockProperties.EDGE;
 import static fr.adrien1106.reframed.util.blocks.BlockProperties.LIGHT;
 import static fr.adrien1106.reframed.util.blocks.StairShape.*;
-import static net.minecraft.util.shape.VoxelShapes.combine;
 
 public class BlockHelper {
 
-    // self culling cache of the models not made thread local so that it is only computed once
-    private static final Cache<CullElement, Integer[]> INNER_CULL_MAP = CacheBuilder.newBuilder().maximumSize(1024).build();
-    private record CullElement(Block block, Object state_key, int model) {}
-
     public static Corner getPlacementCorner(ItemPlacementContext ctx) {
         Direction side = ctx.getSide().getOpposite();
         Vec3d pos = getHitPos(ctx.getHitPos(), ctx.getBlockPos());
@@ -167,8 +150,8 @@ public class BlockHelper {
     public static ActionResult useCamo(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit, int theme_index) {
         if(!(world.getBlockEntity(pos) instanceof ReFramedEntity block_entity)) return ActionResult.PASS;
 
-        // Changing the theme
         ItemStack held = player.getStackInHand(hand);
+        // Changing the theme
         if(held.getItem() instanceof BlockItem block_item && block_entity.getTheme(theme_index).getBlock() == Blocks.AIR) {
             Block block = block_item.getBlock();
             ItemPlacementContext ctx = new ItemPlacementContext(new ItemUsageContext(player, hand, hit));
@@ -232,148 +215,6 @@ public class BlockHelper {
         return ActionResult.PASS;
     }
 
-    /**
-     * compute which quad might cull with another model quad
-     * @param state - the state of the model
-     * @param models - list of models on the same block
-     */
-    @Environment(EnvType.CLIENT)
-    public static void computeInnerCull(BlockState state, List<ForwardingBakedModel> models) {
-        if (!(state.getBlock() instanceof ReFramedBlock frame_block)) return;
-        Object key = frame_block.getModelCacheKey(state);
-        if (INNER_CULL_MAP.asMap().containsKey(new CullElement(frame_block, key, 1))) return;
-
-        Renderer r = ReFramedClient.HELPER.getFabricRenderer();
-        QuadEmitter quad_emitter = r.meshBuilder().getEmitter();
-        RenderMaterial material = r.materialFinder().clear().find();
-        Random random = Random.create();
-
-        List<List<QuadPosBounds>> model_bounds = models.stream()
-            .map(ForwardingBakedModel::getWrappedModel)
-            .filter(Objects::nonNull)
-            .map(wrapped -> wrapped.getQuads(state, null, random))
-            .map(quads -> quads.stream().map(quad -> {
-                quad_emitter.fromVanilla(quad, material, null);
-                return QuadPosBounds.read(quad_emitter, false);
-            }).toList()).toList();
-
-        Integer[] cull_array;
-        for(int self_id = 1; self_id <= model_bounds.size(); self_id++) {
-            List<QuadPosBounds> self_bounds = model_bounds.get(self_id - 1);
-            cull_array = new Integer[self_bounds.size()];
-            for (int self_quad = 0; self_quad < cull_array.length; self_quad++) {
-                QuadPosBounds self_bound = self_bounds.get(self_quad);
-                for(int other_id = 1; other_id <= model_bounds.size(); other_id++) {
-                    if (other_id == self_id) continue;
-                    if (model_bounds.get(other_id - 1).stream().anyMatch(other_bound -> other_bound.equals(self_bound))) {
-                        cull_array[self_quad] = other_id;
-                        break;
-                    }
-                }
-            }
-            INNER_CULL_MAP.put(new CullElement(frame_block, key, self_id), cull_array);
-        }
-    }
-
-    @Environment(EnvType.CLIENT)
-    public static boolean shouldDrawInnerFace(BlockState state, BlockRenderView view, BlockPos pos, int quad_index, int theme_index) {
-        if ( !(state.getBlock() instanceof ReFramedBlock frame_block)
-            || !(view.getBlockEntity(pos) instanceof ThemeableBlockEntity frame_entity)
-        ) return true;
-        CullElement key = new CullElement(frame_block, frame_block.getModelCacheKey(state), theme_index);
-        if (!INNER_CULL_MAP.asMap().containsKey(key)) return true;
-
-        // needs to be Integer object because array is initialized with null not 0
-        Integer cull_theme = Objects.requireNonNull(INNER_CULL_MAP.getIfPresent(key))[quad_index];
-        if (cull_theme == null) return true; // no culling possible
-
-        BlockState self_theme = frame_entity.getTheme(theme_index);
-        BlockState other_theme = frame_entity.getTheme(cull_theme);
-
-        if (self_theme.isSideInvisible(other_theme, null)) return false;
-        return !self_theme.isOpaque() || !other_theme.isOpaque();
-    }
-
-    // Doing this method from scratch as it is simpler to do than injecting everywhere
-    @Environment(EnvType.CLIENT)
-    public static boolean shouldDrawSide(BlockState self_state, BlockView world, BlockPos pos, Direction side, BlockPos other_pos, int theme_index) {
-        ThemeableBlockEntity self = world.getBlockEntity(pos) instanceof ThemeableBlockEntity e ? e : null;
-        ThemeableBlockEntity other = world.getBlockEntity(other_pos) instanceof ThemeableBlockEntity e ? e : null;
-        BlockState other_state = world.getBlockState(other_pos);
-
-        // normal behaviour
-        if (self == null && other == null) return Block.shouldDrawSide(self_state, world, pos, side, other_pos);
-
-        // self is a normal Block
-        if (self == null && other_state.getBlock() instanceof ReFramedBlock other_block) {
-            VoxelShape self_shape = self_state.getCullingShape(world, pos);
-            if (self_shape.isEmpty()) return true;
-
-            int i = 0;
-            VoxelShape other_shape = VoxelShapes.empty();
-            for (BlockState s: other.getThemes()) {
-                i++;
-                if (self_state.isSideInvisible(s, side) || s.isOpaque())
-                    other_shape = combine(
-                        other_shape,
-                        other_block
-                            .getShape(other_state, i)
-                            .getFace(side.getOpposite()),
-                        BooleanBiFunction.OR
-                    );
-            }
-
-            // determine if side needs to be rendered
-            return VoxelShapes.matchesAnywhere(self_shape, other_shape, BooleanBiFunction.ONLY_FIRST);
-        }
-
-        BlockState self_theme = self.getTheme(theme_index);
-        // other is normal Block
-        if (other == null && self_state.getBlock() instanceof ReFramedBlock self_block) {
-            // Transparent is simple if self and the neighbor are invisible don't render side (like default)
-            if (self_theme.isSideInvisible(other_state, side)) return false;
-
-            // Opaque is also simple as each model are rendered one by one
-            if (other_state.isOpaque()) {
-                // no cache section :( because it differs between each instance of the frame
-                VoxelShape self_shape = self_block.getShape(self_state, theme_index).getFace(side);
-                if (self_shape.isEmpty()) return true;
-                VoxelShape other_shape = other_state.getCullingFace(world, other_pos, side.getOpposite());
-
-                // determine if side needs to be rendered
-                return VoxelShapes.matchesAnywhere(self_shape, other_shape, BooleanBiFunction.ONLY_FIRST);
-            }
-
-            return true;
-        }
-
-        // Both are frames
-        // here both are computed in the same zone as there will necessarily a shape comparison
-        if (self_state.getBlock() instanceof ReFramedBlock self_block && other_state.getBlock() instanceof ReFramedBlock other_block) {
-            VoxelShape self_shape = self_block.getShape(self_state, theme_index).getFace(side);
-            if (self_shape.isEmpty()) return true;
-
-            int i = 0;
-            VoxelShape other_shape = VoxelShapes.empty();
-            for (BlockState s: other.getThemes()) {
-                i++;
-                if (self_theme.isSideInvisible(s, side) || s.isOpaque())
-                    other_shape = combine(
-                        other_shape,
-                        other_block
-                            .getShape(other_state, i)
-                            .getFace(side.getOpposite()),
-                        BooleanBiFunction.OR
-                    );
-            }
-
-            // determine if side needs to be rendered
-            return VoxelShapes.matchesAnywhere(self_shape, other_shape, BooleanBiFunction.ONLY_FIRST);
-        }
-
-        return true;
-    }
-
     public static boolean cursorMatchesFace(VoxelShape shape, Vec3d pos) {
         Map<Direction.Axis, Double> axes = Arrays.stream(Direction.Axis.values())
             .collect(Collectors.toMap(

src/main/resources/fabric.mod.json

@@ -8,7 +8,7 @@
 		"Adrien1106"
 	],
 	"contact": {},
-	"license": "MIT",
+	"license": "MIT AND LGPL-3.0",
 	"icon": "assets/reframed-icon.png",
 	"environment": "*",
 	"entrypoints": {
@@ -33,6 +33,7 @@
 	"suggests": {
 		"athena": "^${athena_version}",
 		"sodium": "^${sodium_version}",
-		"indium": "^${indium_version}"
+		"indium": "^${indium_version}",
+		"continuity": "^${continuity_version}"
 	}
 }

src/main/resources/reframed.mixins.json

@@ -14,6 +14,10 @@
     "compat.AthenaBakedModelMixin",
     "compat.AthenaConnectedBlockModelMixin",
     "compat.AthenaWrappedGetterMixin",
+    "compat.ContinuityConnectionPredicateMixin",
+    "compat.ContinuityCTMBakedModelMixin",
+    "compat.ContinuityCTMQuadTransformMixin",
+    "compat.ContinuityModelWrappingHandlerMixin",
     "compat.IndiumAbstractBlockRenderContextMixin",
     "compat.IndiumTerrainBlockRenderInfoMixin",
     "compat.IndiumTerrainRenderContextMixin",