java类net.minecraft.client.renderer.entity.RenderManager的实例源码

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderShulkerBullet rendershulkerbullet = new RenderShulkerBullet(rendermanager);

    if (!Reflector.RenderShulkerBullet_model.exists())
    {
        Config.warn("Field not found: RenderShulkerBullet.model");
        return null;
    }
    else
    {
        Reflector.setFieldValue(rendershulkerbullet, Reflector.RenderShulkerBullet_model, modelBase);
        rendershulkerbullet.shadowSize = shadowSize;
        return rendershulkerbullet;
    }
}

public static void entityESPBox(Entity entity, Color c) {
    GL11.glBlendFunc(770, 771);
    GL11.glEnable(GL_BLEND);
    GL11.glLineWidth(2.0F);
    GL11.glDisable(GL11.GL_TEXTURE_2D);
    GL11.glDisable(GL_DEPTH_TEST);
    GL11.glDepthMask(false);
    GL11.glColor4f(c.getRed() / 255f, c.getGreen() / 255f, c.getBlue() / 255f, c.getAlpha() / 255f);
    RenderManager renderManager = Minecraft.getMinecraft().getRenderManager();
    drawSelectionBoundingBox(new AxisAlignedBB(
            entity.boundingBox.minX - 0.05 - entity.posX + (entity.posX - renderManager.renderPosX),
            entity.boundingBox.minY - entity.posY + (entity.posY - renderManager.renderPosY),
            entity.boundingBox.minZ - 0.05 - entity.posZ + (entity.posZ - renderManager.renderPosZ),
            entity.boundingBox.maxX + 0.05 - entity.posX + (entity.posX - renderManager.renderPosX),
            entity.boundingBox.maxY + 0.1 - entity.posY + (entity.posY - renderManager.renderPosY),
            entity.boundingBox.maxZ + 0.05 - entity.posZ + (entity.posZ - renderManager.renderPosZ)));
    GL11.glEnable(GL11.GL_TEXTURE_2D);
    GL11.glEnable(GL_DEPTH_TEST);
    GL11.glDepthMask(true);
    GL11.glDisable(GL_BLEND);
}

public static void drawEntityBoxOutline(EntityLivingBase target, int color, float lineWidth, float partialTicks) {
    GL11.glPushMatrix();
    GL11.glLineWidth(lineWidth);
    double[] pos = EntityUtil.interpolate(target, partialTicks);
    double posX = pos[0] - RenderManager.field_78725_b;
    double posY = pos[1] - RenderManager.field_78726_c;
    double posZ = pos[2] - RenderManager.field_78723_d;
    AxisAlignedBB bb = AxisAlignedBB.func_72330_a(Wrapper.getEntityBoundingBox(target).field_72340_a - Wrapper.getPosX(target) + posX,
            Wrapper.getEntityBoundingBox(target).field_72338_b - Wrapper.getPosY(target) + posY,
            Wrapper.getEntityBoundingBox(target).field_72339_c - Wrapper.getPosZ(target) + posZ,
            Wrapper.getEntityBoundingBox(target).field_72336_d - Wrapper.getPosX(target) + posX,
            Wrapper.getEntityBoundingBox(target).field_72337_e - Wrapper.getPosY(target) + posY,
            Wrapper.getEntityBoundingBox(target).field_72334_f - Wrapper.getPosZ(target) + posZ);
    drawBoxOutline(bb, color, true);
    GL11.glPopMatrix();
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderMinecart renderminecart = new RenderMinecart(rendermanager);

    if (!Reflector.RenderMinecart_modelMinecart.exists())
    {
        Config.warn("Field not found: RenderMinecart.modelMinecart");
        return null;
    }
    else
    {
        Reflector.setFieldValue(renderminecart, Reflector.RenderMinecart_modelMinecart, modelBase);
        renderminecart.shadowSize = shadowSize;
        return renderminecart;
    }
}

/**
 * Renders the particle
 */
