Java 类net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent 实例源码

@Override
public void tick(TickEvent event) {
    super.tick(event);

    if(event instanceof ClientTickEvent) {
        while(!clientTickQeue.isEmpty())
            clientTickQeue.poll().run();
    }
    if(event instanceof RenderTickEvent) {
        RenderTickEvent revt = (RenderTickEvent) event;

        // Pre-Scene Render
        if(revt.phase == Phase.START) {
            clientRenderer.on_render_world_terrain_pre(revt);
        } else
            // Post-World >> Pre-HUD Render
            if(revt.phase == Phase.END) {
                clientRenderer.on_render_world_terrain_post(revt);
            }
    }
}

@SubscribeEvent
public void onRenderTick(RenderTickEvent e) {
    if (!isEnabled()) {
        return;
    }

    // only record at the end of the frame
    if (e.phase == Phase.START) {
        return;
    }

    // stop at frame limit
    if (frameLimit > 0 && time.getNumFrames() >= frameLimit) {
        disable();
    }

    // skip frames if the capturing framerate is not synchronized with the
    // rendering framerate
    if (!cfg.isSyncEngine() && !time.isNextFrame()) {
        // Game renders faster than necessary for recording?
        return;
    }

    postFrameEvent(new FrameImportEvent(frame, time, movieDir));
}

@SubscribeEvent
public void onRenderTick(RenderTickEvent evt) {
    if (task == null) {
        return;
    }

    try {
        if (task.onRenderTick(evt)) {
            task = null;
            ChatUtils.printFileLink("screenshot.success", taskFile.toFile());
        }
    } catch (Exception ex) {
        L.error("Screenshot capture failed", ex);
        ChatUtils.print("screenshot.failure", ex.getMessage());
        task = null;
    }
}

/**
 * Called before and after the rendering of the world.
 * 
 * @param event
 *            Contains information about the event.
 */
@SubscribeEvent
public void onRender(RenderTickEvent event)
{
    if( event.phase == Phase.START )
    {
        // this is here in case the user has resized the window during a mission
        resizeIfNeeded();
    }
}

/**
 * Called before and after the rendering of the world.
 * 
 * @param event
 *            Contains information about the event.
 */
@SubscribeEvent
public void onRender(RenderTickEvent event)
{
    if( event.phase == Phase.START )
    {
        // this is here in case the user has resized the window during a mission
        resizeIfNeeded();
    }
}

/**
 * Called before and after the rendering of the world.
 * 
 * @param event
 *            Contains information about the event.
 */
@SubscribeEvent
public void onRender(RenderTickEvent event)
{
    if( event.phase == Phase.START )
    {
        // this is here in case the user has resized the window during a mission
        resizeIfNeeded();
    }
}

@SubscribeEvent
public void tick(RenderTickEvent event) {
    if (tickDelay++ <= 20) return;
    // This is FPS-based, not worldtick based. It just needs to happen occasionally
    tickDelay = 0;
    if (event.phase == Phase.START) {
        tickStart();
    }
}

/** Handle rendering updates */
@SideOnly(Side.CLIENT)
@SubscribeEvent
public void onPlayerRenderTick(RenderTickEvent e) {
    EntityPlayer player = Minecraft.getMinecraft().thePlayer; if(player == null) return;

    // handle potion rendering
    handleClientPotionEffects(player);
}

public void on_render_world_terrain_pre(RenderTickEvent revt) {
    if(mc.world != null) {
        // Which VisualMode should we use?
        VisualMode visMode = visualizationMode;

        // Prevent non-creative players from using the visualization modes.
        if(!proxy.isBuildMode()) {
            visMode = VisualMode.Default;
        }

        // this takes care of the CUSTOM SKY RENDERING
        if(mc.world.provider != null) {
            boolean debugSkyActive = visMode != VisualMode.Default;

            if(debugSkyActive) {
                CustomSkyRenderer.instance.setDebugSky(true);
                mc.world.provider.setSkyRenderer(CustomSkyRenderer.instance);
            } else if(Environments.isNonDefault()) {
                CustomSkyRenderer.instance.setDebugSky(false);
                mc.world.provider.setSkyRenderer(CustomSkyRenderer.instance);
            } else {
                CustomSkyRenderer.instance.setDebugSky(false);
                mc.world.provider.setSkyRenderer(null);
            }
        }

        // handle currently active VisualMode
        if(mc.player != null) {
            RenderModeHelper.ENABLE(visMode);
        }
    }
}

