generic 1.7 item renderer prefab that only requires an itemstack and nothing else

gistfile1.txt

    // vanilla resloc is private, either get an accessor or do this frivolous crap
    public static final ResourceLocation RES_ITEM_GLINT = new ResourceLocation("textures/misc/enchanted_item_glint.png");

    //call this method to make gregorioust happy
    public void renderItem(@Nonnull ItemStack stack) {
        EntityLivingBase observer = Minecraft.getMinecraft().renderViewEntity;
        if (stack.getItem().requiresMultipleRenderPasses()) {
            for (int i = 0; i < stack.getItem().getRenderPasses(stack.getItemDamage()); ++i) {
                int rgb = stack.getItem().getColorFromItemStack(stack, i);
                float r = (float) (rgb >> 16 & 255) / 255.0F;
                float g = (float) (rgb >> 8 & 255) / 255.0F;
                float b = (float) (rgb & 255) / 255.0F;
                GL11.glColor4f(r, g, b, 1.0F);
                renderItemInternal(observer, stack, i, IItemRenderer.ItemRenderType.ENTITY);
            }
        } else {
            int rgb = stack.getItem().getColorFromItemStack(stack, 0);
            float r = (float) (rgb >> 16 & 255) / 255.0F;
            float g = (float) (rgb >> 8 & 255) / 255.0F;
            float b = (float) (rgb & 255) / 255.0F;
            GL11.glColor4f(r, g, b, 1.0F);
            renderItemInternal(observer, stack, 0, IItemRenderer.ItemRenderType.ENTITY);
        }
    }

    public void renderItemInternal(EntityLivingBase entity, ItemStack stack, int renderPass, IItemRenderer.ItemRenderType type) {
        GL11.glPushMatrix();
        TextureManager texturemanager = Minecraft.getMinecraft().getTextureManager();
        RenderBlocks blockRenderer = RenderBlocks.getInstance();
        Item item = stack.getItem();
        Block block = item instanceof ItemBlock ? ((ItemBlock) item).field_150939_a : Block.getBlockFromItem(item);
        boolean translucentBlock = block != null && block.getRenderBlockPass() != 0;

        if (translucentBlock) {
            GL11.glEnable(GL11.GL_BLEND);
            GL11.glEnable(GL11.GL_CULL_FACE);
            OpenGlHelper.glBlendFunc(770, 771, 1, 0);
        }

        IItemRenderer customRenderer = MinecraftForgeClient.getItemRenderer(stack, type);
        if (customRenderer != null) {
            texturemanager.bindTexture(texturemanager.getResourceLocation(stack.getItemSpriteNumber()));
            ForgeHooksClient.renderEquippedItem(type, customRenderer, blockRenderer, entity, stack);
        } else if (stack.getItemSpriteNumber() == 0 && item instanceof ItemBlock && RenderBlocks.renderItemIn3d(block.getRenderType())) {
            texturemanager.bindTexture(texturemanager.getResourceLocation(0));

            /* Blocks and Items start rendering at different offsets from the original point in the matrix.
               For Blocks, the effective "anchor" is in the very center of the Block, which is fairly handy in a 3d matrix.
               This also happens to be the case vertically, so they render halfway into the ground at the origin coordinates, unlike Items.
               The following transform lifts them up to make them appear in the same place as Items.
             */
            GL11.glTranslatef(0f, 0.5f, 0f);
            if (translucentBlock) {
                GL11.glDepthMask(false);
                blockRenderer.renderBlockAsItem(block, stack.getItemDamage(), 1.0F);
                GL11.glDepthMask(true);
            } else {
                blockRenderer.renderBlockAsItem(block, stack.getItemDamage(), 1.0F);
            }
        } else {
            IIcon iicon = entity.getItemIcon(stack, renderPass);

            if (iicon == null) {
                GL11.glPopMatrix();
                return;
            }

            texturemanager.bindTexture(texturemanager.getResourceLocation(stack.getItemSpriteNumber()));
            TextureUtil.func_152777_a(false, false, 1.0F);
            Tessellator tessellator = Tessellator.instance;
            float u0 = iicon.getMinU();
            float v0 = iicon.getMinV();
            float u1 = iicon.getMaxU();
            float v1 = iicon.getMaxV();
            /*Blocks and Items start rendering at different offsets from the original point in the matrix.
              Items start rendering "at" the lower left corner of their sprite, without accounting for the 3d depth.
              This transform just makes Items appear in the exact same place as Blocks.
             */
            GL11.glTranslatef(-0.5f, 0f, 0.03125f);
            GL11.glEnable(GL12.GL_RESCALE_NORMAL);
            ItemRenderer.renderItemIn2D(tessellator, u1, v0, u0, v1, iicon.getIconWidth(), iicon.getIconHeight(), 0.0625F);

            //this shit is very expensive so just remove it if you claim to care about performance
            if (stack.hasEffect(renderPass)) {
                GL11.glDepthFunc(GL11.GL_EQUAL);
                GL11.glDisable(GL11.GL_LIGHTING);
                texturemanager.bindTexture(RES_ITEM_GLINT);
                GL11.glEnable(GL11.GL_BLEND);
                OpenGlHelper.glBlendFunc(768, 1, 1, 0);
                float f7 = 0.76F;
                GL11.glColor4f(0.5F * f7, 0.25F * f7, 0.8F * f7, 1.0F);
                GL11.glMatrixMode(GL11.GL_TEXTURE);
                GL11.glPushMatrix();
                float f8 = 0.125F;
                GL11.glScalef(f8, f8, f8);
                float f9 = (float) (Minecraft.getSystemTime() % 3000L) / 3000.0F * 8.0F;
                GL11.glTranslatef(f9, 0.0F, 0.0F);
                GL11.glRotatef(-50.0F, 0.0F, 0.0F, 1.0F);
                ItemRenderer.renderItemIn2D(tessellator, 0.0F, 0.0F, 1.0F, 1.0F, 256, 256, 0.0625F);
                GL11.glPopMatrix();
                GL11.glPushMatrix();
                GL11.glScalef(f8, f8, f8);
                f9 = (float) (Minecraft.getSystemTime() % 4873L) / 4873.0F * 8.0F;
                GL11.glTranslatef(-f9, 0.0F, 0.0F);
                GL11.glRotatef(10.0F, 0.0F, 0.0F, 1.0F);
                ItemRenderer.renderItemIn2D(tessellator, 0.0F, 0.0F, 1.0F, 1.0F, 256, 256, 0.0625F);
                GL11.glPopMatrix();
                GL11.glMatrixMode(GL11.GL_MODELVIEW);
                GL11.glDisable(GL11.GL_BLEND);
                GL11.glEnable(GL11.GL_LIGHTING);
                GL11.glDepthFunc(GL11.GL_LEQUAL);
            }

            GL11.glDisable(GL12.GL_RESCALE_NORMAL);
            TextureUtil.func_147945_b();
        }

        if (translucentBlock) {
            GL11.glDisable(GL11.GL_BLEND);
        }

        GL11.glPopMatrix();
    }