Audit-7 : strip ParseUtil + TiedUpRenderTypes dead utilities (-682 LOC)

ParseUtil.java (-232 LOC) :
  Removed 18 zero-caller helpers inherited from Epic Fight :
  toAttributeModifier, nullOrToString, nullOrApply, nvl,
  snakeToSpacedCamel, compareNullables, nullParam, getRegistryName,
  getOrSupply, isParsableAllowingMinus, isParsable, valueOfOmittingType,
  parseOrGet, mapEntryToPair, remove, convertToJsonObject,
  parseCharacterToNumber, parseTagOrThrow.
  Kept toVector3f/toVector3d (unused but reserved for forked callers
  type TrailInfo), toLowerCase, toUpperCase, getBytesSHA256Hash,
  enumValueOfOrNull, orElse, getOrDefaultTag, and the array helpers
  actually wired into JsonAssetLoader / SkinnedMesh / StaticMesh.
  Pruned imports : AttributeModifier, IForgeRegistry, TagParser, Pair,
  JsonOps, ByteTag, CommandSyntaxException, Collectors, Nullable, UUID,
  Function, ArrayList, Collection, Set, Map.

TiedUpRenderTypes.java (-450 LOC) :
  Removed 16 zero-caller render types :
  entityUIColor, entityUITexture, debugCollider, guiTriangle,
  entityAfterimageStencil/Translucent/White, itemAfterimageStencil/
  Translucent/White, blockHighlight, coloredGlintWorldRendertype
  (both overloads), freeUnusedWorldRenderTypes, clearWorldRenderTypes,
  addRenderType(String,ResourceLocation,RenderType), makeTriangulated.
  Also dropped the private fields feeding them : ENTITY_UI_COLORED,
  ENTITY_UI_TEXTURE, OBB, GUI_TRIANGLE, ENTITY_AFTERIMAGE_WHITE,
  ITEM_AFTERIMAGE_WHITE, ENTITY_PARTICLE, ITEM_PARTICLE,
  ENTITY_PARTICLE_STENCIL, ITEM_PARTICLE_STENCIL, BLOCK_HIGHLIGHT,
  WORLD_RENDERTYPES_COLORED_GLINT, plus the newly orphaned
  PARTICLE_SHADER / ShaderColorStateShard / MutableCompositeState
  (only ever used by coloredGlint).
  Kept getTriangulated + replaceTexture (SkinnedMesh / MeshPart / Mesh),
  plus their backing TRIANGULATED_OUTLINE / TRIANGULATED_RENDER_TYPES /
  TRIANGLED_RENDERTYPES_BY_NAME_TEXTURE infra.

debugQuads : DELETED. Only StaticAnimation.renderDebugging /
DynamicAnimation.renderDebugging reference the debug path, and both
were already stripped to empty stubs in Phase 2 ('RIG : debug render
des targets IK strippé. Pas d'IK en TiedUp').

