LiteLoader / LiteLoader · Files

package com.mumfrey.liteloader.client;

import java.io.File;
import java.util.UUID;

import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.gui.GuiIngame;
import net.minecraft.client.renderer.EntityRenderer;
import net.minecraft.client.renderer.OpenGlHelper;
import net.minecraft.client.renderer.RenderGlobal;
import net.minecraft.client.renderer.entity.Render;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.shader.Framebuffer;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.server.integrated.IntegratedServer;
import net.minecraft.util.IChatComponent;
import net.minecraft.util.ScreenShotHelper;
import net.minecraft.util.Session;
import net.minecraft.world.WorldSettings;

import com.mojang.authlib.GameProfile;
import com.mumfrey.liteloader.core.CallbackProxyCommon;
import com.mumfrey.liteloader.transformers.event.EventInfo;
import com.mumfrey.liteloader.transformers.event.ReturnEventInfo;

/**
 * Proxy class which handles the redirected calls from the injected callbacks
 * and routes them to the relevant liteloader handler classes. We do this rather
 * than patching a bunch of bytecode into the packet classes themselves because
 * this is easier to maintain.
 * 
 * @author Adam Mummery-Smith
 */
public abstract class CallbackProxyClient extends CallbackProxyCommon
{
    private static LiteLoaderEventBrokerClient clientEventBroker;

    private static boolean fboEnabled;

    private static boolean renderingFBO;

    private CallbackProxyClient() {}

    public static void onStartupComplete(EventInfo<Minecraft> e)
    {
        CallbackProxyCommon.onStartupComplete();

        CallbackProxyClient.clientEventBroker = LiteLoaderEventBrokerClient.getInstance();

        if (CallbackProxyClient.clientEventBroker == null)
        {
            throw new RuntimeException("LiteLoader failed to start up properly."
                    + " The game is in an unstable state and must shut down now. Check the developer log for startup errors");
        }

        CallbackProxyClient.clientEventBroker.onStartupComplete();
    }

    public static void onTimerUpdate(EventInfo<Minecraft> e)
    {
        CallbackProxyClient.clientEventBroker.onTimerUpdate();
    }

    public static void newTick(EventInfo<Minecraft> e)
    {
    }

    public static void onTick(EventInfo<Minecraft> e)
    {
        CallbackProxyClient.clientEventBroker.onTick();
    }

    public static void onRender(EventInfo<Minecraft> e)
    {
        CallbackProxyClient.clientEventBroker.onRender();
    }

    public static void preRenderGUI(EventInfo<EntityRenderer> e, float partialTicks)
    {
        CallbackProxyClient.clientEventBroker.preRenderGUI(partialTicks);
    }

    public static void onSetupCameraTransform(EventInfo<EntityRenderer> e, int pass, float partialTicks, long timeSlice)
    {
        CallbackProxyClient.clientEventBroker.onSetupCameraTransform(pass, partialTicks, timeSlice);
    }

    public static void postRenderEntities(EventInfo<EntityRenderer> e, int pass, float partialTicks, long timeSlice)
    {
        CallbackProxyClient.clientEventBroker.postRenderEntities(partialTicks, timeSlice);
    }

    public static void postRender(EventInfo<EntityRenderer> e, float partialTicks, long timeSlice)
    {
        CallbackProxyClient.clientEventBroker.postRender(partialTicks, timeSlice);
    }

    public static void onRenderHUD(EventInfo<EntityRenderer> e, float partialTicks)
    {
        CallbackProxyClient.clientEventBroker.onRenderHUD(partialTicks);
    }

    public static void onRenderChat(EventInfo<GuiIngame> e, float partialTicks)
    {
        CallbackProxyClient.clientEventBroker.onRenderChat(e.getSource().getChatGUI(), partialTicks);
    }

    public static void postRenderChat(EventInfo<GuiIngame> e, float partialTicks)
    {
        CallbackProxyClient.clientEventBroker.postRenderChat(e.getSource().getChatGUI(), partialTicks);
    }

    public static void postRenderHUD(EventInfo<EntityRenderer> e, float partialTicks)
    {
        CallbackProxyClient.clientEventBroker.postRenderHUD(partialTicks);
    }