public void renderParticle(VertexBuffer worldRendererIn, Entity entityIn, float partialTicks, float rotationX, float rotationZ, float rotationYZ, float rotationXY, float rotationXZ)
{
    if (this.entity != null)
    {
        RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
        rendermanager.setRenderPosition(Particle.interpPosX, Particle.interpPosY, Particle.interpPosZ);
        float f = 0.42553192F;
        float f1 = ((float)this.particleAge + partialTicks) / (float)this.particleMaxAge;
        GlStateManager.depthMask(true);
        GlStateManager.enableBlend();
        GlStateManager.enableDepth();
        GlStateManager.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
        float f2 = 240.0F;
        OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240.0F, 240.0F);
        GlStateManager.pushMatrix();
        float f3 = 0.05F + 0.5F * MathHelper.sin(f1 * (float)Math.PI);
        GlStateManager.color(1.0F, 1.0F, 1.0F, f3);
        GlStateManager.translate(0.0F, 1.8F, 0.0F);
        GlStateManager.rotate(180.0F - entityIn.rotationYaw, 0.0F, 1.0F, 0.0F);
        GlStateManager.rotate(60.0F - 150.0F * f1 - entityIn.rotationPitch, 1.0F, 0.0F, 0.0F);
        GlStateManager.translate(0.0F, -0.4F, -1.5F);
        GlStateManager.scale(0.42553192F, 0.42553192F, 0.42553192F);
        this.entity.rotationYaw = 0.0F;
        this.entity.rotationYawHead = 0.0F;
        this.entity.prevRotationYaw = 0.0F;
        this.entity.prevRotationYawHead = 0.0F;
        rendermanager.doRenderEntity(this.entity, 0.0D, 0.0D, 0.0D, 0.0F, partialTicks, false);
        GlStateManager.popMatrix();
        GlStateManager.enableDepth();
    }
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderTntMinecart rendertntminecart = new RenderTntMinecart(rendermanager);

    if (!Reflector.RenderMinecart_modelMinecart.exists())
    {
        Config.warn("Field not found: RenderMinecart.modelMinecart");
        return null;
    }
    else
    {
        Reflector.setFieldValue(rendertntminecart, Reflector.RenderMinecart_modelMinecart, modelBase);
        rendertntminecart.shadowSize = shadowSize;
        return rendertntminecart;
    }
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderWitherSkull renderwitherskull = new RenderWitherSkull(rendermanager);

    if (!Reflector.RenderWitherSkull_model.exists())
    {
        Config.warn("Field not found: RenderWitherSkull_model");
        return null;
    }
    else
    {
        Reflector.setFieldValue(renderwitherskull, Reflector.RenderWitherSkull_model, modelBase);
        renderwitherskull.shadowSize = shadowSize;
        return renderwitherskull;
    }
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderWolf renderwolf = new RenderWolf(rendermanager);
    renderwolf.mainModel = modelBase;
    renderwolf.shadowSize = shadowSize;
    return renderwolf;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderDragon renderdragon = new RenderDragon(rendermanager);
    renderdragon.mainModel = modelBase;
    renderdragon.shadowSize = shadowSize;
    return renderdragon;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderVex rendervex = new RenderVex(rendermanager);
    rendervex.mainModel = modelBase;
    rendervex.shadowSize = shadowSize;
    return rendervex;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderAbstractHorse renderabstracthorse = new RenderAbstractHorse(rendermanager);
    renderabstracthorse.mainModel = modelBase;
    renderabstracthorse.shadowSize = shadowSize;
    return renderabstracthorse;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderZombie renderzombie = new RenderZombie(rendermanager);
    renderzombie.mainModel = modelBase;
    renderzombie.shadowSize = shadowSize;
    return renderzombie;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderEvoker renderevoker = new RenderEvoker(rendermanager);
    renderevoker.mainModel = modelBase;
    renderevoker.shadowSize = shadowSize;
    return renderevoker;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderSheep rendersheep = new RenderSheep(rendermanager);
    rendersheep.mainModel = modelBase;
    rendersheep.shadowSize = shadowSize;
    return rendersheep;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderGhast renderghast = new RenderGhast(rendermanager);
    renderghast.mainModel = modelBase;
    renderghast.shadowSize = shadowSize;
    return renderghast;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderVillager rendervillager = new RenderVillager(rendermanager);
    rendervillager.mainModel = modelBase;
    rendervillager.shadowSize = shadowSize;
    return rendervillager;
}

