cpw.mods.fml.client.registry.ClientRegistry Java Examples

private void registerBlockRenderers() {
	if (EtFuturum.enableSlimeBlock)
		RenderingRegistry.registerBlockHandler(new BlockSlimeBlockRender());

	if (EtFuturum.enableDoors)
		RenderingRegistry.registerBlockHandler(new BlockDoorRenderer());

	if (EtFuturum.enableBanners)
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityBanner.class, new TileEntityBannerRenderer());

	if (EtFuturum.enableFancySkulls)
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySkull.class, new TileEntityFancySkullRenderer());

	if (EtFuturum.enableChorusFruit) {
		RenderingRegistry.registerBlockHandler(new BlockEndRodRender());
		RenderingRegistry.registerBlockHandler(new BlockChorusFlowerRender());
		RenderingRegistry.registerBlockHandler(new BlockChorusPlantRender());
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityEndRod.class, new TileEntityEndRodRenderer());
	}

	if (EtFuturum.enableColourfulBeacons)
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityNewBeacon.class, new TileEntityNewBeaconRenderer());

	RenderingRegistry.registerBlockHandler(new BlockChestRenderer());
}
 

@Override
public void init()
{
    if(config.getTag("checkUpdates").getBooleanValue(true))
        CCUpdateChecker.updateCheck("EnderStorage");
    ClientUtils.enhanceSupportersList("EnderStorage");

    super.init();

    PacketCustom.assignHandler(EnderStorageCPH.channel, new EnderStorageCPH());

    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(blockEnderChest), new ItemEnderStorageRenderer());

    ClientRegistry.bindTileEntitySpecialRenderer(TileEnderChest.class, new EnderChestRenderer());
    ClientRegistry.bindTileEntitySpecialRenderer(TileEnderTank.class, new EnderTankRenderer());
}
 

@Override
public void registerRenderers() {

    MinecraftForge.EVENT_BUS.register(new IconSupplier());

    ClientRegistry.bindTileEntitySpecialRenderer(TileMoving.class, new RenderMoving());
    MinecraftForgeClient.registerItemRenderer(FramezItems.frame, new RenderFrame());

    RenderMotor motorRenderer = new RenderMotor();
    ClientRegistry.bindTileEntitySpecialRenderer(TileMotor.class, motorRenderer);
    RenderingRegistry.registerBlockHandler(motorRenderer);
    for (Block m : FramezBlocks.motors.keySet())
        MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(m), motorRenderer);

    MinecraftForge.EVENT_BUS.register(new RenderMovementBlocking());
    MinecraftForge.EVENT_BUS.register(new MOPHelper());
}
 

public void init()
{
    if(config.getTag("checkUpdates").getBooleanValue(true))
        CCUpdateChecker.updateCheck("Translocator");
    ClientUtils.enhanceSupportersList("Translocator");
    
    super.init();


    ClientRegistry.bindTileEntitySpecialRenderer(TileItemTranslocator.class, new TileTranslocatorRenderer());
    ClientRegistry.bindTileEntitySpecialRenderer(TileLiquidTranslocator.class, new TileTranslocatorRenderer());
    ClientRegistry.bindTileEntitySpecialRenderer(TileCraftingGrid.class, new TileCraftingGridRenderer());
    
    PacketCustom.assignHandler(TranslocatorCPH.channel, new TranslocatorCPH());
    
    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(blockTranslocator), new ItemTranslocatorRenderer());

    FMLCommonHandler.instance().bus().register(CraftingGridKeyHandler.instance);
    ClientRegistry.registerKeyBinding(CraftingGridKeyHandler.instance);
}
 

@Override
public void init()
{
	super.init();

	FMLCommonHandler.instance().bus().register(new MultiblockClientTickHandler());
       FMLCommonHandler.instance().bus().register(new BRRenderTickHandler());

	BlockFuelRod.renderId = RenderingRegistry.getNextAvailableRenderId();
	ISimpleBlockRenderingHandler fuelRodISBRH = new SimpleRendererFuelRod();
	RenderingRegistry.registerBlockHandler(BlockFuelRod.renderId, fuelRodISBRH);
	
	BlockTurbineRotorPart.renderId = RenderingRegistry.getNextAvailableRenderId();
	ISimpleBlockRenderingHandler rotorISBRH = new RotorSimpleRenderer();
	RenderingRegistry.registerBlockHandler(BlockTurbineRotorPart.renderId, rotorISBRH);	
	
	if(BigReactors.blockTurbinePart != null) {
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityTurbineRotorBearing.class, new RotorSpecialRenderer());
	}
}
 

