java类net.minecraft.client.renderer.block.statemap.StateMapperBase的实例源码

public void registerModels()
{
    ItemModels.register();
    //BlockModels.register();

    ModelLoader.setCustomStateMapper(ModBlocks.thorns,new StateMap.Builder().ignore(BlockThorns.FACING).build());
    ModelLoader.setCustomStateMapper(ModBlocks.brine, new BrineStateMapper());
    ModelLoader.setCustomStateMapper(ModBlocks.aqueductWater, new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return aqueductWaterLocation;
        }
    });

    RenderingRegistry.registerEntityRenderingHandler(EntityGreatarrow.class, RenderGreatarrow.GREATARROW_RENDER);
    RenderingRegistry.registerEntityRenderingHandler(EntityYa.class, RenderYa.YA_RENDER);
    RenderingRegistry.registerEntityRenderingHandler(EntitySpirit.class, manager -> new RenderSpirit(manager));
    RenderingRegistry.registerEntityRenderingHandler(EntityAncestryBottle.class, manager -> new RenderSnowball<>(manager,ModItems.ancestryBottle,Minecraft.getMinecraft().getRenderItem()));
    RenderingRegistry.registerEntityRenderingHandler(EntityArtifactFrame.class, RenderArtifactFrame.ARTIFACEFRAME_RENDER);
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityAlchDragon.class, new RenderAlchDragon());
}

@Override
@SideOnly(Side.CLIENT)
public void initModel() {
    StateMapperBase ignoreState = new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState iBlockState) {
            return ModelPipeBaked.BAKED_MODEL;
        }
    };
    ModelLoader.setCustomStateMapper(this, ignoreState);
    ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(getRegistryName(), "inventory");
    //for(PipeType type : PipeType.values())
    // Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(Item.getItemFromBlock(this), type.getMeta(), itemModelResourceLocation);
    for(PipeType type : PipeType.values())
        ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(this), type.getMeta(), itemModelResourceLocation);
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityPipe.class, new TileEntityPipeRenderer());
}

public static void registerBlockWithStateMapper(Block block)
{
    Minecraft.getMinecraft().getRenderItem().getItemModelMesher().getModelManager().getBlockModelShapes().registerBlockWithStateMapper(block, new StateMapperBase() 
    {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state)
        {
            return new ModelResourceLocation(state.getBlock().getRegistryName(), "normal");
        }

    });

    Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(Item.getItemFromBlock(block), new ItemMeshDefinition() 
    {
        @Override
        public ModelResourceLocation getModelLocation(ItemStack stack) 
        {
            return new ModelResourceLocation(stack.getItem().getRegistryName(), "inventory");
        }
    });
}

public static final void registerFluidsClient()
{
    final ModelResourceLocation fluidSteamLocation = new ModelResourceLocation(QBarConstants.MODID + ":" +
            "blockfluidsteam",
            "steam");
    ModelLoader.setCustomStateMapper(QBarFluids.blockFluidSteam, new StateMapperBase()
    {
        @Override
        protected ModelResourceLocation getModelResourceLocation(final IBlockState state)
        {
            return fluidSteamLocation;
        }
    });

    ModelBakery.registerItemVariants(Item.getItemFromBlock(QBarFluids.blockFluidSteam), fluidSteamLocation);
    ModelLoader.setCustomMeshDefinition(Item.getItemFromBlock(QBarFluids.blockFluidSteam),
            stack -> fluidSteamLocation);
}

@SideOnly(Side.CLIENT)
public void registerRenderer() {
    IFluidBlock block = BlocksRegistry.liquidXpBlock;
    Item item = Item.getItemFromBlock((Block)block);
    assert (item == Items.AIR);

    ModelBakery.registerItemVariants(item);

    ModelResourceLocation modelResourceLocation = new ModelResourceLocation(MekfarmMod.MODID + ":fluids", this.getName());

    ModelLoader.setCustomMeshDefinition(item, new ItemMeshDefinition() {
        @Override
        public ModelResourceLocation getModelLocation(ItemStack stack) {
            return modelResourceLocation;
        }
    });

    ModelLoader.setCustomStateMapper((Block) block, new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return modelResourceLocation;
        }
    });
}

@SideOnly(Side.CLIENT)
public void registerRenderer() {
    IFluidBlock block = BlocksRegistry.sewageBlock;
    Item item = Item.getItemFromBlock((Block)block);
    assert (item == Items.AIR);

    ModelBakery.registerItemVariants(item);

    ModelResourceLocation modelResourceLocation = new ModelResourceLocation(MekfarmMod.MODID + ":fluids", this.getName());

    ModelLoader.setCustomMeshDefinition(item, new ItemMeshDefinition() {
        @Override
        public ModelResourceLocation getModelLocation(ItemStack stack) {
            return modelResourceLocation;
        }
    });

    ModelLoader.setCustomStateMapper((Block) block, new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return modelResourceLocation;
        }
    });
}