public static void renderDebugText(String str, double x, double y, double z, float partialTicks, int color)
{
    Minecraft minecraft = Minecraft.getMinecraft();

    if (minecraft.thePlayer != null && minecraft.getRenderManager() != null && minecraft.getRenderManager().options != null)
    {
        FontRenderer fontrenderer = minecraft.fontRendererObj;
        EntityPlayer entityplayer = minecraft.thePlayer;
        double d0 = entityplayer.lastTickPosX + (entityplayer.posX - entityplayer.lastTickPosX) * (double)partialTicks;
        double d1 = entityplayer.lastTickPosY + (entityplayer.posY - entityplayer.lastTickPosY) * (double)partialTicks;
        double d2 = entityplayer.lastTickPosZ + (entityplayer.posZ - entityplayer.lastTickPosZ) * (double)partialTicks;
        GlStateManager.pushMatrix();
        GlStateManager.translate((float)(x - d0), (float)(y - d1) + 0.07F, (float)(z - d2));
        GlStateManager.glNormal3f(0.0F, 1.0F, 0.0F);
        GlStateManager.scale(0.02F, -0.02F, 0.02F);
        RenderManager rendermanager = minecraft.getRenderManager();
        GlStateManager.rotate(-rendermanager.playerViewY, 0.0F, 1.0F, 0.0F);
        GlStateManager.rotate((float)(rendermanager.options.thirdPersonView == 2 ? 1 : -1) * rendermanager.playerViewX, 1.0F, 0.0F, 0.0F);
        GlStateManager.disableLighting();
        GlStateManager.enableTexture2D();
        GlStateManager.enableDepth();
        GlStateManager.depthMask(true);
        GlStateManager.scale(-1.0F, 1.0F, 1.0F);
        fontrenderer.drawString(str, -fontrenderer.getStringWidth(str) / 2, 0, color);
        GlStateManager.enableLighting();
        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
        GlStateManager.popMatrix();
    }
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderSkeleton renderskeleton = new RenderSkeleton(rendermanager);
    renderskeleton.mainModel = modelBase;
    renderskeleton.shadowSize = shadowSize;
    return renderskeleton;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    Render render = (Render)rendermanager.getEntityRenderMap().get(EntitySheep.class);

    if (!(render instanceof RenderSheep))
    {
        Config.warn("Not a RenderSheep: " + render);
        return null;
    }
    else
    {
        if (render.getEntityClass() == null)
        {
            RenderSheep rendersheep = new RenderSheep(rendermanager);
            rendersheep.mainModel = new ModelSheep2();
            rendersheep.shadowSize = 0.7F;
            render = rendersheep;
        }

        RenderSheep rendersheep1 = (RenderSheep)render;
        List<LayerRenderer<EntitySheep>> list = rendersheep1.getLayerRenderers();
        Iterator iterator = list.iterator();

        while (iterator.hasNext())
        {
            LayerRenderer layerrenderer = (LayerRenderer)iterator.next();

            if (layerrenderer instanceof LayerSheepWool)
            {
                iterator.remove();
            }
        }

        LayerSheepWool layersheepwool = new LayerSheepWool(rendersheep1);
        layersheepwool.sheepModel = (ModelSheep1)modelBase;
        rendersheep1.addLayer(layersheepwool);
        return rendersheep1;
    }
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderOcelot renderocelot = new RenderOcelot(rendermanager);
    renderocelot.mainModel = modelBase;
    renderocelot.shadowSize = shadowSize;
    return renderocelot;
}