@Override
public void registerRenderers()
{
	RenderingRegistry.registerEntityRenderingHandler(EntityShip.class, new RenderShip());
	RenderingRegistry.registerEntityRenderingHandler(EntityParachute.class, new RenderParachute());
	ClientRegistry.bindTileEntitySpecialRenderer(TileEntityGauge.class, new TileEntityGaugeRenderer());
	ClientRegistry.bindTileEntitySpecialRenderer( TileEntityHelm.class, new TileEntityModelHelmRenderer() );
	ClientRegistry.bindTileEntitySpecialRenderer( TileEntityEngine.class, new TileEntityModelEngineRenderer() );
	MinecraftForgeClient.registerItemRenderer( Item.getItemFromBlock( ArchimedesShipMod.blockMarkShip ), new ItemModelHelmRenderer( new TileEntityModelHelmRenderer(), new TileEntityHelm() ) );
	MinecraftForgeClient.registerItemRenderer( Item.getItemFromBlock( ArchimedesShipMod.blockEngine ), new ItemModelEngineRenderer( new TileEntityModelEngineRenderer(), new TileEntityEngine() ) );
	//ClientRegistry.bindTileEntitySpecialRenderer(TileEntityHelm.class, new TileEntityHelmRenderer());
	BlockGauge.gaugeBlockRenderID = RenderingRegistry.getNextAvailableRenderId();
	BlockSeat.seatBlockRenderID = RenderingRegistry.getNextAvailableRenderId();
	RenderingRegistry.registerBlockHandler(BlockSeat.seatBlockRenderID, new RenderBlockSeat());
	RenderingRegistry.registerBlockHandler(BlockGauge.gaugeBlockRenderID, new RenderBlockGauge());
}
 

@Override
public void preInit(FMLPreInitializationEvent evt) {
	super.preInit(evt);
	MinecraftForge.EVENT_BUS.register(RenderUtility.instance);
	ClientRegistry.bindTileEntitySpecialRenderer(FWTile.class, FWTileRenderer.instance);
	RenderingRegistry.registerEntityRenderingHandler(FWEntity.class, FWEntityRenderer.instance);
	RenderUtility.instance.preInit(evt);
}
 

@Override
public void registerRenderInfo()
{
    BlockBabyChest.pRenderID = RenderingRegistry.getNextAvailableRenderId();
    TileEntitySpecialRenderer render = new RenderBabyChest();

    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(MainRegistry._mBlockBabyChest), new RenderItemBabyChest());
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityBabyChest.class, render);

    MinecraftForge.EVENT_BUS.register(CONFIG_HANDLER);
}
 

@Override
public void init()
{
    if(config.getTag("checkUpdates").getBooleanValue(true))
        CCUpdateChecker.updateCheck("ChickenChunks");
    ClientUtils.enhanceSupportersList("ChickenChunks");
    
    super.init();

    PacketCustom.assignHandler(ChunkLoaderCPH.channel, new ChunkLoaderCPH());
    
    ClientRegistry.bindTileEntitySpecialRenderer(TileChunkLoader.class, new TileChunkLoaderRenderer());
    ClientRegistry.bindTileEntitySpecialRenderer(TileSpotLoader.class, new TileChunkLoaderRenderer());
    RenderingRegistry.registerBlockHandler(new ChunkLoaderSBRH());
}
 