public void registerFluidModel(Block  block) {
    Item item = Item.getItemFromBlock(block);

    ModelBakery.registerItemVariants(item);

    final ModelResourceLocation loc = new ModelResourceLocation(Reference.MODID + ":fluid", "liquidmalgra");

    ModelLoader.setCustomMeshDefinition(item, new ItemMeshDefinition() {
        @Override
        public ModelResourceLocation getModelLocation(ItemStack stack) {
            return loc;
        }
    });

    ModelLoader.setCustomStateMapper(block, new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return loc;
        }
    });
}

@Override
public void preInit(FMLPreInitializationEvent event) {
    super.preInit(event);
    for (final String name : Fluids.getFluidBlockRegistry().keySet()) {
        final Block block = Fluids.getFluidBlockByName(name);
        final Item item = Item.getItemFromBlock(block);
        if (!item.getRegistryName().getResourceDomain().equals(BaseGems.MODID))
            continue;
        final ModelResourceLocation fluidModelLocation = new ModelResourceLocation(item.getRegistryName().getResourceDomain() + ":" + name, "fluid");
        ModelBakery.registerItemVariants(item);
        ModelLoader.setCustomMeshDefinition(item, stack -> fluidModelLocation);
        ModelLoader.setCustomStateMapper(block, new StateMapperBase() {
            @Override
            protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
                return fluidModelLocation;
            }
        });
    }
}

@SideOnly(Side.CLIENT)
public void registerCustomBlockRenderer(ICustomRenderedBlock customRenderedBlock) {
    if (customRenderedBlock == null || !(customRenderedBlock instanceof BlockBase)) {
        return;
    }
    //set custom state mapper
    StateMapperBase stateMapper = new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return customRenderedBlock.getBlockModelResourceLocation();
        }
    };
    ModelLoader.setCustomStateMapper((BlockBase) customRenderedBlock, stateMapper);
    //register renderers
    if (customRenderedBlock instanceof ICustomRenderedBlockWithTile) {
        registerTileRenderer((ICustomRenderedBlockWithTile) customRenderedBlock);
    } else {
        registerBlockRenderer(customRenderedBlock);
    }
}

@SideOnly(Side.CLIENT)
public static void buildRenderFor(Block block, String name)
{
    final ModelResourceLocation fluidLocation = new ModelResourceLocation(MReference.MODID + ":" + name, "fluid");
    Item fluid = Item.getItemFromBlock(block);
    ModelBakery.addVariantName(fluid);
    ModelLoader.setCustomMeshDefinition(fluid, new ItemMeshDefinition()
    {
        @Override
        public ModelResourceLocation getModelLocation(ItemStack stack)
        {
            return fluidLocation;
        }
    });
    ModelLoader.setCustomStateMapper(block, new StateMapperBase()
    {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state)
        {
            return fluidLocation;
        }
    });
}

@SideOnly(Side.CLIENT)
public static void bakeModels(String modID){
    for(Fluid fluid : fluidBlocks.keySet()){
        BlockFluidBase block = fluidBlocks.get(fluid);
        Item item = Item.getItemFromBlock(block);
        final ModelResourceLocation fluidModelLocation = new ModelResourceLocation(
                modID.toLowerCase() + ":" + fluidBlockNames.get(block), "fluid");
           ModelBakery.registerItemVariants(item);
        ModelLoader.setCustomMeshDefinition(item, new ItemMeshDefinition()
        {
            public ModelResourceLocation getModelLocation(ItemStack stack)
            {
                return fluidModelLocation;
            }
        });
        ModelLoader.setCustomStateMapper(block, new StateMapperBase()
        {
            protected ModelResourceLocation getModelResourceLocation(IBlockState state)
            {
                return fluidModelLocation;
            }
        });
    }
}

private void registerFluidModel(Block fluidBlock, String name) {
    Item item = Item.getItemFromBlock(fluidBlock);

    ModelBakery.registerItemVariants(item);

    final ModelResourceLocation modelResourceLocation = new ModelResourceLocation("abyssalcraft:fluid", name);

    ModelLoader.setCustomMeshDefinition(item, stack -> modelResourceLocation);

    ModelLoader.setCustomStateMapper(fluidBlock, new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState p_178132_1_) {
            return modelResourceLocation;
        }
    });
}