public void on_render_world_terrain_post(RenderTickEvent revt) {
    if(mc.ingameGUI != null && mc.world != null) {
        if(proxy.getInfoBar().canDisplayInfoBar(mc, proxy)) {
            proxy.getInfoBar().display(mc, mc.world, proxy);

            // XXX: Move this to its own IF
            proxy.getInvokeTracker().display(mc, proxy);
        }
    }
}

@SubscribeEvent
public void onTick(RenderTickEvent event)
{
    //we want the END phase
    if (!event.phase.equals(Phase.END))return;
    if(Clock.doesRender(mcClient)){
        Clock.draw(mcClient);
    }

}

@SubscribeEvent
public void onTick(RenderTickEvent t) {
    GuiScreen screen = Minecraft.getMinecraft().currentScreen;
    if (screen instanceof GuiMainMenu) {
        screen.drawCenteredString(Minecraft.getMinecraft().fontRendererObj, StatCollector.translateToLocal("ias.loggedinas") + Minecraft.getMinecraft().getSession().getUsername()+".", screen.width / 2, screen.height / 4 + 48 + 72 + 12 + 22, 0xFFCC8888);
    }else if(screen instanceof GuiMultiplayer){
        if (Minecraft.getMinecraft().getSession().getToken().equals("0")) {
            screen.drawCenteredString(Minecraft.getMinecraft().fontRendererObj, StatCollector.translateToLocal("ias.offlinemode"), screen.width / 2, 10, 16737380);
        }
    }
}

@SubscribeEvent
public void onRender(RenderTickEvent evt) {
    if (evt.phase == Phase.END) {
        GlStateManager.color(1, 1, 1);
        GlStateManager.enableTexture2D();
        GlStateManager.disableLighting();
        GlStateManager.enableBlend();
        GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        if (mouseIndicators != null)
            mouseIndicators.render(evt.renderTickTime);

        if (keyboardIndicators != null)
            keyboardIndicators.render(evt.renderTickTime);
    }
}

@Override
public boolean onRenderTick(RenderTickEvent evt) throws FileNotFoundException, IOException {
    int width = config.captureWidth.get();
    int height = config.captureHeight.get();

    FramebufferCapturer fbc = new FramebufferCapturer();
    FramebufferTiledWriter fbw = new FramebufferTiledWriter(file, fbc, width, height);
    fbw.write();

    return true;
}

@Override
public boolean onRenderTick(RenderTickEvent evt) throws Exception {
    switch (frame) {
        // override viewport size (the following frame will be black)
        case 0:
            displayWidth = MC.displayWidth;
            displayHeight = MC.displayHeight;

            int width = config.captureWidth.get();
            int height = config.captureHeight.get();

            // resize viewport/framebuffer
            MC.resize(width, height);
            break;

        // capture screenshot and restore viewport size
        case 3:
            try {
                FramebufferCapturer fbc = new FramebufferCapturer();
                FramebufferWriter fbw = new FramebufferWriter(file, fbc);
                fbw.write();
            } finally {
                // restore viewport/framebuffer
                MC.resize(displayWidth, displayHeight);
            }
            break;
    }

    frame++;
    return frame > 3;
}

@SubscribeEvent
public void RenderTickEvent(TickEvent.RenderTickEvent event)
{
    if (event.phase == TickEvent.Phase.START)
    {
        renderPartialTicks = event.renderTickTime;

        if (Minecraft.getMinecraft().player != null) DrawableApi.beginFrustum();
    }
    else if (event.phase == TickEvent.Phase.END)
    {
    }
}

@SubscribeEvent
public void onRenderTick(RenderTickEvent event) {
    if (event.phase == Phase.START) {
        if (mc.thePlayer != null && ZSSPlayerSkills.get(mc.thePlayer) != null) {
            // TODO updateRenderer();
            ZSSPlayerSkills.get(mc.thePlayer).onRenderTick(event.renderTickTime);
            float swing = ZSSPlayerInfo.get(mc.thePlayer).armSwing;
            if (swing > 0.0F) {
                mc.thePlayer.swingProgress = swing;
                mc.thePlayer.prevSwingProgress = swing;
            }
        }
    }
}

/** Subclass should overrride this to act on render ticks.*/
protected void onRenderTick(RenderTickEvent ev) {}

/** Subclass should overrride this to act on render ticks.*/
protected void onRenderTick(RenderTickEvent ev) {}

/** Subclass should overrride this to act on render ticks.*/
protected void onRenderTick(RenderTickEvent ev) {}

@SubscribeEvent
public void onRender(final RenderTickEvent e) {
    PathHandler.tick();
}