public void RegisterRenderers()
{
	try
	{
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySolderingStation.class, new TileEntityRendererSolderingStation());
		MinecraftForgeClient.registerItemRenderer(BlockEnum.SOLDERINGSTATION.getBlockInstance().blockID, new ItemRendererSolderingStation());

		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityBusFluidStorage.class, new TileEntityRendererBusFluidStorage());
		MinecraftForgeClient.registerItemRenderer(BlockEnum.FLUIDSTORAGE.getBlockInstance().blockID, new ItemRendererBusFluidStorage());

		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityBusFluidImport.class, new TileEntityRendererBusFluidImport());
		MinecraftForgeClient.registerItemRenderer(BlockEnum.FLUIDIMPORT.getBlockInstance().blockID, new ItemRendererBusFluidImport());

		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityBusFluidExport.class, new TileEntityRendererBusFluidExport());
		MinecraftForgeClient.registerItemRenderer(BlockEnum.FLUIDEXPORT.getBlockInstance().blockID, new ItemRendererBusFluidExport());
		
		MinecraftForgeClient.registerItemRenderer(BlockEnum.CERTUSTANK.getBlockInstance().blockID, new ItemRendererCertusTank());

		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityWalrus.class, new TileEntityRedererWalrus());
		MinecraftForgeClient.registerItemRenderer(BlockEnum.CHROMIA.getBlockInstance().blockID, new ItemRendererWalrus());

		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityLevelEmitterFluid.class, new TileEntityRendererLevelEmitterFluid());
		MinecraftForgeClient.registerItemRenderer(BlockEnum.FLUIDLEVELEMITTER.getBlockInstance().blockID, new ItemRendererLevelEmitterFluid());

		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityMonitorStorageFluid.class, new TileEntityRendererMonitorStorageFluid());
	} catch (NullPointerException e)
	{
		System.out.println("Mod ExtraCells: Another mod probably overrid an ExtraCells item causing EC to cancel the registration of ItemRenderers!");
	}
}
 

@Override
public void init() {
	RenderingRegistry.registerBlockHandler(new RendererCTM());
	RenderingRegistry.registerBlockHandler(new RendererStairs());
	RenderingRegistry.registerBlockHandler(new RendererCTMPane());
	RenderingRegistry.registerBlockHandler(new RendererRoadLine());
	RenderingRegistry.registerBlockHandler(new RendererSnakeStone());
	RenderingRegistry.registerBlockHandler(new RendererEldritch());
	RenderingRegistry.registerBlockHandler(new RendererLayeredGlow());
	RenderingRegistry.registerBlockHandler(new RendererSimpleLayered());
	
	RenderingRegistry.registerBlockHandler(new RendererMultiLayer());

	RenderAutoChisel rac = new RenderAutoChisel();
	RenderingRegistry.registerBlockHandler(rac);
	MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(ChiselBlocks.autoChisel), rac);
	ClientRegistry.bindTileEntitySpecialRenderer(TileEntityAutoChisel.class, rac);
	
	RenderCarvableBeacon rcb = new RenderCarvableBeacon();
	ClientRegistry.bindTileEntitySpecialRenderer(TileEntityCarvableBeacon.class, rcb);
	RenderingRegistry.registerBlockHandler(rcb);
	BlockCarvableBeacon.renderId = rcb.getRenderId();
	
	RenderPresent rp = new RenderPresent();
	MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(ChiselBlocks.present), rp);
	ClientRegistry.bindTileEntitySpecialRenderer(TileEntityPresent.class, rp);

	RenderingRegistry.registerEntityRenderingHandler(EntityCloudInABottle.class, new RenderSnowball(ChiselItems.cloudinabottle));
	RenderingRegistry.registerEntityRenderingHandler(EntityBallOMoss.class, new RenderSnowball(ChiselItems.ballomoss));
	RenderingRegistry.registerEntityRenderingHandler(EntitySmashingRock.class, new RenderSnowball(ChiselItems.smashingrock));
       RenderingRegistry.registerEntityRenderingHandler(EntityChiselSnowman.class, new RenderChiselSnowman());

	MinecraftForgeClient.registerItemRenderer(ChiselItems.chisel, renderer);
	MinecraftForgeClient.registerItemRenderer(ChiselItems.diamondChisel, renderer);

	PlayerSpecials.init();
}
 

