Quartz 4

ModelProvider.java

4 min read

ModelProvider.java

net.minecraft.client.data.models.ModelProvider

信息

  • 全限定名：net.minecraft.client.data.models.ModelProvider
  • 类型：public class
  • 包：net.minecraft.client.data.models
  • 源码路径：src/main/java/net/minecraft/client/data/models/ModelProvider.java
  • 起始行号：L33
  • 实现：DataProvider
  • 职责：

    TODO

字段/常量

  • blockStatePathProvider

    • 类型: PackOutput.PathProvider
    • 修饰符: private final
    • 源码定位: L34
    • 说明:

      TODO

  • itemInfoPathProvider

    • 类型: PackOutput.PathProvider
    • 修饰符: private final
    • 源码定位: L35
    • 说明:

      TODO

  • modelPathProvider

    • 类型: PackOutput.PathProvider
    • 修饰符: private final
    • 源码定位: L36
    • 说明:

      TODO

内部类/嵌套类型

  • net.minecraft.client.data.models.ModelProvider.BlockStateGeneratorCollector

    • 类型: class
    • 修饰符: private static
    • 源码定位: L66
    • 说明:

      TODO

  • net.minecraft.client.data.models.ModelProvider.ItemInfoCollector

    • 类型: class
    • 修饰符: private static
    • 源码定位: L96
    • 说明:

      TODO

  • net.minecraft.client.data.models.ModelProvider.SimpleModelCollector

    • 类型: class
    • 修饰符: private static
    • 源码定位: L150
    • 说明:

      TODO

构造器

public ModelProvider(PackOutput output) @ L38

  • 构造器名：ModelProvider
  • 源码定位：L38
  • 修饰符：public

参数:

  • output: PackOutput

说明:

TODO

方法

下面的方法块按源码顺序生成。

public CompletableFuture<?> run(CachedOutput cache) @ L44

  • 方法名：run
  • 源码定位：L44
  • 返回类型：CompletableFuture<?>
  • 修饰符：public

参数:

  • cache: CachedOutput

说明:

TODO

public final String getName() @ L60

  • 方法名：getName
  • 源码定位：L60
  • 返回类型：String
  • 修饰符：public final

参数:

  • 无

说明:

TODO

代码

@OnlyIn(Dist.CLIENT)
public class ModelProvider implements DataProvider {
    private final PackOutput.PathProvider blockStatePathProvider;
    private final PackOutput.PathProvider itemInfoPathProvider;
    private final PackOutput.PathProvider modelPathProvider;
 
    public ModelProvider(PackOutput output) {
        this.blockStatePathProvider = output.createPathProvider(PackOutput.Target.RESOURCE_PACK, "blockstates");
        this.itemInfoPathProvider = output.createPathProvider(PackOutput.Target.RESOURCE_PACK, "items");
        this.modelPathProvider = output.createPathProvider(PackOutput.Target.RESOURCE_PACK, "models");
    }
 
    @Override
    public CompletableFuture<?> run(CachedOutput cache) {
        ModelProvider.ItemInfoCollector itemModels = new ModelProvider.ItemInfoCollector();
        ModelProvider.BlockStateGeneratorCollector blockStateGenerators = new ModelProvider.BlockStateGeneratorCollector();
        ModelProvider.SimpleModelCollector simpleModels = new ModelProvider.SimpleModelCollector();
        new BlockModelGenerators(blockStateGenerators, itemModels, simpleModels).run();
        new ItemModelGenerators(itemModels, simpleModels).run();
        blockStateGenerators.validate();
        itemModels.finalizeAndValidate();
        return CompletableFuture.allOf(
            blockStateGenerators.save(cache, this.blockStatePathProvider),
            simpleModels.save(cache, this.modelPathProvider),
            itemModels.save(cache, this.itemInfoPathProvider)
        );
    }
 
    @Override
    public final String getName() {
        return "Model Definitions";
    }
 
    @OnlyIn(Dist.CLIENT)
    private static class BlockStateGeneratorCollector implements Consumer<BlockModelDefinitionGenerator> {
        private final Map<Block, BlockModelDefinitionGenerator> generators = new HashMap<>();
 