    public static void IntegratedServerCtor(EventInfo<IntegratedServer> e, Minecraft minecraft, String folderName, String worldName,
            WorldSettings worldSettings)
    {
        CallbackProxyClient.clientEventBroker.onStartServer(e.getSource(), folderName, worldName, worldSettings);
    }

    public static void onOutboundChat(EventInfo<EntityPlayerSP> e, String message)
    {
        CallbackProxyClient.clientEventBroker.onSendChatMessage(e, message);
    }

    public static void onResize(EventInfo<Minecraft> e)
    {
        if (CallbackProxyClient.clientEventBroker == null) return;
        CallbackProxyClient.clientEventBroker.onResize(e.getSource());
    }

    public static void preRenderFBO(EventInfo<Minecraft> e)
    {
        if (CallbackProxyClient.clientEventBroker == null) return;
        CallbackProxyClient.fboEnabled = OpenGlHelper.isFramebufferEnabled();

        if (CallbackProxyClient.fboEnabled)
        {
            CallbackProxyClient.renderingFBO = true;
            CallbackProxyClient.clientEventBroker.preRenderFBO(e.getSource().getFramebuffer());
        }
    }

    public static void postRenderFBO(EventInfo<Minecraft> e)
    {
        if (CallbackProxyClient.clientEventBroker == null) return;
        CallbackProxyClient.renderingFBO = false;

        if (CallbackProxyClient.fboEnabled)
        {
            CallbackProxyClient.clientEventBroker.postRenderFBO(e.getSource().getFramebuffer());
        }
    }

    public static void renderFBO(EventInfo<Framebuffer> e, int width, int height, boolean flag)
    {
        if (CallbackProxyClient.clientEventBroker == null) return;
        if (CallbackProxyClient.renderingFBO)
        {
            CallbackProxyClient.clientEventBroker.onRenderFBO(e.getSource(), width, height);
        }

        CallbackProxyClient.renderingFBO = false;
    }

    public static void onRenderWorld(EventInfo<EntityRenderer> e, float partialTicks, long timeSlice)
    {
        CallbackProxyClient.clientEventBroker.onRenderWorld(partialTicks, timeSlice);
    }

    public static void onRenderSky(EventInfo<EntityRenderer> e, int pass, float partialTicks, long timeSlice)
    {
        CallbackProxyClient.clientEventBroker.onRenderSky(partialTicks, pass, timeSlice);
    }

    public static void onRenderClouds(EventInfo<EntityRenderer> e, RenderGlobal renderGlobalIn, float partialTicks, int pass)
    {
        CallbackProxyClient.clientEventBroker.onRenderClouds(partialTicks, pass, renderGlobalIn);
    }

    public static void onRenderTerrain(EventInfo<EntityRenderer> e, int pass, float partialTicks, long timeSlice)
    {
        CallbackProxyClient.clientEventBroker.onRenderTerrain(partialTicks, pass, timeSlice);
    }

    public static void onSaveScreenshot(ReturnEventInfo<ScreenShotHelper, IChatComponent> e, File gameDir, String name, int width, int height,
            Framebuffer fbo)
    {
        CallbackProxyClient.clientEventBroker.onScreenshot(e, name, width, height, fbo);
    }

    public static void onRenderEntity(ReturnEventInfo<RenderManager, Boolean> e, Entity entity, double xPos, double yPos, double zPos, float yaw,
            float partialTicks, boolean hideBoundingBox, Render render)
    {
        CallbackProxyClient.clientEventBroker.onRenderEntity(e.getSource(), entity, xPos, yPos, zPos, yaw, partialTicks, render);
    }

    public static void onPostRenderEntity(ReturnEventInfo<RenderManager, Boolean> e, Entity entity, double xPos, double yPos, double zPos, float yaw,
            float partialTicks, boolean hideBoundingBox, Render render)
    {
        CallbackProxyClient.clientEventBroker.onPostRenderEntity(e.getSource(), entity, xPos, yPos, zPos, yaw, partialTicks, render);
    }

    /**
     * Compatiblbe behaviour with FML, this method is called to generate a
     * consistent offline UUID between client and server for a given username.
     */
    public static void generateOfflineUUID(ReturnEventInfo<Session, GameProfile> e)
    {
        Session session = e.getSource();
        UUID uuid = EntityPlayer.getUUID(new GameProfile((UUID)null, session.getUsername()));
        e.setReturnValue(new GameProfile(uuid, session.getUsername()));
    }
}