public MwKeyHandler(){
       ClientRegistry.registerKeyBinding(keyMapGui);
       ClientRegistry.registerKeyBinding(keyNewMarker);
       ClientRegistry.registerKeyBinding(keyMapMode);
       ClientRegistry.registerKeyBinding(keyNextGroup);
       ClientRegistry.registerKeyBinding(keyTeleport);
       ClientRegistry.registerKeyBinding(keyZoomIn);
       ClientRegistry.registerKeyBinding(keyZoomOut);
       ClientRegistry.registerKeyBinding(keyUndergroundMode);
}
 

@Override
public void registerRenderInformation() {
	OpenPeripheralAddons.renderId = RenderingRegistry.getNextAvailableRenderId();
	final BlockRenderingHandler blockRenderingHandler = new BlockRenderingHandler(OpenPeripheralAddons.renderId);
	RenderingRegistry.registerBlockHandler(blockRenderingHandler);

	blockRenderingHandler.addRenderer(Blocks.pim, new BlockPIMRenderer());

	ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySensor.class, new TileEntitySensorRenderer());
	ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySelector.class, new TileEntitySelectorRenderer());
}
 

@Override
	public void registerRenders() {
		
		int r = RenderingRegistry.getNextAvailableRenderId();
		ISimpleBlockRenderingHandler handler = new RenderFakeBlock(r);
		RenderingRegistry.registerBlockHandler(handler);
		((BlockIllusionary)BlockIllusionary.instance).renderType = r;
//		GameRegistry.registerTileEntity(TileEntitySpikes.class, "artifacts.spiketrap");
		
		r = RenderingRegistry.getNextAvailableRenderId();
		handler = new RenderArrowTrap(r);
		RenderingRegistry.registerBlockHandler(handler);
		((BlockTrap)BlockTrap.instance).renderType = r;
//		GameRegistry.registerTileEntity(TileEntityTrap.class, "artifacts.arrowtrap");

//		r = RenderingRegistry.getNextAvailableRenderId();
//		handler = new RenderQuickSand(r);
//		RenderingRegistry.registerBlockHandler(handler);
//		((BlockQuickSand)BlockQuickSand.instance).renderType = r;
		
		r = RenderingRegistry.getNextAvailableRenderId();
		handler = new RenderCoverPlate(r);
		RenderingRegistry.registerBlockHandler(handler);
		((BlockCoverPlate)BlockCoverPlate.instance).renderType = r;
        RenderingRegistry.registerEntityRenderingHandler(EntityClayGolem.class, new RenderClayGolem());
        
		TileEntitySpecialRenderer render = new TESwordRenderer();
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySword.class, render);
        MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(BlockSword.instance), new ItemRenderPedestal(render, new TileEntitySword()));
		
        render = new PedestalRenderer();
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityDisplayPedestal.class, render);
        MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(BlockPedestal.instance), new ItemRenderPedestal(render, new TileEntityDisplayPedestal()));
        
        render = new SpikesRenderer();
        ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySpikes.class, render);
        MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(BlockSpikes.instance), new ItemRenderPedestal(render, new TileEntitySpikes()));
        
        r = RenderingRegistry.getNextAvailableRenderId();
        handler = new RenderLaserBeam(r);
		RenderingRegistry.registerBlockHandler(handler);
		((BlockLaserBeam)BlockLaserBeam.instance).renderID = r;

        r = RenderingRegistry.getNextAvailableRenderId();
        handler = new RenderLaserSource(r);
		RenderingRegistry.registerBlockHandler(handler);
		((BlockLaserBeamSource)BlockLaserBeamSource.instance).renderID = r;
		
		if(Loader.isModLoaded("antiqueatlas")) {
//			AtlasAPI.getTileAPI().setTexture("wizardtower", new ResourceLocation("artifacts:textures/gui/tower.png"));
		}
	}
 

private KeyBinding registerKeyBinding(KeyBinding keyBinding){
    ClientRegistry.registerKeyBinding(keyBinding);
    keys.add(keyBinding);
    return keyBinding;
}
 

private static void registerBaseModelRenderer(Item item, Class<? extends TileEntity> tileEntityClass, IBaseModel model){
    RenderModelBase renderer = new RenderModelBase(model);
    ClientRegistry.bindTileEntitySpecialRenderer(tileEntityClass, renderer);
    MinecraftForgeClient.registerItemRenderer(item, renderer);
}
 