public static void loadEntityRenderers(RenderManager manager, Map<Class<? extends Entity> , Render<? extends Entity>> renderMap)
{
    for (Map.Entry<Class<? extends Entity>, IRenderFactory<? extends Entity>> entry : INSTANCE.entityRenderers.entrySet())
    {
        register(manager, renderMap, entry.getKey(), entry.getValue());
    }
}

@SideOnly(Side.CLIENT)
public static void initModels() {
    RenderingRegistry.registerEntityRenderingHandler(EntityMeeCreeps.class, RenderMeeCreeps.FACTORY);

    RenderingRegistry.registerEntityRenderingHandler(EntityProjectile.class, new IRenderFactory<EntityProjectile>() {
        @Override
        public Render<? super EntityProjectile> createRenderFor(RenderManager manager) {
            return new RenderProjectile<EntityProjectile>(manager, Minecraft.getMinecraft().getRenderItem());
        }
    });
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderZombie renderzombie = new RenderZombie(rendermanager);
    renderzombie.mainModel = modelBase;
    renderzombie.shadowSize = shadowSize;
    return renderzombie;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderWither renderwither = new RenderWither(rendermanager);
    renderwither.mainModel = modelBase;
    renderwither.shadowSize = shadowSize;
    return renderwither;
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderMagmaCube rendermagmacube = new RenderMagmaCube(rendermanager);
    rendermagmacube.mainModel = modelBase;
    rendermagmacube.shadowSize = shadowSize;
    return rendermagmacube;
}

public static void renderDebugText(String str, double x, double y, double z, float partialTicks, int color)
{
    Minecraft minecraft = Minecraft.getMinecraft();

    if (minecraft.player != null && minecraft.getRenderManager() != null && minecraft.getRenderManager().options != null)
    {
        FontRenderer fontrenderer = minecraft.fontRendererObj;
        EntityPlayer entityplayer = minecraft.player;
        double d0 = entityplayer.lastTickPosX + (entityplayer.posX - entityplayer.lastTickPosX) * (double)partialTicks;
        double d1 = entityplayer.lastTickPosY + (entityplayer.posY - entityplayer.lastTickPosY) * (double)partialTicks;
        double d2 = entityplayer.lastTickPosZ + (entityplayer.posZ - entityplayer.lastTickPosZ) * (double)partialTicks;
        GlStateManager.pushMatrix();
        GlStateManager.translate((float)(x - d0), (float)(y - d1) + 0.07F, (float)(z - d2));
        GlStateManager.glNormal3f(0.0F, 1.0F, 0.0F);
        GlStateManager.scale(0.02F, -0.02F, 0.02F);
        RenderManager rendermanager = minecraft.getRenderManager();
        GlStateManager.rotate(-rendermanager.playerViewY, 0.0F, 1.0F, 0.0F);
        GlStateManager.rotate((float)(rendermanager.options.thirdPersonView == 2 ? 1 : -1) * rendermanager.playerViewX, 1.0F, 0.0F, 0.0F);
        GlStateManager.disableLighting();
        GlStateManager.enableTexture2D();
        GlStateManager.enableDepth();
        GlStateManager.depthMask(true);
        GlStateManager.scale(-1.0F, 1.0F, 1.0F);
        fontrenderer.drawString(str, -fontrenderer.getStringWidth(str) / 2, 0, color);
        GlStateManager.enableLighting();
        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
        GlStateManager.popMatrix();
    }
}

