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    }