        public void accept(BlockModelDefinitionGenerator generator) {
            Block block = generator.block();
            BlockModelDefinitionGenerator prev = this.generators.put(block, generator);
            if (prev != null) {
                throw new IllegalStateException("Duplicate blockstate definition for " + block);
            }
        }
 
        public void validate() {
            List<Identifier> missingDefinitions = BuiltInRegistries.BLOCK
                .listElements()
                .filter(e -> !this.generators.containsKey(e.value()))
                .map(e -> e.key().identifier())
                .toList();
            if (!missingDefinitions.isEmpty()) {
                throw new IllegalStateException("Missing blockstate definitions for: " + missingDefinitions);
            }
        }
 
        public CompletableFuture<?> save(CachedOutput cache, PackOutput.PathProvider pathProvider) {
            Map<Block, BlockStateModelDispatcher> definitions = Maps.transformValues(this.generators, BlockModelDefinitionGenerator::create);
            Function<Block, Path> pathGetter = block -> pathProvider.json(block.builtInRegistryHolder().key().identifier());
            return DataProvider.saveAll(cache, BlockStateModelDispatcher.CODEC, pathGetter, definitions);
        }
    }
 
    @OnlyIn(Dist.CLIENT)
    private static class ItemInfoCollector implements ItemModelOutput {
        private final Map<Item, ClientItem> itemInfos = new HashMap<>();
        private final Map<Item, Item> copies = new HashMap<>();
 
        @Override
        public void accept(Item item, ItemModel.Unbaked model, ClientItem.Properties properties) {
            this.register(item, new ClientItem(model, properties));
        }
 
        private void register(Item item, ClientItem itemInfo) {
            ClientItem prev = this.itemInfos.put(item, itemInfo);
            if (prev != null) {
                throw new IllegalStateException("Duplicate item model definition for " + item);
            }
        }
 
        @Override
        public void copy(Item donor, Item acceptor) {
            this.copies.put(acceptor, donor);
        }
 
        public void finalizeAndValidate() {
            BuiltInRegistries.ITEM.forEach(item -> {
                if (!this.copies.containsKey(item)) {
                    if (item instanceof BlockItem blockItem && !this.itemInfos.containsKey(blockItem)) {
                        Identifier targetModel = ModelLocationUtils.getModelLocation(blockItem.getBlock());
                        this.accept(blockItem, ItemModelUtils.plainModel(targetModel));
                    }
                }
            });
            this.copies.forEach((acceptor, donor) -> {
                ClientItem donorInfo = this.itemInfos.get(donor);
                if (donorInfo == null) {
                    throw new IllegalStateException("Missing donor: " + donor + " -> " + acceptor);
                } else {
                    this.register(acceptor, donorInfo);
                }
            });
            List<Identifier> missingDefinitions = BuiltInRegistries.ITEM
                .listElements()
                .filter(e -> !this.itemInfos.containsKey(e.value()))
                .map(e -> e.key().identifier())
                .toList();
            if (!missingDefinitions.isEmpty()) {
                throw new IllegalStateException("Missing item model definitions for: " + missingDefinitions);
            }
        }
 
        public CompletableFuture<?> save(CachedOutput cache, PackOutput.PathProvider pathProvider) {
            return DataProvider.saveAll(cache, ClientItem.CODEC, item -> pathProvider.json(item.builtInRegistryHolder().key().identifier()), this.itemInfos);
        }
    }
 
    @OnlyIn(Dist.CLIENT)
    private static class SimpleModelCollector implements BiConsumer<Identifier, ModelInstance> {
        private final Map<Identifier, ModelInstance> models = new HashMap<>();
 
        public void accept(Identifier id, ModelInstance contents) {
            Supplier<JsonElement> prev = this.models.put(id, contents);
            if (prev != null) {
                throw new IllegalStateException("Duplicate model definition for " + id);
            }
        }
 
        public CompletableFuture<?> save(CachedOutput cache, PackOutput.PathProvider pathProvider) {
            return DataProvider.saveAll(cache, Supplier::get, pathProvider::json, this.models);
        }
    }
}

引用的其他类

Graph View

Backlinks