001 package cpw.mods.fml.client.registry; 002 003 import java.util.List; 004 import java.util.Map; 005 006 import net.minecraft.src.Block; 007 import net.minecraft.src.Entity; 008 import net.minecraft.src.IBlockAccess; 009 import net.minecraft.src.Render; 010 import net.minecraft.src.RenderBlocks; 011 import net.minecraft.src.RenderManager; 012 import net.minecraft.src.RenderPlayer; 013 014 import com.google.common.collect.Lists; 015 import com.google.common.collect.Maps; 016 import com.google.common.collect.ObjectArrays; 017 018 import cpw.mods.fml.client.SpriteHelper; 019 import cpw.mods.fml.client.TextureFXManager; 020 021 /** 022 * @author cpw 023 * 024 */ 025 public class RenderingRegistry 026 { 027 private static final RenderingRegistry INSTANCE = new RenderingRegistry(); 028 029 private int nextRenderId = 32; 030 031 private Map<Integer, ISimpleBlockRenderingHandler> blockRenderers = Maps.newHashMap(); 032 033 private List<EntityRendererInfo> entityRenderers = Lists.newArrayList(); 034 035 /** 036 * Add a new armour prefix to the RenderPlayer 037 * 038 * @param armor 039 * @return 040 */ 041 public static int addNewArmourRendererPrefix(String armor) 042 { 043 RenderPlayer.armorFilenamePrefix = ObjectArrays.concat(RenderPlayer.armorFilenamePrefix, armor); 044 return RenderPlayer.armorFilenamePrefix.length - 1; 045 } 046 047 /** 048 * Register an entity rendering handler. This will, after mod initialization, be inserted into the main 049 * render map for entities 050 * 051 * @param entityClass 052 * @param renderer 053 */ 054 public static void registerEntityRenderingHandler(Class<? extends Entity> entityClass, Render renderer) 055 { 056 instance().entityRenderers.add(new EntityRendererInfo(entityClass, renderer)); 057 } 058 059 /** 060 * Register a simple block rendering handler 061 * 062 * @param handler 063 */ 064 public static void registerBlockHandler(ISimpleBlockRenderingHandler handler) 065 { 066 instance().blockRenderers.put(handler.getRenderId(), handler); 067 } 068 069 /** 070 * Register the simple block rendering handler 071 * This version will not call getRenderId on the passed in handler, instead using the supplied ID, so you 072 * can easily re-use the same rendering handler for multiple IDs 073 * 074 * @param renderId 075 * @param handler 076 */ 077 public static void registerBlockHandler(int renderId, ISimpleBlockRenderingHandler handler) 078 { 079 instance().blockRenderers.put(renderId, handler); 080 } 081 /** 082 * Get the next available renderId from the block render ID list 083 * 084 * @return 085 */ 086 public static int getNextAvailableRenderId() 087 { 088 return instance().nextRenderId++; 089 } 090 091 /** 092 * Add a texture override for the given path and return the used index 093 * 094 * @param fileToOverride 095 * @param fileToAdd 096 * @return 097 */ 098 public static int addTextureOverride(String fileToOverride, String fileToAdd) 099 { 100 int idx = SpriteHelper.getUniqueSpriteIndex(fileToOverride); 101 addTextureOverride(fileToOverride, fileToAdd, idx); 102 return idx; 103 } 104 105 /** 106 * Add a texture override for the given path and index 107 * 108 * @param path 109 * @param overlayPath 110 * @param index 111 */ 112 public static void addTextureOverride(String path, String overlayPath, int index) 113 { 114 TextureFXManager.instance().addNewTextureOverride(path, overlayPath, index); 115 } 116 117 /** 118 * Get and reserve a unique texture index for the supplied path 119 * 120 * @param path 121 * @return 122 */ 123 public static int getUniqueTextureIndex(String path) 124 { 125 return SpriteHelper.getUniqueSpriteIndex(path); 126 } 127 128 @Deprecated public static RenderingRegistry instance() 129 { 130 return INSTANCE; 131 } 132 133 private static class EntityRendererInfo 134 { 135 public EntityRendererInfo(Class<? extends Entity> target, Render renderer) 136 { 137 this.target = target; 138 this.renderer = renderer; 139 } 140 private Class<? extends Entity> target; 141 private Render renderer; 142 } 143 144 /** 145 * @param renderer 146 * @param world 147 * @param x 148 * @param y 149 * @param z 150 * @param block 151 * @param modelId 152 * @return 153 */ 154 public boolean renderWorldBlock(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, Block block, int modelId) 155 { 156 if (!blockRenderers.containsKey(modelId)) { return false; } 157 ISimpleBlockRenderingHandler bri = blockRenderers.get(modelId); 158 return bri.renderWorldBlock(world, x, y, z, block, modelId, renderer); 159 } 160 161 /** 162 * @param renderer 163 * @param block 164 * @param metadata 165 * @param modelID 166 */ 167 public void renderInventoryBlock(RenderBlocks renderer, Block block, int metadata, int modelID) 168 { 169 if (!blockRenderers.containsKey(modelID)) { return; } 170 ISimpleBlockRenderingHandler bri = blockRenderers.get(modelID); 171 bri.renderInventoryBlock(block, metadata, modelID, renderer); 172 } 173 174 /** 175 * @param p_1219_0_ 176 * @return 177 */ 178 public boolean renderItemAsFull3DBlock(int modelId) 179 { 180 ISimpleBlockRenderingHandler bri = blockRenderers.get(modelId); 181 return bri != null && bri.shouldRender3DInInventory(); 182 } 183 184 public void loadEntityRenderers(Map<Class<? extends Entity>, Render> rendererMap) 185 { 186 for (EntityRendererInfo info : entityRenderers) 187 { 188 rendererMap.put(info.target, info.renderer); 189 info.renderer.setRenderManager(RenderManager.instance); 190 } 191 } 192 }