@Override
public void registerFluidBlockRendering(Block block, String name) 
{       
    final ModelResourceLocation fluidLocation = new ModelResourceLocation(HarshenCastle.MODID.toLowerCase() + ":fluids", name);

    ModelLoader.setCustomStateMapper(block, new StateMapperBase()
    {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state)
        {

            return fluidLocation;
        }
    });
}

@SideOnly(Side.CLIENT)
public static void initModels()
{
    Item item = Item.getItemFromBlock(ModBlocks.liquid_butter);

    ModelBakery.registerItemVariants(item);
    ModelResourceLocation location = new ModelResourceLocation("btweagles:fluid", "liquid_butter");
    ModelLoader.setCustomMeshDefinition(item, stack -> location);
    ModelLoader.setCustomStateMapper(ModBlocks.liquid_butter, new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return location;
        }
    });
}

@SubscribeEvent
public static void registerModels(ModelRegistryEvent event){
    StateMapperBase mapper=new StateMapperBase() {

        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return new ModelResourceLocation(new ResourceLocation(Constants.MODID, "creosote"), "creosote");
        }
    };
    if(FluidsRegistry.BlockCreosote!=null)
        ModelLoader.setCustomStateMapper(FluidsRegistry.BlockCreosote, mapper);
}

@Override
@SideOnly(Side.CLIENT)
public void setupModels()
{
    StateMapperBase st = new StateMapperBase()
    {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state)
        {
            MagibenchRegistry.Tier t = PurMag.INSTANCE.getMagibenchRegistry().getTier(state.getValue(TIER));
            return new ModelResourceLocation(t.getSmartModel(), "normal");
        }
    };
    ModelLoader.setCustomStateMapper(this, st);
}

@SideOnly(Side.CLIENT)
protected void registerFluidRender(BlockFluidBase blockFluid, String blockStateName) {
    final String location = FoodCraftReloaded.MODID + ":" + blockStateName;
    final Item itemFluid = Item.getItemFromBlock(blockFluid);
    ModelLoader.setCustomMeshDefinition(itemFluid, stack -> new ModelResourceLocation(location, "fluid"));
    ModelLoader.setCustomStateMapper(blockFluid, new StateMapperBase() {
        @Nonnull
        @Override
        protected ModelResourceLocation getModelResourceLocation(@Nonnull IBlockState state) {
            return new ModelResourceLocation(location, "fluid");
        }
    });
}

@Override
public void registerFluidRenderers(ModelResourceLocation modelResourceLocation) {
    ModelLoader.setCustomStateMapper(GSBlock.TOXIC_WATER, new StateMapperBase() {
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return modelResourceLocation;
        }
    });
}

@SideOnly(Side.CLIENT)
public static void registerStateMapper(Block block) {
    if (!(block instanceof IBlockStateMap)) return;
    ModelLoader.setCustomStateMapper(block, new StateMapperBase() {
        @Override
        @Nonnull
        protected ModelResourceLocation getModelResourceLocation(@Nonnull IBlockState state) {
            return new ModelResourceLocation(((IBlockStateMap) block).getResourceLocation(state), ((IBlockStateMap) block).getVarient(state));
        }
    });
}

/** Make sure to set up the rendering info */
@SideOnly(Side.CLIENT)
public static void registerRendering() {
    for(Fluid fluid : fluidBlocks.keySet()) {
        BlockFluidBase block = fluidBlocks.get(fluid);
        final ModelResourceLocation fluidModelLocation = new ModelResourceLocation(
                RefStrings.MODID + ":" + fluidBlockNames.get(block), "fluid");
        ModelLoader.setCustomStateMapper(block, new StateMapperBase() {
            @Override
            protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
                return fluidModelLocation;
            }
        });
    }
}

@SideOnly(Side.CLIENT)
public void initModel() {
    ModelResourceLocation fluidLocation = new ModelResourceLocation(getRegistryName(), "fluid");

    StateMapperBase customState = new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState iBlockState) {
            return fluidLocation;
        }
    };
    ModelLoader.setCustomStateMapper(this, customState);
    ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(this), 0, new ModelResourceLocation(getRegistryName(), "inventory"));
}

@Override
@SideOnly(Side.CLIENT)
public void initModel() {
    StateMapperBase ignoreState = new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState iBlockState) {
            return TankBakedModel.BAKED_TANK;
        }
    };
    ModelLoader.setCustomStateMapper(this, ignoreState);
    ClientRegistry.bindTileEntitySpecialRenderer(TankTE.class, new TankTESR());
}