@Override
public void registerRenders(){
    SPECIAL_RENDER_TYPE_VALUE = RenderingRegistry.getNextAvailableRenderId();
    blockRenderers.add(new RenderElevatorFrame());
    blockRenderers.add(new RenderChargingStationPad());

    for(ISBRHPneumatic renderer : blockRenderers) {
        RenderingRegistry.registerBlockHandler(renderer);
    }

    RenderingRegistry.registerBlockHandler(new RenderModelBase());
    // RenderingRegistry.registerBlockHandler(new RendererSpecialBlock());
    registerBaseModelRenderer(Blockss.airCompressor, TileEntityAirCompressor.class, new ModelAirCompressor("airCompressor"));
    registerBaseModelRenderer(Blockss.advancedAirCompressor, TileEntityAdvancedAirCompressor.class, new ModelAirCompressor("advancedAirCompressor"));
    registerBaseModelRenderer(Blockss.assemblyController, TileEntityAssemblyController.class, new ModelAssemblyController());
    registerBaseModelRenderer(Blockss.assemblyDrill, TileEntityAssemblyDrill.class, new ModelAssemblyDrill());
    registerBaseModelRenderer(Blockss.assemblyIOUnit, TileEntityAssemblyIOUnit.class, new ModelAssemblyIOUnit());
    registerBaseModelRenderer(Blockss.assemblyLaser, TileEntityAssemblyLaser.class, new ModelAssemblyLaser());
    registerBaseModelRenderer(Blockss.assemblyPlatform, TileEntityAssemblyPlatform.class, new ModelAssemblyPlatform());
    registerBaseModelRenderer(Blockss.chargingStation, TileEntityChargingStation.class, new ModelChargingStation());
    registerBaseModelRenderer(Blockss.creativeCompressor, TileEntityCreativeCompressor.class, new BaseModel("creativeCompressor.obj"));
    registerBaseModelRenderer(Blockss.electrostaticCompressor, TileEntityElectrostaticCompressor.class, new BaseModel("electrostaticCompressor.obj"));
    registerBaseModelRenderer(Blockss.elevatorBase, TileEntityElevatorBase.class, new ModelElevatorBase());
    registerBaseModelRenderer(Blockss.pneumaticDoor, TileEntityPneumaticDoor.class, new ModelPneumaticDoor());
    registerBaseModelRenderer(Blockss.pneumaticDoorBase, TileEntityPneumaticDoorBase.class, new ModelPneumaticDoorBase());
    registerBaseModelRenderer(Blockss.pressureChamberInterface, TileEntityPressureChamberInterface.class, new ModelPressureChamberInterface());
    registerBaseModelRenderer(Blockss.securityStation, TileEntitySecurityStation.class, new ModelComputer(Textures.MODEL_SECURITY_STATION));
    registerBaseModelRenderer(Blockss.universalSensor, TileEntityUniversalSensor.class, new ModelUniversalSensor());
    registerBaseModelRenderer(Blockss.uvLightBox, TileEntityUVLightBox.class, new ModelUVLightBox());
    registerBaseModelRenderer(Blockss.vacuumPump, TileEntityVacuumPump.class, new ModelVacuumPump());
    registerBaseModelRenderer(Blockss.omnidirectionalHopper, TileEntityOmnidirectionalHopper.class, new ModelOmnidirectionalHopper(Textures.MODEL_OMNIDIRECTIONAL_HOPPER));
    registerBaseModelRenderer(Blockss.liquidHopper, TileEntityLiquidHopper.class, new ModelLiquidHopper());
    registerBaseModelRenderer(Blockss.programmer, TileEntityProgrammer.class, new ModelComputer(Textures.MODEL_PROGRAMMER));
    registerBaseModelRenderer(Blockss.plasticMixer, TileEntityPlasticMixer.class, new ModelPlasticMixer());
    registerBaseModelRenderer(Blockss.liquidCompressor, TileEntityLiquidCompressor.class, new BaseModel("liquidCompressor.obj"));
    registerBaseModelRenderer(Blockss.advancedLiquidCompressor, TileEntityAdvancedLiquidCompressor.class, new BaseModel("liquidCompressor.obj", "advancedLiquidCompressor.png"));
    registerBaseModelRenderer(Blockss.heatSink, TileEntityHeatSink.class, new ModelHeatSink());
    registerBaseModelRenderer(Blockss.vortexTube, TileEntityVortexTube.class, new ModelVortexTube());
    registerBaseModelRenderer(Blockss.thermopneumaticProcessingPlant, TileEntityThermopneumaticProcessingPlant.class, new ModelThermopneumaticProcessingPlant());
    registerBaseModelRenderer(Blockss.refinery, TileEntityRefinery.class, new ModelRefinery());
    registerBaseModelRenderer(Blockss.gasLift, TileEntityGasLift.class, new ModelGasLift());
    registerBaseModelRenderer(Blockss.keroseneLamp, TileEntityKeroseneLamp.class, new ModelKeroseneLamp());
    registerBaseModelRenderer(Blockss.sentryTurret, TileEntitySentryTurret.class, new ModelSentryTurret());

    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityPressureTube.class, new RenderPressureTube());
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityAirCannon.class, new RenderAirCannon());
    // ClientRegistry.bindTileEntitySpecialRenderer(TileEntityElevatorBase.class, new RenderElevatorBase());
    // ClientRegistry.bindTileEntitySpecialRenderer(TileEntityAdvancedPressureTube.class, new RenderAdvancedPressureTube());
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityAphorismTile.class, new RenderAphorismTile());
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityElevatorCaller.class, new RenderElevatorCaller());
    // ClientRegistry.bindTileEntitySpecialRenderer(TileEntityProgrammableController.class, new RenderProgrammableController());
    // ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySentryTurret.class, new RenderSentryTurret());

    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(Blockss.pressureTube), new RenderItemPressureTube(false));
    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(Blockss.advancedPressureTube), new RenderItemPressureTube(true));

    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(Blockss.airCannon), new RenderModelBase(new ModelAirCannon()));
    MinecraftForgeClient.registerItemRenderer(Itemss.vortexCannon, new RenderItemVortexCannon());
    // MinecraftForgeClient.registerItemRenderer(Blocks.elevatorBase, new RenderItemElevatorBase());
    MinecraftForgeClient.registerItemRenderer(Itemss.cannonBarrel, new RenderItemCannonParts(false));
    MinecraftForgeClient.registerItemRenderer(Itemss.stoneBase, new RenderItemCannonParts(true));
    MinecraftForgeClient.registerItemRenderer(Itemss.pneumaticCylinder, new RenderItemPneumaticCilinder());
    //   MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(Blockss.advancedPressureTube), new RenderItemAdvancedPressureTube());
    MinecraftForgeClient.registerItemRenderer(Itemss.drone, new RenderItemDrone(false));
    MinecraftForgeClient.registerItemRenderer(Itemss.logisticsDrone, new RenderItemDrone(true));
    MinecraftForgeClient.registerItemRenderer(Itemss.programmingPuzzle, new RenderItemProgrammingPuzzle());
    MinecraftForgeClient.registerItemRenderer(Itemss.minigun, new RenderItemMinigun());
    if(Config.useHelmetModel) MinecraftForgeClient.registerItemRenderer(Itemss.pneumaticHelmet, new RenderItemPneumaticHelmet());

    RenderingRegistry.registerEntityRenderingHandler(EntityVortex.class, new RenderEntityVortex());
    RenderingRegistry.registerEntityRenderingHandler(EntityChopperSeeds.class, new RenderEntityChopperSeeds());
    RenderingRegistry.registerEntityRenderingHandler(EntityPotionCloud.class, new RenderEntityPotionCloud());
    RenderingRegistry.registerEntityRenderingHandler(EntityDrone.class, new RenderDrone(false));
    RenderingRegistry.registerEntityRenderingHandler(EntityLogisticsDrone.class, new RenderDrone(true));
    RenderingRegistry.registerEntityRenderingHandler(EntityProgrammableController.class, new RenderDrone(false));

    RenderingRegistry.registerEntityRenderingHandler(EntityRing.class, new RenderEntityRing());
    EntityRegistry.registerModEntity(EntityRing.class, "Ring", 100, PneumaticCraft.instance, 80, 1, true);

    registerModuleRenderers();
    super.registerRenders();
}
 

