1.19.4 feature backports

library/core/registry/build.gradle

@@ -15,6 +15,9 @@ qslModule {
 			testmodOnly("resource_loader")
 			testmodOnly("testing")
 		}
+		data {
+			testmodOnly("tags")
+		}
 	}
 	entrypoints {
 		client_init {

library/core/registry/src/main/java/org/quiltmc/qsl/registry/api/dynamic/DynamicMetaRegistry.java

@@ -36,6 +36,57 @@
  * This registry will be frozen at the same time as static registries.
  */
 public final class DynamicMetaRegistry {
+	/**
+	 * Registers a server-side dynamic registry.
+	 * <p>
+	 * Entries will be loaded from {@code "data/<namespace>/<registry_namespace>/<registry_path>"} for every datapack
+	 * {@code namespace}, where {@code registry_namespace} and {@code registry_path}'s values are respectively
+	 * {@code key.getLocation().getNamespace()} and {@code key.getLocation().getPath()}.
+	 *
+	 * @param <E>        the type of elements in the dynamic registry
+	 * @param key        a {@link RegistryKey#ofRegistry(Identifier) key for the new dynamic registry}
+	 * @param entryCodec the codec used to deserialize entries from datapacks
+	 * @throws IllegalStateException if this registry of registries already got frozen
+	 */
+	public static <E> void register(RegistryKey<? extends Registry<E>> key, Codec<E> entryCodec, DynamicRegistryFlag... flags) {
+		DynamicMetaRegistryImpl.register(key, entryCodec, flags);
+	}
+
+	/**
+	 * Registers a dynamic registry which contents get synced between the server and connected clients.
+	 * <p>
+	 * Entries will be loaded from {@code "data/<namespace>/<registry_namespace>/<registry_path>"} for every datapack
+	 * {@code namespace}, where {@code registry_namespace} and {@code registry_path}'s values are respectively
+	 * {@code key.getLocation().getNamespace()} and {@code key.getLocation().getPath()}.
+	 *
+	 * @param <E>        the type of elements in the dynamic registry
+	 * @param key        a {@link RegistryKey#ofRegistry(Identifier) key for the new dynamic registry}
+	 * @param entryCodec the codec used to both deserialize entries from datapacks and (de)serialize entries to and from packets
+	 * @throws IllegalStateException if this registry of registries already got frozen
+	 * @see #registerSynced(RegistryKey, Codec, Codec, DynamicRegistryFlag...)
+	 */
+	public static <E> void registerSynced(RegistryKey<? extends Registry<E>> key, Codec<E> entryCodec, DynamicRegistryFlag... flags) {
+		DynamicMetaRegistryImpl.registerSynced(key, entryCodec, entryCodec, flags);
+	}
+
+	/**
+	 * Registers a dynamic registry which contents get synced between the server and connected clients.
+	 * <p>
+	 * Entries will be loaded from {@code "data/<namespace>/<registry_namespace>/<registry_path>"} for every datapack
+	 * {@code namespace}, where {@code registry_namespace} and {@code registry_path}'s values are respectively
+	 * {@code key.getLocation().getNamespace()} and {@code key.getLocation().getPath()}.
+	 *
+	 * @param <E>        the type of elements in the dynamic registry
+	 * @param key        a {@link RegistryKey#ofRegistry(Identifier) key for the new dynamic registry}
+	 * @param entryCodec the codec used to deserialize entries from datapacks
+	 * @param syncCodec  the codec used to (de)serialize entries to and from packets - may be the same as {@code entryCodec}
+	 * @throws IllegalStateException if this registry of registries already got frozen
+	 * @see #registerSynced(RegistryKey, Codec, DynamicRegistryFlag...)
+	 */
+	public static <E> void registerSynced(RegistryKey<? extends Registry<E>> key, Codec<E> entryCodec, Codec<E> syncCodec, DynamicRegistryFlag... flags) {
+		DynamicMetaRegistryImpl.registerSynced(key, entryCodec, syncCodec, flags);
+	}
+
 	/**
 	 * Registers a server-side dynamic registry.
 	 * <p>

library/core/registry/src/main/java/org/quiltmc/qsl/registry/api/dynamic/DynamicRegistryFlag.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2023 The Quilt Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.registry.api.dynamic;
+
+import net.minecraft.registry.RegistryKey;
+import net.minecraft.util.Identifier;
+
+import org.quiltmc.qsl.registry.impl.dynamic.DynamicMetaRegistryImpl;
+import org.quiltmc.qsl.registry.impl.dynamic.DynamicRegistryFlagManager;
+
+/**
+ * Flags that can be set on dynamic registries to define their behavior.
+ * <p>
+ * All flags are off by default, and can be enabled using static methods in this class or on dynamic registry creation via varargs.
+ *
+ * @see org.quiltmc.qsl.registry.api.sync.RegistrySynchronization  org.quiltmc.qsl.registry.api.sync.RegistrySynchronization,
+ * which contains similar flag setters/getters for static registries
+ */
+public enum DynamicRegistryFlag {
+	/**
+	 * Indicates that this registry (and the entries within) do not necessarily need to be sent
+	 * to (logical) clients for synchronization in multiplayer contexts.
+	 * <p>
+	 * <b>Note:</b> This flag is intended only for synchronized dynamic registries. On non-synced dynamic registries, this flag does nothing.
+	 * <p>
+	 * One use-case for this flag is for creating mods that are entirely compatible with vanilla, and thus do not
+	 * require the dynamic registry to exist clientside to connect to the server.
+	 * This allows for both vanilla clients/clients without the mod to connect <i>and</i> for clients with the mod
+	 * supplying the registry to connect, with the latter being able to see the contents of the registry and possibly
+	 * enable extra clientside features accordingly.
+	 */
+	OPTIONAL;
+
+	/**
+	 * Enables a specific flag on a dynamic registry.
+	 *
+	 * @param registryId the value id ({@link RegistryKey#getValue()}) of the target dynamic registry
+	 * @param flag the flag value to enable on the dynamic registry
+	 */
+	public static void setFlag(Identifier registryId, DynamicRegistryFlag flag) {
+		try {
+			DynamicRegistryFlagManager.setFlag(registryId, flag);
+		} catch (Exception e) {
+			logFlagModifyException(registryId, flag, e);
+		}
+	}
+
+	/**
+	 * Checks if a dynamic registry has the {@link DynamicRegistryFlag#OPTIONAL} flag enabled on it.
+	 *
+	 * @param registryId the value id ({@link RegistryKey#getValue()}) of the dynamic registry to check
+	 * @return whether the checked dynamic registry has the {@link DynamicRegistryFlag#OPTIONAL} flag enabled
+	 */
+	public static boolean isOptional(Identifier registryId) {
+		return DynamicRegistryFlagManager.isOptional(registryId);
+	}
+
+	/**
+	 * Helper method for logging exceptions to avoid code duplication.
+	 */
+	private static void logFlagModifyException(Identifier registryId, DynamicRegistryFlag flag, Exception e) {
+		DynamicMetaRegistryImpl.LOGGER.error("Caught exception while attempting to enable flag {} on registry id {}: {}", flag.toString(), registryId, e.toString());
+	}
+}

library/core/registry/src/main/java/org/quiltmc/qsl/registry/impl/dynamic/DynamicMetaRegistryImpl.java

@@ -22,31 +22,44 @@
 import com.google.common.collect.ImmutableMap;
 import com.mojang.serialization.Codec;
 import org.jetbrains.annotations.ApiStatus;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import net.minecraft.registry.Registry;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.registry.RegistryLoader;
 import net.minecraft.util.Identifier;
 
 import org.quiltmc.qsl.registry.mixin.DynamicRegistrySyncAccessor;
+import org.quiltmc.qsl.registry.api.dynamic.DynamicRegistryFlag;
 
 @ApiStatus.Internal
 public class DynamicMetaRegistryImpl {
 	private static boolean frozen;
 	private static final Set<Identifier> MODDED_REGISTRY_IDS = new HashSet<>();
 
+	public static final Logger LOGGER = LoggerFactory.getLogger("quilt_dynamic_registries");
+
 	public static boolean isModdedRegistryId(Identifier id) {
 		return MODDED_REGISTRY_IDS.contains(id);
 	}
 
-	public static <E> void register(RegistryKey<? extends Registry<E>> ref, Codec<E> entryCodec) {
+	public static <E> void register(RegistryKey<? extends Registry<E>> ref, Codec<E> entryCodec, DynamicRegistryFlag... flags) {
+		if (ref.getValue().getNamespace().equals(Identifier.DEFAULT_NAMESPACE)) {
+			throw new IllegalStateException("The '" + ref.getValue() + "' dynamic registry cannot have 'minecraft' as its identifier's namespace!");
+		}
+
 		if (frozen) throw new IllegalStateException("Registry is already frozen");
+
 		MODDED_REGISTRY_IDS.add(ref.getValue());
 		RegistryLoader.WORLDGEN_REGISTRIES.add(new RegistryLoader.DecodingData<>(ref, entryCodec));
+		for (DynamicRegistryFlag flag : flags) {
+			DynamicRegistryFlagManager.setFlag(ref.getValue(), flag);
+		}
 	}
 
-	public static <E> void registerSynced(RegistryKey<? extends Registry<E>> ref, Codec<E> entryCodec, Codec<E> syncCodec) {
-		register(ref, entryCodec);
+	public static <E> void registerSynced(RegistryKey<? extends Registry<E>> ref, Codec<E> entryCodec, Codec<E> syncCodec, DynamicRegistryFlag... flags) {
+		register(ref, entryCodec, flags);
 		var builder = ImmutableMap.<RegistryKey<? extends Registry<?>>, Object>builder().putAll(DynamicRegistrySyncAccessor.quilt$getSyncedCodecs());
 		DynamicRegistrySyncAccessor.quilt$invokeAddSyncedRegistry(builder, ref, syncCodec);
 		DynamicRegistrySyncAccessor.quilt$setSyncedCodecs(builder.build());
@@ -55,4 +68,8 @@ public static <E> void registerSynced(RegistryKey<? extends Registry<E>> ref, Co
 	public static void freeze() {
 		frozen = true;
 	}
+
+	static boolean isFrozen() {
+		return frozen;
+	}
 }

library/core/registry/src/main/java/org/quiltmc/qsl/registry/impl/dynamic/DynamicRegistryFlagManager.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2023 The Quilt Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.registry.impl.dynamic;
+
+import org.jetbrains.annotations.ApiStatus;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.MultimapBuilder;
+
+import net.minecraft.util.Identifier;
+
+import org.quiltmc.qsl.registry.api.dynamic.DynamicRegistryFlag;
+
+@ApiStatus.Internal
+public final class DynamicRegistryFlagManager {
+	private static final Multimap<Identifier, DynamicRegistryFlag> DYNAMIC_REGISTRY_FLAGS =
+			MultimapBuilder.hashKeys().enumSetValues(DynamicRegistryFlag.class).build();
+
+	public static void setFlag(Identifier registryId, DynamicRegistryFlag flag) throws IllegalStateException {
+		if (DynamicMetaRegistryImpl.isFrozen()) {
+			throw new IllegalStateException("Dynamic registries are frozen, and thus flags cannot be changed!");
+		}
+
+		if (!DynamicMetaRegistryImpl.isModdedRegistryId(registryId)) return;
+
+		DYNAMIC_REGISTRY_FLAGS.put(registryId, flag);
+	}
+
+	public static boolean isOptional(Identifier registryId) {
+		if (DYNAMIC_REGISTRY_FLAGS.containsKey(registryId)) {
+			return DYNAMIC_REGISTRY_FLAGS.get(registryId).contains(DynamicRegistryFlag.OPTIONAL);
+		}
+
+		return false;
+	}
+}

library/core/registry/src/main/java/org/quiltmc/qsl/registry/mixin/DynamicRegistrySyncMixin.java

@@ -1,4 +1,5 @@
 /*
+ * Copyright 2016, 2017, 2018, 2019 FabricMC
  * Copyright 2023 The Quilt Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,21 +18,53 @@
 package org.quiltmc.qsl.registry.mixin;
 
 import java.util.Map;
+import java.util.stream.Stream;
 
+import org.spongepowered.asm.mixin.Dynamic;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Mutable;
 import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
 
+import net.minecraft.registry.DynamicRegistryManager;
 import net.minecraft.registry.DynamicRegistrySync;
 import net.minecraft.registry.Registry;
 import net.minecraft.registry.RegistryKey;
 
+import org.quiltmc.qsl.registry.impl.dynamic.DynamicRegistryFlagManager;
+
 @Mixin(DynamicRegistrySync.class)
 public abstract class DynamicRegistrySyncMixin {
 	@SuppressWarnings("unused")	// makes the field mutable for use by the accessor
 	@Shadow
 	@Final
 	@Mutable
 	private static Map<RegistryKey<? extends Registry<?>>, ?> SYNCED_CODECS;
+	@Unique
+	private static boolean filterRegistryEntry(DynamicRegistryManager.RegistryEntry<?> entry) {
+		// OPTIONAL
+		if (DynamicRegistryFlagManager.isOptional(entry.key().getValue())) {
+			return entry.value().size() > 0;
+		}
+
+		return true; // If no flags apply, always return true
+	}
+
+	@Shadow
+	private static Stream<DynamicRegistryManager.RegistryEntry<?>> streamSyncedRegistries(DynamicRegistryManager registryManager) {
+		throw new IllegalStateException("Mixin injection failed.");
+	}
+
+	/**
+	 * This redirect mixin's annotation was taken directly from Fabric API (and adapted for Quilt Mappings), the rest of this file was not.
+	 */
+	@Dynamic("method_45961: Codec.xmap in buildManagerCodec")
+	@Redirect(method = "method_45961",
+			at = @At(value = "INVOKE", target = "Lnet/minecraft/registry/DynamicRegistrySync;streamSyncedRegistries(Lnet/minecraft/registry/DynamicRegistryManager;)Ljava/util/stream/Stream;"))
+	private static Stream<DynamicRegistryManager.RegistryEntry<?>> filterNonSyncedEntries(DynamicRegistryManager drm) {
+		return streamSyncedRegistries(drm).filter(DynamicRegistrySyncMixin::filterRegistryEntry);
+	}
 }

library/core/registry/src/main/java/org/quiltmc/qsl/registry/mixin/TagManagerLoaderMixin.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2023 The Quilt Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.registry.mixin;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import net.minecraft.registry.Registry;
+import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.tag.TagManagerLoader;
+import net.minecraft.util.Identifier;
+
+import org.quiltmc.qsl.registry.impl.dynamic.DynamicMetaRegistryImpl;
+
+@Mixin(TagManagerLoader.class)
+public class TagManagerLoaderMixin {
+	@Inject(method = "getRegistryDirectory", at = @At("HEAD"), cancellable = true)
+	private static void quilt$replaceModdedDynamicRegistryTagPath(RegistryKey<? extends Registry<?>> registry, CallbackInfoReturnable<String> cir) {
+		Identifier id = registry.getValue();
+		if (DynamicMetaRegistryImpl.isModdedRegistryId(id)) {
+			cir.setReturnValue("tags/" + id.getNamespace() + "/" + id.getPath());
+		}
+	}
+}

library/core/registry/src/main/resources/quilt_registry.mixins.json

@@ -19,6 +19,7 @@
     "ServerPlayerEntityMixin",
     "ServerPlayNetworkHandlerAccessor",
     "SimpleRegistryMixin",
+    "TagManagerLoaderMixin",
     "patch.BeaconBlockEntityMixin",
     "patch.MooshroomEntityMixin",
     "patch.StatusEffectInstanceMixin",