@SubscribeEvent
public void renderEnd(RenderTickEvent event) {
    Minecraft mc = Minecraft.getMinecraft();
    // Check FIRST, to avoid rendering before.
    if (mc.thePlayer == null)
        return;
    // if (mc.currentScreen != null)
    // return;
    if (CivConfig.debugMode.getBoolean()) {
        NBTTagCompound nbt = CivCraft.playerNBTData;
        NBTTagCompound nbtCiv = nbt.getCompoundTag("civcraft");
        NBTTagCompound nbtCooling = nbtCiv.getCompoundTag("cooldown");
        NBTTagCompound nbtProgress = nbtCiv.getCompoundTag("progress");
        NBTTagCompound nbtLastDone = nbtCiv.getCompoundTag("lastdone");
        // CivCraft.log.info(nbtCiv.toString());
        List<String> names = new ArrayList<String>();
        for (Object o : nbtProgress.getKeySet())
            names.add((String) o);

        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        // ScaledResolution res = new ScaledResolution(mc, mc.displayWidth,
        // mc.displayHeight);
        // int width = res.getScaledWidth();
        // int height = res.getScaledHeight();
        int x = 10;
        int y = 10;
        int colour = 0xFFFFFF;
        int altColour = 0x0000FF;
        DecimalFormat df = new DecimalFormat();
        mc.fontRendererObj.drawString("drawing " + names.size() + " stuffs", x, y - mc.fontRendererObj.FONT_HEIGHT, colour);
        for (String n : names) {
            double cool = nbtCooling.getDouble(n);
            String cooling = df.format(cool);
            String progress = df.format(nbtProgress.getDouble(n));
            String time = Long.toString(nbtLastDone.getLong(n));
            int colourToUse = (cool == 0) ? colour : altColour;
            mc.fontRendererObj.drawString("\"" + n + "\"=[Cooling=(" + (cooling.length() > 6 ? cooling.substring(0, 5) : cooling)
                    + "),Progress=(" + (progress.length() > 6 ? progress.substring(0, 5) : progress) + "),LastDone=" + time + "]", x, y,
                    colourToUse);
            y += mc.fontRendererObj.FONT_HEIGHT;
        }

    }
}

@SubscribeEvent
public void onFrame(RenderTickEvent e) {
    if (e.phase == Phase.START) {
        core.frame();
    }
}

@SubscribeEvent
    public void onTick(RenderTickEvent event)
    {
        if (event.phase.equals(Phase.START))
        {
            return;
        }else if ((mc.inGameHasFocus || mc.currentScreen == null) && !mc.gameSettings.showDebugInfo)
        {
            if(allowTestRender)
            {
//              EntityPlayer d;
//              float worldTime = event.renderTickTime;
//              double tickRate = 1000;
//              double cornerX = worldTime / tickRate;
//              double cornerY = worldTime / tickRate;
//              
//              ScaledResolution scaled = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
//
//              GL11.glPushMatrix();
//              
//              GL11.glDisable(GL11.GL_DEPTH_TEST);
//              GL11.glDepthMask(false);
//              OpenGlHelper.glBlendFunc(770, 771, 1, 0);
//              GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
//              GL11.glDisable(GL11.GL_ALPHA_TEST);
//              mc.getTextureManager().bindTexture(tempResource);
//              Tessellator tessellator = Tessellator.getInstance();
//              WorldRenderer wr = tessellator.getWorldRenderer();
//              wr.startDrawingQuads();
//              wr.addVertexWithUV(0.0D, (double)scaled.getScaledHeight(), -90.0D, 0.0D + cornerX, 1.0D + cornerY);
//              wr.addVertexWithUV((double)scaled.getScaledWidth(), (double)scaled.getScaledHeight(), -90.0D, 1.0D + cornerX, 1.0D + cornerY);
//              wr.addVertexWithUV((double)scaled.getScaledWidth(), 0.0D, -90.0D, 1.0D + cornerX, 0.0D + cornerY);
//              wr.addVertexWithUV(0.0D, 0.0D, -90.0D, 0.0D + cornerX, 0.0D + cornerY);
//              tessellator.draw();
//              GL11.glDepthMask(true);
//              GL11.glEnable(GL11.GL_DEPTH_TEST);
//              GL11.glEnable(GL11.GL_ALPHA_TEST);
//              GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
//
//              GL11.glPopMatrix();
            }

            if (!HUDRenderHelper.renderHUDElements(mc))
            {
                return;
            }
        } 
    }

/**
 * Called on every frame to update the task.
 * 
 * @param evt current render tick event
 * @return true if the task is done and can be disposed or false if it should
 *         continue to be updated.
 * @throws Exception 
 */
boolean onRenderTick(RenderTickEvent evt) throws Exception;