@Override
public void registerRenderInfo() {
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityWrathCage.class, new TileEntityWrathCageRenderer());
    VillagerRegistry.instance().registerVillagerSkin(Config.hereticID, new ResourceLocation("forbidden", "textures/models/heretic.png"));
}
 

@Override
public void registerKeyBindings()
{
    ClientRegistry.registerKeyBinding(Keybindings.charge);
    ClientRegistry.registerKeyBinding(Keybindings.release);
}
 

public SJKeyBinding(String name, int keyId, ModKey keyType) {
    super(SimplyJetpacks.PREFIX + "keybind." + name, keyId, "Simply Jetpacks");
    this.keyType = keyType;
    ClientRegistry.registerKeyBinding(this);
    KeyHandler.keyBindings.add(this);
}
 

private void registerKeybinds(){
    FMLCommonHandler.instance().bus().register(new KeyInputHandler());
    for(Keybindings key : Keybindings.values()) {
        ClientRegistry.registerKeyBinding(key.getKeybind());
    }
}
 

@Override
public void initalize() {
    super.initalize();

    injectGolemTextures();

    //Tiles
    ClientRegistry.bindTileEntitySpecialRenderer(TileStickyJar.class, new RenderTileStickyJar());

    RenderTileRemoteJar renderTileRemoteJar = new RenderTileRemoteJar();
    ClientRegistry.bindTileEntitySpecialRenderer(TileRemoteJar.class, renderTileRemoteJar);

    RenderTileArcaneDropper renderTileArcaneDropper = new RenderTileArcaneDropper();
    ClientRegistry.bindTileEntitySpecialRenderer(TileArcaneDropper.class, renderTileArcaneDropper);

    RenderTileInfusionClaw renderTileInfusionClaw = new RenderTileInfusionClaw();
    ClientRegistry.bindTileEntitySpecialRenderer(TileInfusionClaw.class, renderTileInfusionClaw);

    RenderTileExtendedNode nodeRenderer = new RenderTileExtendedNode();
    ClientRegistry.bindTileEntitySpecialRenderer(TileExtendedNode.class, nodeRenderer);

    RenderTileExtendedNodeJar nodeJarRenderer = new RenderTileExtendedNodeJar();
    ClientRegistry.bindTileEntitySpecialRenderer(TileExtendedNodeJar.class, nodeJarRenderer);

    ClientRegistry.bindTileEntitySpecialRenderer(TileNodeManipulator.class, new RenderTileNodeManipulator());

    ClientRegistry.bindTileEntitySpecialRenderer(TileManipulatorPillar.class, new RenderTileManipulatorPillar());
    RenderTileManipulationFocus renderTileManipulationFocus = new RenderTileManipulationFocus();
    ClientRegistry.bindTileEntitySpecialRenderer(TileManipulationFocus.class, renderTileManipulationFocus);

    ClientRegistry.bindTileEntitySpecialRenderer(TileAdditionalEldritchPortal.class, new TileEldritchPortalRenderer());

    ClientRegistry.bindTileEntitySpecialRenderer(TileEldritchObelisk.class, new RenderTileObelisk());
    ClientRegistry.bindTileEntitySpecialRenderer(TileEldritchAltar.class, new RenderTileCapEldritch("textures/models/obelisk_cap_altar.png"));
    ClientRegistry.bindTileEntitySpecialRenderer(TileEldritchCap.class, new RenderTileCapEldritch("textures/models/obelisk_cap.png"));
    RenderTileEssentiaCompressor renderTileEssentiaCompressor = new RenderTileEssentiaCompressor();
    ClientRegistry.bindTileEntitySpecialRenderer(TileEssentiaCompressor.class, renderTileEssentiaCompressor);

    //ClientRegistry.bindTileEntitySpecialRenderer(TileAIShutdown.class, new RenderTileAIShutdown());

    RenderTileAuraPylon renderTileAuraPylon = new RenderTileAuraPylon();
    ClientRegistry.bindTileEntitySpecialRenderer(TileAuraPylon.class, renderTileAuraPylon);
    ClientRegistry.bindTileEntitySpecialRenderer(TileAuraPylonTop.class, renderTileAuraPylon);

    RenderTileBlockProtector renderTileBlockProtector = new RenderTileBlockProtector();
    ClientRegistry.bindTileEntitySpecialRenderer(TileBlockProtector.class, renderTileBlockProtector);

    RenderTileArcanePackager renderTileArcanePackager = new RenderTileArcanePackager();
    ClientRegistry.bindTileEntitySpecialRenderer(TileArcanePackager.class, renderTileArcanePackager);

    RenderTileKnowledgeBook bookRender = new RenderTileKnowledgeBook();
    ClientRegistry.bindTileEntitySpecialRenderer(TileKnowledgeBook.class, bookRender);

    //Items
    TileArcaneDropper fakeTile = new TileArcaneDropper();
    fakeTile.blockMetadata = 8 | ForgeDirection.SOUTH.ordinal();
    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(RegisteredBlocks.blockArcaneDropper), new ItemRenderTileEntity<TileArcaneDropper>(renderTileArcaneDropper, fakeTile));

    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(RegisteredBlocks.blockInfusionClaw), new ItemRenderTileEntity<TileInfusionClaw>(renderTileInfusionClaw, new TileInfusionClaw()));

    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(RegisteredBlocks.blockEssentiaCompressor), new ItemRenderTileEntity<TileEssentiaCompressor>(renderTileEssentiaCompressor, new TileEssentiaCompressor()));

    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(ConfigBlocks.blockAiry), new ItemExNodeRenderer());

    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(RegisteredBlocks.blockKnowledgeBook), new ItemRenderTEKnowledgeBook(bookRender));

    ItemRenderTileEntityMulti multi = new ItemRenderTileEntityMulti(new ItemRenderTileEntityMulti.RenderSet(renderTileAuraPylon, new TileAuraPylon(), 0),
           new ItemRenderTileEntityMulti.RenderSet(renderTileAuraPylon, new TileAuraPylonTop(), 1));
    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(RegisteredBlocks.blockAuraPylon), multi);

    MinecraftForgeClient.registerItemRenderer(RegisteredItems.itemExtendedNodeJar, new ItemJarExtendedNodeRenderer());
    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(RegisteredBlocks.blockRemoteJar), new ItemRenderRemoteJar(renderTileRemoteJar));

    ItemRenderStoneMachine itemRenderStoneMachine = new ItemRenderStoneMachine();
    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(RegisteredBlocks.blockStoneMachine), itemRenderStoneMachine);
    itemRenderStoneMachine.registerRenderer(0, new TileManipulationFocus(), renderTileManipulationFocus);
    TileManipulationFocus tileManipulationFocus = new TileManipulationFocus();
    tileManipulationFocus.blockMetadata = 3;
    itemRenderStoneMachine.registerRenderer(3, tileManipulationFocus, renderTileManipulationFocus);
    TileBlockProtector tileBlockProtector = new TileBlockProtector();
    tileBlockProtector.facing = 3;
    itemRenderStoneMachine.registerRenderer(2, tileBlockProtector, renderTileBlockProtector);
    itemRenderStoneMachine.registerRenderer(4, new TileArcanePackager(), renderTileArcanePackager);

    MinecraftForgeClient.registerItemRenderer(RegisteredItems.itemEtherealFamiliar, new ItemRenderFamiliar());
    MinecraftForgeClient.registerItemRenderer(RegisteredItems.itemCreativeNode, new ItemCreativeNodeRenderer());

    //Entities
    RenderingRegistry.registerEntityRenderingHandler(EntityPermNoClipItem.class, new RenderSpecialItem());
    RenderingRegistry.registerEntityRenderingHandler(EntityAuraCore.class, new RenderEntityAuraCore());

    //Blocks
    RegisteredBlocks.rendererTransparentBlock = registerBlockRenderer(new RenderBlockTransparent());
    RegisteredBlocks.rendererExtendedNodeJarBlock = registerBlockRenderer(new BlockExtendedNodeJarRenderer());
    RegisteredBlocks.rendererBlockStoneMachine = registerBlockRenderer(new RenderBlockStoneMachine());
}