public void initModel(){
    final ModelResourceLocation mrl = new ModelResourceLocation(Constants.MODID+":GlowOre_" + Type);
       StateMapperBase ignoreState = new StateMapperBase() {
           @Override
           protected ModelResourceLocation getModelResourceLocation(IBlockState iBlockState) {
               return mrl;
           }
       };
       ModelLoader.setCustomStateMapper(this, ignoreState);
       ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(this), 0, new ModelResourceLocation(Constants.MODID+Type,"inventory"));
}

@SideOnly(Side.CLIENT)
public void registerModel(Block block) {
    nameToMimicingBlock.put(MIMIC_PREFIX + blockName, block);

    ModelLoader.setCustomStateMapper(this, new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return new ModelResourceLocation(MIMIC_PREFIX + blockName);
        }
    });
}

@SideOnly(Side.CLIENT)
@Override
public void initModel() {
  Block block = FluidsRegistry.block_milk;
  Item item = Item.getItemFromBlock(block);
  ModelBakery.registerItemVariants(item);
  final ModelResourceLocation modelResourceLocation = new ModelResourceLocation(Const.MODID + ":fluid", stack.getFluid().getName());
  ModelLoader.setCustomModelResourceLocation(item, 0, modelResourceLocation);
  ModelLoader.setCustomStateMapper(block, new StateMapperBase() {
    @Override
    protected ModelResourceLocation getModelResourceLocation(IBlockState bs) {
      return modelResourceLocation;
    }
  });
}

@SideOnly(Side.CLIENT)
@Override
public void initModel() {
  Block block = FluidsRegistry.block_poison;
  Item item = Item.getItemFromBlock(block);
  ModelBakery.registerItemVariants(item);
  final ModelResourceLocation modelResourceLocation = new ModelResourceLocation(Const.MODID + ":fluid", stack.getFluid().getName());
  ModelLoader.setCustomModelResourceLocation(item, 0, modelResourceLocation);
  ModelLoader.setCustomStateMapper(block, new StateMapperBase() {
    @Override
    protected ModelResourceLocation getModelResourceLocation(IBlockState bs) {
      return modelResourceLocation;
    }
  });
}

@SideOnly(Side.CLIENT)
@Override
public void initModel() {
  Block block = FluidsRegistry.block_exp;
  Item item = Item.getItemFromBlock(block);
  ModelBakery.registerItemVariants(item);
  final ModelResourceLocation modelResourceLocation = new ModelResourceLocation(Const.MODID + ":fluid", stack.getFluid().getName());
  ModelLoader.setCustomModelResourceLocation(item, 0, modelResourceLocation);
  ModelLoader.setCustomStateMapper(block, new StateMapperBase() {
    @Override
    protected ModelResourceLocation getModelResourceLocation(IBlockState bs) {
      return modelResourceLocation;
    }
  });
}

@Override
public void registerDustStateMapper(ADustStorageBlock dustBlock){
    RunesOfWizardry.log().info("Creating StateMapper for "+dustBlock.getName());
    StateMapperBase mapper = new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState iBlockState) {
            ModelResourceLocation loc =new ModelResourceLocation(References.texture_path+"dust_storage");
            //System.err.println(loc.toString());
            return loc;
        }
    };
    ModelLoader.setCustomStateMapper(dustBlock.getInstance(), mapper);
}

/**
 * Adds fluid block models to the game and applies them to the fluid blocks
 */
@SideOnly(Side.CLIENT)
public static void bakeModels(){
    String modID = PowerAdvantage.MODID;
    for(Map.Entry<String,Block> e : allBlocks.entrySet()){
        Block b = e.getValue();
        String name = e.getKey();
        if(b instanceof BlockFluidBase){
            BlockFluidBase block = (BlockFluidBase)b;
            Fluid fluid = block.getFluid();
            Item item = Item.getItemFromBlock(block);
            final ModelResourceLocation fluidModelLocation = new ModelResourceLocation(
                    modID.toLowerCase() + ":" + name, "fluid");
            ModelBakery.registerItemVariants(item);
            ModelLoader.setCustomMeshDefinition(item, new ItemMeshDefinition()
            {
                public ModelResourceLocation getModelLocation(ItemStack stack)
                {
                    return fluidModelLocation;
                }
            });
            ModelLoader.setCustomStateMapper(block, new StateMapperBase()
            {
                protected ModelResourceLocation getModelResourceLocation(IBlockState state)
                {
                    return fluidModelLocation;
                }
            });
        }
    }
}

/**
 * Always returns the same base texture, since ISmartModel will handle the actual render state
 */
@Override
@SideOnly(Side.CLIENT)
public IStateMapper getCustomStateMap() {
    return new StateMapperBase() {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
            return ModelDungeonBlock.resource;
        }
    };
}