public ModuleTracers() {
    super("Tracers", "tracers", Ordering.RENDER, 0, 0);
    addValue(rainbow, showInvis);
    addListener(new Listener("tracers_render_3d", Render3DEvent.class) {
        @Override
        public void call(Event e) {
            GL11.glPushMatrix();
            for (Entity ent : Wrapper.loadedEntityList()) {
                if (Wrapper.isInvisible(ent) && !showInvis.getValue()) continue;
                if (!EntityUtil.isValid_render(ent, false, false)) continue;
                if (!(ent instanceof EntityPlayer)) continue;
                boolean bob = Wrapper.gameSettings().field_74336_f;
                Wrapper.gameSettings().field_74336_f = false;
                GL11.glPushMatrix();
                GL11.glLineWidth(0.8f);
                double[] pos = EntityUtil.interpolate(ent, ((Render3DEvent) e).getPartialTicks());
                double posX = pos[0] - RenderManager.field_78725_b;
                double posY = pos[1] - RenderManager.field_78726_c;
                double posZ = pos[2] - RenderManager.field_78723_d;
                GL11.glLoadIdentity();
                ReflectionUtil.invokeMethod("func_78467_g", Wrapper.getMinecraft().field_71460_t, new Object[]{((Render3DEvent) e).getPartialTicks()}, float.class);
                int color = Bit.getInstance().getFriendManager().isFriend(ent.func_70005_c_())
                        ? new ColorBuilder(0, 200, 150, 255).build_hex()
                        : new ColorBuilder(0, 10, 255, 255).build_hex();
                if (rainbow.getValue()) color = ColorUtil.rainbow(Wrapper.loadedEntityList().indexOf(ent));
                RenderUtil.drawLine3D(0, 0, 0, posX, posY, posZ, color, true);
                GL11.glPopMatrix();
                Wrapper.gameSettings().field_74336_f = bob;
            }
            GL11.glPopMatrix();
        }
    });
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderAbstractHorse renderabstracthorse = new RenderAbstractHorse(rendermanager);
    renderabstracthorse.mainModel = modelBase;
    renderabstracthorse.shadowSize = shadowSize;
    return renderabstracthorse;
}

/**
 * Renders the particle
 */
public void renderParticle(WorldRenderer worldRendererIn, Entity entityIn, float partialTicks, float p_180434_4_, float p_180434_5_, float p_180434_6_, float p_180434_7_, float p_180434_8_)
{
    if (this.entity != null)
    {
        RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
        rendermanager.setRenderPosition(EntityFX.interpPosX, EntityFX.interpPosY, EntityFX.interpPosZ);
        float f = 0.42553192F;
        float f1 = ((float)this.particleAge + partialTicks) / (float)this.particleMaxAge;
        GlStateManager.depthMask(true);
        GlStateManager.enableBlend();
        GlStateManager.enableDepth();
        GlStateManager.blendFunc(770, 771);
        float f2 = 240.0F;
        OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, f2, f2);
        GlStateManager.pushMatrix();
        float f3 = 0.05F + 0.5F * MathHelper.sin(f1 * (float)Math.PI);
        GlStateManager.color(1.0F, 1.0F, 1.0F, f3);
        GlStateManager.translate(0.0F, 1.8F, 0.0F);
        GlStateManager.rotate(180.0F - entityIn.rotationYaw, 0.0F, 1.0F, 0.0F);
        GlStateManager.rotate(60.0F - 150.0F * f1 - entityIn.rotationPitch, 1.0F, 0.0F, 0.0F);
        GlStateManager.translate(0.0F, -0.4F, -1.5F);
        GlStateManager.scale(f, f, f);
        this.entity.rotationYaw = this.entity.prevRotationYaw = 0.0F;
        this.entity.rotationYawHead = this.entity.prevRotationYawHead = 0.0F;
        rendermanager.renderEntityWithPosYaw(this.entity, 0.0D, 0.0D, 0.0D, 0.0F, partialTicks);
        GlStateManager.popMatrix();
        GlStateManager.enableDepth();
    }
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
    RenderCreeper rendercreeper = new RenderCreeper(rendermanager);
    rendercreeper.mainModel = modelBase;
    rendercreeper.shadowSize = shadowSize;
    return rendercreeper;
}