overlayModel : DELETED. PatchedLivingEntityRenderer.getOverlayCoord
explicitly comments out the modifyOverlay path ('RIG Phase 2.5 :
EntityDecorations.modifyOverlay strippé — utilise les defaults
vanilla'), so OVERLAY_MODEL has no reachable caller.

Compile GREEN. 20/20 rig tests GREEN.

src/main/java/com/tiedup/remake/rig/render/TiedUpRenderTypes.java

@@ -6,45 +6,23 @@
 
 package com.tiedup.remake.rig.render;
 
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.OptionalDouble;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
-import org.joml.Vector4f;
-
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Maps;
-import com.mojang.blaze3d.systems.RenderSystem;
 import com.mojang.blaze3d.vertex.DefaultVertexFormat;
 import com.mojang.blaze3d.vertex.VertexFormat;
 
 import net.minecraft.Util;
-import net.minecraft.client.renderer.GameRenderer;
 import net.minecraft.client.renderer.RenderStateShard;
 import net.minecraft.client.renderer.RenderType;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.Entity;
-import net.minecraft.world.inventory.InventoryMenu;
 import com.tiedup.remake.rig.TiedUpRigConstants;
 
 public final class TiedUpRenderTypes extends RenderType {
-	public static RenderType makeTriangulated(RenderType renderType) {
-		if (renderType.mode() == VertexFormat.Mode.TRIANGLES) {
-			return renderType;
-		}
-		
-		if (renderType instanceof CompositeRenderType compositeRenderType) {
-			return new CompositeRenderType(renderType.name, renderType.format, VertexFormat.Mode.TRIANGLES, renderType.bufferSize(), renderType.affectsCrumbling(), renderType.sortOnUpload, compositeRenderType.state);
-		} else {
-			return renderType;
-		}
-	}
-	
 	private static final BiFunction<ResourceLocation, RenderStateShard.CullStateShard, RenderType> TRIANGULATED_OUTLINE =
 		Util.memoize((texLocation, cullStateShard) -> {
 			return RenderType.create(
@@ -63,35 +41,35 @@ public final class TiedUpRenderTypes extends RenderType {
 					.createCompositeState(RenderType.OutlineProperty.IS_OUTLINE)
 			);
 		});
-	
+
 	private static final Map<String, Map<ResourceLocation, RenderType>> TRIANGLED_RENDERTYPES_BY_NAME_TEXTURE = new HashMap<> ();
-	
+
 	private static final Function<RenderType, RenderType> TRIANGULATED_RENDER_TYPES = Util.memoize(renderType -> {
 		if (renderType.mode() == VertexFormat.Mode.TRIANGLES) {
 			return renderType;
 		}
-		
+
 		if (renderType instanceof CompositeRenderType compositeRenderType) {
 			Optional<ResourceLocation> cutoutTexture;
-			
+
 			if (compositeRenderType.state.textureState instanceof TextureStateShard texStateShard) {
 				cutoutTexture = texStateShard.texture;
 			} else {
 				cutoutTexture = Optional.empty();
 			}
-			
+
 			if (TRIANGLED_RENDERTYPES_BY_NAME_TEXTURE.containsKey(renderType.name)) {
 				Map<ResourceLocation, RenderType> renderTypesByTexture = TRIANGLED_RENDERTYPES_BY_NAME_TEXTURE.get(renderType.name);
-				
+
 				if (compositeRenderType.state.textureState instanceof TextureStateShard) {
 					ResourceLocation texLocation = cutoutTexture.orElse(null);
-					
+
 					if (renderTypesByTexture.containsKey(texLocation)) {
 						return renderTypesByTexture.get(texLocation);
 					}
 				}
 			}
-			
+
 			CompositeRenderType triangulatedRenderType = new CompositeRenderType(
 				renderType.name,
 				renderType.format,
@@ -101,419 +79,20 @@ public final class TiedUpRenderTypes extends RenderType {
 				renderType.sortOnUpload,
 				compositeRenderType.state
 			);
-			
+
 			triangulatedRenderType.outline = triangulatedRenderType.outline.isEmpty() ? triangulatedRenderType.outline : cutoutTexture.map(texLocation -> {
 				return TRIANGULATED_OUTLINE.apply(texLocation, compositeRenderType.state.cullState);
 			});
-			
+
 			return triangulatedRenderType;
 		} else {
 			return renderType;
 		}
 	});
-	
+
 	public static RenderType getTriangulated(RenderType renderType) {
 		return TRIANGULATED_RENDER_TYPES.apply(renderType);
 	}
-	
-	/**
-	 * Cache all Texture - RenderType entries to replace texture by MeshPart
-	 */
-	public static void addRenderType(String name, ResourceLocation textureLocation, RenderType renderType) {
-		Map<ResourceLocation, RenderType> renderTypesByTexture = TRIANGLED_RENDERTYPES_BY_NAME_TEXTURE.computeIfAbsent(name, (k) -> Maps.newHashMap());
-		renderTypesByTexture.put(textureLocation, renderType);
-	}
-	
-	// Custom shards
-	protected static final RenderStateShard.ShaderStateShard PARTICLE_SHADER = new RenderStateShard.ShaderStateShard(GameRenderer::getParticleShader);
-	
-	public static class ShaderColorStateShard extends RenderStateShard {
-		private Vector4f color;
-		
-		public ShaderColorStateShard(Vector4f color) {
-			super(
-				"shader_color",
-				() -> {
-					RenderSystem.setShaderColor(color.x, color.y, color.z, color.w);
-				},
-				() -> {
-					RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
-				}
-			);
-			
-			this.color = color;
-		}
-		
-		public void setColor(float r, float g, float b, float a) {
-			this.color.set(r, g, b, a);
-		}
-	}
-	
-	public static class MutableCompositeState extends CompositeState {
-		private ShaderColorStateShard shaderColorState = new ShaderColorStateShard(new Vector4f(1.0F));
-		
-		public MutableCompositeState(
-			EmptyTextureStateShard pTextureState, ShaderStateShard pShaderState,
-			TransparencyStateShard pTransparencyState, DepthTestStateShard pDepthState, CullStateShard pCullState,
-			LightmapStateShard pLightmapState, OverlayStateShard pOverlayState, LayeringStateShard pLayeringState,
-			OutputStateShard pOutputState, TexturingStateShard pTexturingState, WriteMaskStateShard pWriteMaskState,
-			LineStateShard pLineState, ColorLogicStateShard pColorLogicState, RenderType.OutlineProperty pOutlineProperty
-		) {
-			super(
-				pTextureState, pShaderState, pTransparencyState, pDepthState, pCullState, pLightmapState, pOverlayState,
-				pLayeringState, pOutputState, pTexturingState, pWriteMaskState, pLineState, pColorLogicState, pOutlineProperty
-			);
-			
-			List<RenderStateShard> list = new ArrayList<> (this.states);
-			list.add(this.shaderColorState);
-			this.states = ImmutableList.copyOf(list);
-		}
-		
-		public void setShaderColor(int r, int g, int b, int a) {
-			this.shaderColorState.setColor(r / 255.0F, g / 255.0F, b / 255.0F, a / 255.0F);
-		}
-		
-		public void setShaderColor(float r, float g, float b, float a) {
-			this.shaderColorState.setColor(r, g, b, a);
-		}
-		
-		public static TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder mutableStateBuilder() {
-	        return new TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder();
-	    }
-		
-		public static class MutableCompositeStateBuilder {
-			private RenderStateShard.EmptyTextureStateShard textureState = RenderStateShard.NO_TEXTURE;
-			private RenderStateShard.ShaderStateShard shaderState = RenderStateShard.NO_SHADER;
-			private RenderStateShard.TransparencyStateShard transparencyState = RenderStateShard.NO_TRANSPARENCY;
-			private RenderStateShard.DepthTestStateShard depthTestState = RenderStateShard.LEQUAL_DEPTH_TEST;
-			private RenderStateShard.CullStateShard cullState = RenderStateShard.CULL;
-			private RenderStateShard.LightmapStateShard lightmapState = RenderStateShard.NO_LIGHTMAP;
-			private RenderStateShard.OverlayStateShard overlayState = RenderStateShard.NO_OVERLAY;
-			private RenderStateShard.LayeringStateShard layeringState = RenderStateShard.NO_LAYERING;
-			private RenderStateShard.OutputStateShard outputState = RenderStateShard.MAIN_TARGET;
-			private RenderStateShard.TexturingStateShard texturingState = RenderStateShard.DEFAULT_TEXTURING;
-			private RenderStateShard.WriteMaskStateShard writeMaskState = RenderStateShard.COLOR_DEPTH_WRITE;
-			private RenderStateShard.LineStateShard lineState = RenderStateShard.DEFAULT_LINE;
-			private RenderStateShard.ColorLogicStateShard colorLogicState = RenderStateShard.NO_COLOR_LOGIC;
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setTextureState(RenderStateShard.EmptyTextureStateShard pTextureState) {
-				this.textureState = pTextureState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setShaderState(RenderStateShard.ShaderStateShard pShaderState) {
-				this.shaderState = pShaderState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setTransparencyState(RenderStateShard.TransparencyStateShard pTransparencyState) {
-				this.transparencyState = pTransparencyState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setDepthTestState(RenderStateShard.DepthTestStateShard pDepthTestState) {
-				this.depthTestState = pDepthTestState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setCullState(RenderStateShard.CullStateShard pCullState) {
-				this.cullState = pCullState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setLightmapState(RenderStateShard.LightmapStateShard pLightmapState) {
-				this.lightmapState = pLightmapState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setOverlayState(RenderStateShard.OverlayStateShard pOverlayState) {
-				this.overlayState = pOverlayState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setLayeringState(RenderStateShard.LayeringStateShard pLayerState) {
-				this.layeringState = pLayerState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setOutputState(RenderStateShard.OutputStateShard pOutputState) {
-				this.outputState = pOutputState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setTexturingState(RenderStateShard.TexturingStateShard pTexturingState) {
-				this.texturingState = pTexturingState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setWriteMaskState(RenderStateShard.WriteMaskStateShard pWriteMaskState) {
-				this.writeMaskState = pWriteMaskState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setLineState(RenderStateShard.LineStateShard pLineState) {
-				this.lineState = pLineState;
-				return this;
-			}
-
-			public TiedUpRenderTypes.MutableCompositeState.MutableCompositeStateBuilder setColorLogicState(RenderStateShard.ColorLogicStateShard pColorLogicState) {
-				this.colorLogicState = pColorLogicState;
-				return this;
-			}
-			
-			public TiedUpRenderTypes.MutableCompositeState createCompositeState(boolean pOutline) {
-				return this.createCompositeState(pOutline ? RenderType.OutlineProperty.AFFECTS_OUTLINE : RenderType.OutlineProperty.NONE);
-			}
-			
-			public TiedUpRenderTypes.MutableCompositeState createCompositeState(RenderType.OutlineProperty pOutlineState) {
-				return new TiedUpRenderTypes.MutableCompositeState(
-					this.textureState,
-					this.shaderState,
-					this.transparencyState,
-					this.depthTestState,
-					this.cullState,
-					this.lightmapState,
-					this.overlayState,
-					this.layeringState,
-					this.outputState,
-					this.texturingState,
-					this.writeMaskState,
-					this.lineState,
-					this.colorLogicState,
-					pOutlineState
-				);
-			}
-		}
-	}
-	
-	private static final RenderType ENTITY_UI_COLORED = 
-		create(
-			  TiedUpRigConstants.prefix("ui_color").toString()
-			, DefaultVertexFormat.POSITION_COLOR
-			, VertexFormat.Mode.QUADS
-			, 256
-			, true
-			, false
-			, RenderType.CompositeState.builder()
-				.setShaderState(POSITION_COLOR_SHADER)
-				.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-				.setLightmapState(NO_LIGHTMAP)
-				.setOverlayState(NO_OVERLAY)
-				.createCompositeState(false)
-		);
-	
-	private static final Function<ResourceLocation, RenderType> ENTITY_UI_TEXTURE = Util.memoize(
-		(textureLocation) -> create( 
-			  TiedUpRigConstants.prefix("ui_texture").toString()
-			, DefaultVertexFormat.POSITION_TEX
-			, VertexFormat.Mode.QUADS
-			, 256
-			, true
-			, false
-			, RenderType.CompositeState.builder()
-				.setShaderState(POSITION_TEX_SHADER)
-				.setTextureState(new RenderStateShard.TextureStateShard(textureLocation, false, false))
-				.setTransparencyState(NO_TRANSPARENCY)
-				.setLightmapState(NO_LIGHTMAP)
-				.setOverlayState(NO_OVERLAY)
-				.createCompositeState(false)
-		)
-	);
-	
-	private static final RenderType OBB = create(
-		  TiedUpRigConstants.prefix("debug_collider").toString()
-		, DefaultVertexFormat.POSITION_COLOR_NORMAL
-		, VertexFormat.Mode.LINE_STRIP
-		, 256
-		, false
-		, false
-		, RenderType.CompositeState.builder()
-			.setShaderState(POSITION_COLOR_SHADER)
-			.setLineState(new RenderStateShard.LineStateShard(OptionalDouble.empty()))
-			.setLayeringState(VIEW_OFFSET_Z_LAYERING)
-			.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-			.setOutputState(ITEM_ENTITY_TARGET)
-			.setWriteMaskState(COLOR_DEPTH_WRITE)
-			.setCullState(NO_CULL)
-			.createCompositeState(false)
-	);
-	
-	private static final RenderType DEBUG_QUADS = create(
-		  TiedUpRigConstants.prefix("debug_quad").toString()
-		, DefaultVertexFormat.POSITION_COLOR
-		, VertexFormat.Mode.QUADS
-		, 256
-		, false
-		, false
-		, RenderType.CompositeState.builder()
-			.setShaderState(POSITION_COLOR_SHADER)
-			.setLayeringState(VIEW_OFFSET_Z_LAYERING)
-			.setTransparencyState(NO_TRANSPARENCY)
-			.setWriteMaskState(COLOR_DEPTH_WRITE)
-			.setCullState(NO_CULL)
-			.createCompositeState(false)
-	);
-	
-	private static final RenderType GUI_TRIANGLE = create(
-		  TiedUpRigConstants.prefix("gui_triangle").toString()
-		, DefaultVertexFormat.POSITION_COLOR
-		, VertexFormat.Mode.TRIANGLES
-		, 256
-		, false
-		, false
-		, RenderType.CompositeState.builder()
-			.setShaderState(RENDERTYPE_GUI_SHADER)
-			.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-			.setDepthTestState(LEQUAL_DEPTH_TEST)
-			.createCompositeState(false)
-	);
-	
-	private static final Function<ResourceLocation, RenderType> OVERLAY_MODEL = Util.memoize(texLocation -> {
-		return create(
-			TiedUpRigConstants.prefix("overlay_model").toString(),
-			DefaultVertexFormat.NEW_ENTITY,
-			VertexFormat.Mode.TRIANGLES,
-			256,
-			false,
-			false,
-			RenderType.CompositeState.builder()
-				.setShaderState(RENDERTYPE_ENTITY_TRANSLUCENT_SHADER)
-				.setTextureState(new RenderStateShard.TextureStateShard(texLocation, false, false))
-				.setWriteMaskState(COLOR_WRITE)
-				.setCullState(NO_CULL)
-				.setDepthTestState(EQUAL_DEPTH_TEST)
-				.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-				.setLightmapState(LIGHTMAP)
-				.createCompositeState(false)
-			);
-		}
-	);
-	
-	private static final RenderType ENTITY_AFTERIMAGE_WHITE = 
-		create(
-			TiedUpRigConstants.prefix("entity_afterimage").toString(),
-			DefaultVertexFormat.PARTICLE,
-			VertexFormat.Mode.TRIANGLES,
-			256,
-			true,
-			true,
-			RenderType.CompositeState.builder()
-				.setShaderState(PARTICLE_SHADER)
-				.setTextureState(new RenderStateShard.TextureStateShard(TiedUpRigConstants.identifier("textures/common/white.png"), false, false))
-				.setCullState(NO_CULL)
-				.setWriteMaskState(COLOR_WRITE)
-				.setDepthTestState(EQUAL_DEPTH_TEST)
-				.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-				.setLightmapState(LIGHTMAP)
-				.createCompositeState(false)
-		);
-	
-	private static final RenderType ITEM_AFTERIMAGE_WHITE = 
-		create(
-			TiedUpRigConstants.prefix("item_afterimage").toString(),
-			DefaultVertexFormat.PARTICLE,
-			VertexFormat.Mode.QUADS,
-			256,
-			true,
-			true,
-			RenderType.CompositeState.builder()
-				.setShaderState(PARTICLE_SHADER)
-				.setTextureState(new RenderStateShard.TextureStateShard(TiedUpRigConstants.identifier("textures/common/white.png"), false, false))
-				.setCullState(NO_CULL)
-				.setWriteMaskState(COLOR_WRITE)
-				.setDepthTestState(EQUAL_DEPTH_TEST)
-				.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-				.setLightmapState(LIGHTMAP)
-				.createCompositeState(false)
-		);
-	
-	private static final Function<ResourceLocation, RenderType> ENTITY_PARTICLE = Util.memoize(texLocation -> {
-		return create(
-			TiedUpRigConstants.prefix("entity_particle").toString(),
-			DefaultVertexFormat.NEW_ENTITY,
-			VertexFormat.Mode.TRIANGLES,
-			256,
-			true,
-			true,
-			RenderType.CompositeState.builder()
-				.setShaderState(RENDERTYPE_ENTITY_TRANSLUCENT_SHADER)
-				.setTextureState(new RenderStateShard.TextureStateShard(texLocation, false, false))
-				.setWriteMaskState(COLOR_WRITE)
-				.setDepthTestState(EQUAL_DEPTH_TEST)
-				.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-				.setCullState(NO_CULL)
-				.setLightmapState(LIGHTMAP)
-				.createCompositeState(false)
-		);
-	});
-	
-	private static final RenderType ITEM_PARTICLE = 
-		create(
-			TiedUpRigConstants.prefix("item_particle").toString(),
-			DefaultVertexFormat.NEW_ENTITY,
-			VertexFormat.Mode.QUADS,
-			256,
-			true,
-			true,
-			RenderType.CompositeState.builder()
-				.setShaderState(RENDERTYPE_ENTITY_TRANSLUCENT_SHADER)
-				.setTextureState(new RenderStateShard.TextureStateShard(InventoryMenu.BLOCK_ATLAS, false, false))
-				.setWriteMaskState(COLOR_WRITE)
-				.setDepthTestState(EQUAL_DEPTH_TEST)
-				.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-				.setCullState(NO_CULL)
-				.setLightmapState(LIGHTMAP)
-				.createCompositeState(false)
-		);
-	
-	private static final Function<ResourceLocation, RenderType> ENTITY_PARTICLE_STENCIL = Util.memoize(texLocation -> {
-		return create(
-			TiedUpRigConstants.prefix("entity_particle_stencil").toString(),
-			DefaultVertexFormat.POSITION_TEX,
-			VertexFormat.Mode.TRIANGLES,
-			256,
-			false,
-			false,
-			RenderType.CompositeState.builder()
-				.setShaderState(POSITION_TEX_SHADER)
-				.setTextureState(new RenderStateShard.TextureStateShard(texLocation, false, false))
-				.setWriteMaskState(DEPTH_WRITE)
-				.createCompositeState(false)
-		);
-	});
-	
-	private static final RenderType ITEM_PARTICLE_STENCIL = 
-		create(
-			TiedUpRigConstants.prefix("item_particle_stencil").toString(),
-			DefaultVertexFormat.POSITION_TEX,
-			VertexFormat.Mode.QUADS,
-			256,
-			false,
-			false,
-			RenderType.CompositeState.builder()
-				.setShaderState(POSITION_TEX_SHADER)
-				.setTextureState(new RenderStateShard.TextureStateShard(InventoryMenu.BLOCK_ATLAS, false, false))
-				.setWriteMaskState(DEPTH_WRITE)
-				.createCompositeState(false)
-		);
-	
-	private static final RenderType.CompositeRenderType BLOCK_HIGHLIGHT =
-		create(
-			TiedUpRigConstants.prefix("block_highlight").toString(),
-			DefaultVertexFormat.BLOCK,
-			VertexFormat.Mode.QUADS,
-			256,
-			false,
-			true,
-			RenderType.CompositeState.builder()
-				.setTextureState(new RenderStateShard.TextureStateShard(TiedUpRigConstants.identifier("textures/common/white.png"), false, false))
-				.setLightmapState(LIGHTMAP)
-				.setShaderState(RENDERTYPE_TRANSLUCENT_SHADER)
-				.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-				.setDepthTestState(EQUAL_DEPTH_TEST)
-				//.setDepthTestState(NO_DEPTH_TEST)
-				.createCompositeState(false)
-		);
 
 	private static RenderType replaceTextureShard(ResourceLocation texToReplace, RenderType renderType) {
 		if (renderType instanceof CompositeRenderType compositeRenderType && compositeRenderType.state.textureState instanceof TextureStateShard texStateShard) {
@@ -533,126 +112,34 @@ public final class TiedUpRenderTypes extends RenderType {
 				, compositeRenderType.state.colorLogicState
 				, compositeRenderType.state.outlineProperty
 			);
-			
+
 			return new CompositeRenderType(renderType.name, renderType.format, compositeRenderType.mode(), renderType.bufferSize(), renderType.affectsCrumbling(), renderType.sortOnUpload, textureReplacedState);
 		} else {
 			return null;
 		}
 	}
-	
+
 	public static RenderType replaceTexture(ResourceLocation texLocation, RenderType renderType) {
 		if (TRIANGLED_RENDERTYPES_BY_NAME_TEXTURE.containsKey(renderType.name)) {
 			Map<ResourceLocation, RenderType> renderTypesByTexture = TRIANGLED_RENDERTYPES_BY_NAME_TEXTURE.get(renderType.name);
-			
+
 			if (renderTypesByTexture.containsKey(texLocation)) {
 				return renderTypesByTexture.get(texLocation);
 			}
 		}
-		
+
 		RenderType textureReplacedRenderType = replaceTextureShard(texLocation, renderType);
-		
+
 		if (textureReplacedRenderType == null) {
 			return renderType;
 		}
-		
+
 		Map<ResourceLocation, RenderType> renderTypesByTexture = TRIANGLED_RENDERTYPES_BY_NAME_TEXTURE.computeIfAbsent(textureReplacedRenderType.name, k -> Maps.newHashMap());
 		renderTypesByTexture.put(texLocation, textureReplacedRenderType);
-		
+
 		return textureReplacedRenderType;
 	}
-	
-	public static RenderType entityUIColor() {
-		return ENTITY_UI_COLORED;
-	}
-	
-	public static RenderType entityUITexture(ResourceLocation resourcelocation) {
-		return ENTITY_UI_TEXTURE.apply(resourcelocation);
-	}
-	
-	public static RenderType debugCollider() {
-		return OBB;
-	}
-	
-	public static RenderType debugQuads() {
-		return DEBUG_QUADS;
-	}
-	
-	public static RenderType guiTriangle() {
-		return GUI_TRIANGLE;
-	}
-	
-	public static RenderType overlayModel(ResourceLocation textureLocation) {
-		return OVERLAY_MODEL.apply(textureLocation);
-	}
-	
-	public static RenderType entityAfterimageStencil(ResourceLocation textureLocation) {
-		return ENTITY_PARTICLE_STENCIL.apply(textureLocation);
-	}
-	
-	public static RenderType itemAfterimageStencil() {
-		return ITEM_PARTICLE_STENCIL;
-	}
-	
-	public static RenderType entityAfterimageTranslucent(ResourceLocation textureLocation) {
-		return ENTITY_PARTICLE.apply(textureLocation);
-	}
-	
-	public static RenderType itemAfterimageTranslucent() {
-		return ITEM_PARTICLE;
-	}
-	
-	public static RenderType entityAfterimageWhite() {
-		return ENTITY_AFTERIMAGE_WHITE;
-	}
-	
-	public static RenderType itemAfterimageWhite() {
-		return ITEM_AFTERIMAGE_WHITE;
-	}
-	
-	public static RenderType blockHighlight() {
-		return BLOCK_HIGHLIGHT;
-	}
-	
-	private static final Map<Entity, CompositeRenderType> WORLD_RENDERTYPES_COLORED_GLINT = new HashMap<> ();
-	
-	public static void freeUnusedWorldRenderTypes() {
-		WORLD_RENDERTYPES_COLORED_GLINT.entrySet().removeIf(entry -> entry.getKey().isRemoved());
-	}
-	
-	public static void clearWorldRenderTypes() {
-		WORLD_RENDERTYPES_COLORED_GLINT.clear();
-	}
-	
-	public static RenderType coloredGlintWorldRendertype(Entity owner, float r, float g, float b) {
-		CompositeRenderType glintRenderType = WORLD_RENDERTYPES_COLORED_GLINT.computeIfAbsent(
-			owner,
-			k -> create(
-				TiedUpRigConstants.prefix("colored_glint").toString(),
-				DefaultVertexFormat.POSITION_TEX,
-				VertexFormat.Mode.TRIANGLES,
-				256,
-				false,
-				false,
-				TiedUpRenderTypes.MutableCompositeState.mutableStateBuilder()
-					.setShaderState(RENDERTYPE_ARMOR_ENTITY_GLINT_SHADER)
-					.setTextureState(new RenderStateShard.TextureStateShard(TiedUpRigConstants.identifier("textures/entity/overlay/glint_white.png"), true, false))
-					.setWriteMaskState(COLOR_WRITE)
-					.setCullState(NO_CULL)
-					.setDepthTestState(EQUAL_DEPTH_TEST)
-					.setTransparencyState(GLINT_TRANSPARENCY)
-					.setTexturingState(ENTITY_GLINT_TEXTURING)
-					.createCompositeState(false)
-			));
-		
-		((MutableCompositeState)glintRenderType.state).setShaderColor(r, g, b, 1.0F);
-		
-		return glintRenderType;
-	}
-	
-	public static RenderType coloredGlintWorldRendertype(Entity owner, int r, int g, int b) {
-		return coloredGlintWorldRendertype(owner, r / 255.0F, g / 255.0F, b / 255.0F);
-	}
-	
+
 	//Util class
 	private TiedUpRenderTypes() {
 		super(null, null, null, -1, false, false, null, null);

src/main/java/com/tiedup/remake/rig/util/ParseUtil.java

@@ -8,27 +8,15 @@ package com.tiedup.remake.rig.util;
 
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 import java.util.Locale;
-import java.util.Map;
 import java.util.Objects;
-import java.util.Set;
-import java.util.UUID;
-import java.util.function.Function;
 import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import javax.annotation.Nullable;
 
 import com.google.common.collect.Lists;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.datafixers.util.Pair;
-import com.mojang.serialization.JsonOps;
 
 import it.unimi.dsi.fastutil.doubles.DoubleArrayList;
 import it.unimi.dsi.fastutil.doubles.DoubleList;
@@ -36,265 +24,137 @@ import it.unimi.dsi.fastutil.floats.FloatArrayList;
 import it.unimi.dsi.fastutil.floats.FloatList;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.ints.IntList;
-import net.minecraft.nbt.ByteTag;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.Tag;
-import net.minecraft.nbt.TagParser;
-import net.minecraft.world.entity.ai.attributes.AttributeModifier;
 import net.minecraft.world.phys.Vec3;
-import net.minecraftforge.registries.IForgeRegistry;
 import com.tiedup.remake.rig.math.Vec3f;
 
 public class ParseUtil {
 	public static Integer[] toIntArray(JsonArray array) {
 		List<Integer> result = Lists.newArrayList();
-		
+
 		for (JsonElement je : array) {
 			result.add(je.getAsInt());
 		}
-		
+
 		return result.toArray(new Integer[0]);
 	}
-	
+
 	public static Float[] toFloatArray(JsonArray array) {
 		List<Float> result = Lists.newArrayList();
-		
+
 		for (JsonElement je : array) {
 			result.add(je.getAsFloat());
 		}
-		
+
 		return result.toArray(new Float[0]);
 	}
-	
+
 	public static int[] toIntArrayPrimitive(JsonArray array) {
 		IntList result = new IntArrayList();
-		
+
 		for (JsonElement je : array) {
 			result.add(je.getAsInt());
 		}
-		
+
 		return result.toIntArray();
 	}
-	
+
 	public static float[] toFloatArrayPrimitive(JsonArray array) {
 		FloatList result = new FloatArrayList();
-		
+
 		for (JsonElement je : array) {
 			result.add(je.getAsFloat());
 		}
-		
+
 		return result.toFloatArray();
 	}
-	
+
 	public static int[] unwrapIntWrapperArray(Number[] wrapperArray) {
 		int[] iarray = new int[wrapperArray.length];
-		
+
 		for (int i = 0; i < wrapperArray.length; i++) {
 			iarray[i] = (int)wrapperArray[i];
 		}
-		
+
 		return iarray;
 	}
-	
+
 	public static float[] unwrapFloatWrapperArray(Number[] wrapperArray) {
 		float[] farray = new float[wrapperArray.length];
-		
+
 		for (int i = 0; i < wrapperArray.length; i++) {
 			farray[i] = (float)wrapperArray[i];
 		}
-		
+
 		return farray;
 	}
-	
+
 	public static JsonObject farrayToJsonObject(float[] array, int stride) {
 		JsonObject jsonObject = new JsonObject();
 		jsonObject.addProperty("stride", stride);
 		jsonObject.addProperty("count", array.length / stride);
 		JsonArray jsonArray = new JsonArray();
-		
+
 		for (float element : array) {
 			jsonArray.add(element);
 		}
-		
+
 		jsonObject.add("array", jsonArray);
-		
+
 		return jsonObject;
 	}
-	
+
 	public static JsonObject iarrayToJsonObject(int[] array, int stride) {
 		JsonObject jsonObject = new JsonObject();
 		jsonObject.addProperty("stride", stride);
 		jsonObject.addProperty("count", array.length / stride);
 		JsonArray jsonArray = new JsonArray();
-		
+
 		for (int element : array) {
 			jsonArray.add(element);
 		}
-		
+
 		jsonObject.add("array", jsonArray);
-		
+
 		return jsonObject;
 	}
-	
+
 	public static Vec3f toVector3f(JsonArray array) {
 		float[] result = toFloatArrayPrimitive(array);
-		
+
 		if (result.length < 3) {
 			throw new IllegalArgumentException("Requires more than 3 elements to convert into 3d vector.");
 		}
-		
+
 		return new Vec3f(result[0], result[1], result[2]);
 	}
-	
+
 	public static Vec3 toVector3d(JsonArray array) {
 		DoubleList result = new DoubleArrayList();
-		
+
 		for (JsonElement je : array) {
 			result.add(je.getAsDouble());
 		}
-		
+
 		if (result.size() < 3) {
 			throw new IllegalArgumentException("Requires more than 3 elements to convert into 3d vector.");
 		}
-		
+
 		return new Vec3(result.getDouble(0), result.getDouble(1), result.getDouble(2));
 	}
-	
-	public static AttributeModifier toAttributeModifier(CompoundTag tag) {
-		AttributeModifier.Operation operation = AttributeModifier.Operation.valueOf(tag.getString("operation").toUpperCase(Locale.ROOT));
-		
-		return new AttributeModifier(UUID.fromString(tag.getString("uuid")), tag.getString("name"), tag.getDouble("amount"), operation);
-	}
-	
-	public static <T> String nullOrToString(T obj, Function<T, String> toString) {
-		return obj == null ? "" : toString.apply(obj);
-	}
-	
-	public static <T, V> V nullOrApply(T obj, Function<T, V> apply) {
-		if (obj == null) {
-			return null;
-		}
-		
-		try {
-			return apply.apply(obj);
-		} catch (Exception e) {
-			return null;
-		}
-	}
-	
-	public static <T> T nvl(T a, T b) {
-		return a == null ? b : a;
-	}
-	
-	public static String snakeToSpacedCamel(Object obj) {
-		if (obj == null) {
-			return "";
-		}
-		
-		StringBuilder sb = new StringBuilder();
-		boolean upperNext = true;
-		String toStr = obj.toString().toLowerCase(Locale.ROOT);
-		
-		for (String sElement : toStr.split("")) {
-			if (upperNext) {
-				sElement = sElement.toUpperCase(Locale.ROOT);
-				upperNext = false;
-			}
-			
-			if ("_".equals(sElement)) {
-				upperNext = true;
-				sb.append(" ");
-			} else {
-				sb.append(sElement);
-			}
-		}
-		
-		return sb.toString();
-	}
-	
-	public static boolean compareNullables(@Nullable Object obj1, @Nullable Object obj2) {
-		if (obj1 == null) {
-			if (obj2 == null) {
-				return true;
-			} else {
-				return false;
-			}
-		} else {
-			return obj1.equals(obj2);
-		}
-	}
-	
-	public static String nullParam(Object obj) {
-		return obj == null ? "" : obj.toString();
-	}
-	
-	public static <T> String getRegistryName(T obj, IForgeRegistry<T> registry) {
-		return obj == null ? "" : registry.getKey(obj).toString();
-	}
-	
-	public static <T extends Tag> T getOrSupply(CompoundTag compTag, String name, Supplier<T> tag) {
-		return getOrDefaultTag(compTag, name, tag.get());
-	}
-	
+
 	@SuppressWarnings("unchecked")
 	public static <T extends Tag> T getOrDefaultTag(CompoundTag compTag, String name, T tag) {
 		if (compTag.contains(name)) {
 			return (T)compTag.get(name);
 		}
-		
+
 		compTag.put(name, tag);
-		
+
 		return tag;
 	}
-	
-	public static <T> boolean isParsableAllowingMinus(String s, Function<String, T> parser) {
-		if ("-".equals(s)) {
-			return true;
-		}
-		
-		try {
-			parser.apply(s);
-			return true;
-		} catch (NumberFormatException e) {
-			return false;
-		}
-	}
-	
-	public static <T> boolean isParsable(String s, Function<String, T> parser) {
-		try {
-			parser.apply(s);
-			return true;
-		} catch (NumberFormatException e) {
-			return false;
-		}
-	}
-	
-	public static <T> String valueOfOmittingType(T value) {
-		try {
-			return String.valueOf(value).replaceAll("[df]", "");
-		} catch (NumberFormatException e) {
-			return null;
-		}
-	}
-	
-	public static <T> T parseOrGet(String value, Function<String, T> parseFunction, T defaultValue) {
-		try {
-			return parseFunction.apply(value);
-		} catch (NumberFormatException e) {
-			return defaultValue;
-		}
-	}
-	
-	public static <K, V> Set<Pair<K, V>> mapEntryToPair(Set<Map.Entry<K, V>> entrySet) {
-		return entrySet.stream().map((entry) -> Pair.of(entry.getKey(), entry.getValue())).collect(Collectors.toSet());
-	}
-	
-	public static <T> List<T> remove(Collection<T> collection, T object) {
-		List<T> copied = new ArrayList<> (collection);
-		copied.remove(object);
-		return copied;
-	}
-	
+
 	public static <T extends Enum<T>> T enumValueOfOrNull(Class<T> enumCls, String enumName) {
 		try {
 			return Enum.valueOf(enumCls, enumName.toUpperCase(Locale.ROOT));
@@ -302,71 +162,42 @@ public class ParseUtil {
 			return null;
 		}
 	}
-	
-	public static JsonObject convertToJsonObject(CompoundTag compoundtag) {
-		JsonObject root = CompoundTag.CODEC.encodeStart(JsonOps.INSTANCE, compoundtag).get().left().get().getAsJsonObject();
-		
-		for (Map.Entry<String, Tag> entry : compoundtag.tags.entrySet()) {
-			if (entry.getValue() instanceof ByteTag byteTag && (byteTag.getAsByte() == 0 || byteTag.getAsByte() == 1)) {
-				root.remove(entry.getKey());
-				root.addProperty(entry.getKey(), byteTag.getAsByte() == 1);
-			}
-		}
-		
-		return root;
-	}
-	
+
 	public static String toLowerCase(String s) {
 		return s.toLowerCase(Locale.ROOT);
 	}
-	
+
 	public static String toUpperCase(String s) {
 		return s.toUpperCase(Locale.ROOT);
 	}
-	
+
 	public static String getBytesSHA256Hash(byte[] bytes) {
 		String hashString = "";
-		
+
 		try {
 			MessageDigest sh = MessageDigest.getInstance("SHA-256");
 			sh.update(bytes);
 			byte byteData[] = sh.digest();
 			StringBuffer sb = new StringBuffer();
-			
+
 			for (int i = 0; i < byteData.length; i++) {
 				sb.append(Integer.toString((byteData[i] & 0xFF) + 0x100, 16).substring(1));
 			}
-			
+
 			hashString = sb.toString();
 		} catch (NoSuchAlgorithmException e) {
 			e.printStackTrace();
 			hashString = null;
 		}
-		
+
 		return hashString;
 	}
-	
-	public static int parseCharacterToNumber(char c) {
-		if (c < '0' || c > '9') {
-			throw new IllegalArgumentException(c + "is not a character represents number");
-		}
-		
-		return c - '0';
-	}
-	
+
 	public static <T> T orElse(T value, Supplier<T> defaultVal) {
 		Objects.requireNonNull(defaultVal);
-		
+
 		return value == null ? defaultVal.get() : value;
 	}
-	
-	public static CompoundTag parseTagOrThrow(JsonElement jsonElement) {
-		try {
-			return TagParser.parseTag(jsonElement.toString());
-		} catch (CommandSyntaxException e) {
-			throw new RuntimeException("Can't parse element:", e);
-		}
-	}
-	
+
 	private ParseUtil() {}
 }