private static final ResourceLocation locationMojangPng = new ResourceLocation("textures/gui/title/mojang.png");

  public static final boolean isRunningOnMac = Util.getOSType() == EnumOS.MACOS;

  /** A 10MiB preallocation to ensure the heap is reasonably sized. */

  public static byte[] memoryReserve = new byte[10485760];

  private static final List macDisplayModes = Lists.newArrayList(new DisplayMode[] {new DisplayMode(2560, 1600), new DisplayMode(2880, 1800)});

  private final ILogAgent mcLogAgent;

  private final File fileResourcepacks;

  private ServerData currentServerData;

  /** The RenderEngine instance used by Minecraft */

  // Spout Start

  public TextureManager renderEngine;

  // Spout End

  /**

   * Set to 'this' in Minecraft constructor; used by some settings get methods

   */

  // Spout Start - private to public

  public static Minecraft theMinecraft;

  // Spout End

  public PlayerControllerMP playerController;

  private boolean fullscreen;

  private boolean hasCrashed;

  /** Instance of CrashReport. */

  private CrashReport crashReporter;

  public int displayWidth;

  public int displayHeight;

  private Timer timer;

  /** Instance of PlayerUsageSnooper. */

  private PlayerUsageSnooper usageSnooper;

  public WorldClient theWorld;

  public RenderGlobal renderGlobal;

  public EntityClientPlayerMP thePlayer;

  /**

   * The Entity from which the renderer determines the render viewpoint. Currently is always the parent Minecraft class's

   * 'thePlayer' instance. Modification of its location, rotation, or other settings at render time will modify the

   * camera likewise, with the caveat of triggering chunk rebuilds as it moves, making it unsuitable for changing the

   * viewpoint mid-render.

   */

  public EntityLivingBase renderViewEntity;

  public EntityLivingBase pointedEntityLiving;

  public EffectRenderer effectRenderer;

  public Session session; 

  public boolean isGamePaused; 

  /** The font renderer used for displaying and measuring text. */

  public FontRenderer fontRenderer;

  public FontRenderer standardGalacticFontRenderer;

  /** The GuiScreen that's being displayed at the moment. */

  public GuiScreen currentScreen;

  public LoadingScreenRenderer loadingScreen;

  public EntityRenderer entityRenderer;

  /** Mouse left click counter */

  private int leftClickCounter;

  /** Display width */

  private int tempDisplayWidth;

  /** Display height */

  private int tempDisplayHeight;

  /** Instance of IntegratedServer. */

  private IntegratedServer theIntegratedServer;

  /** Gui achievement */

  public GuiAchievement guiAchievement;

  public GuiIngame ingameGUI;

  /** Skip render world */

  public boolean skipRenderWorld;

  /** The ray trace hit that the mouse is over. */

  public MovingObjectPosition objectMouseOver;

  /** The game settings that currently hold effect. */

  public GameSettings gameSettings; 

  public SoundManager sndManager;

  /** Mouse helper instance. */

  public MouseHelper mouseHelper;

  public final File mcDataDir;

  private final File fileAssets;

  private final String launchedVersion;

  private final Proxy proxy;

  private ISaveFormat saveLoader;

  /**

   * This is set to fpsCounter every debug screen update, and is shown on the debug screen. It's also sent as part of the

   * usage snooping.

   */

  private static int debugFPS;

  /**

   * When you place a block, it's set to 6, decremented once per tick, when it's 0, you can place another block.

   */

  private int rightClickDelayTimer;

  /**

   * Checked in Minecraft's while(running) loop, if true it's set to false and the textures refreshed.

   */

  private boolean refreshTexturePacksScheduled;

  /** Stat file writer */

  public StatFileWriter statFileWriter;

  private String serverName;

  private int serverPort;

  /**

   * Makes sure it doesn't keep taking screenshots when both buttons are down.

   */

  boolean isTakingScreenshot;

  /**

   * Does the actual gameplay have focus. If so then mouse and keys will effect the player instead of menus.

   */

  public boolean inGameHasFocus;

  long systemTime;

  /** Join player counter */

  private int joinPlayerCounter;

  private final boolean isDemo;

  private INetworkManager myNetworkManager;

  private boolean integratedServerIsRunning;

  /** The profiler instance */

  public final Profiler mcProfiler;

  private long field_83002_am;

  private ReloadableResourceManager mcResourceManager;

  private final MetadataSerializer metadataSerializer_;

  private List defaultResourcePacks;

  private DefaultResourcePack mcDefaultResourcePack;

  private ResourcePackRepository mcResourcePackRepository;

  private LanguageManager mcLanguageManager;

  /**

   * Set to true to keep the game loop running. Set to false by shutdown() to allow the game loop to exit cleanly.

   */

  volatile boolean running;

  /** String that shows the debug information */

  public String debug;

  /** Approximate time (in ms) of last update to debug string */

  long debugUpdateTime;

  /** holds the current fps */

  int fpsCounter;

  long prevFrameTime;

  /** Profiler currently displayed in the debug screen pie chart */

  private String debugProfilerName;

  // Spout Start

  public static Thread mainThread;

  private boolean shutdown = false;

  public static boolean spoutcraftLauncher = true;

  public static boolean portable = false;

  public static int framesPerSecond = 0;

  // Spout End

  public Minecraft(Session par1Session, int par2, int par3, boolean par4, boolean par5, File par6File, File par7File, File par8File, Proxy par9Proxy, String par10Str) {   

    MCPatcherUtils.setMinecraft(par6File, par7File, "1.6.4", "4.2.2");

    this.timer = new Timer(20.0F);

    this.usageSnooper = new PlayerUsageSnooper("client", this, MinecraftServer.getSystemTimeMillis());

    this.systemTime = getSystemTime();

    this.mcProfiler = new Profiler();

    this.field_83002_am = -1L;

    this.metadataSerializer_ = new MetadataSerializer();

    this.defaultResourcePacks = Lists.newArrayList();

    this.running = true;

    this.debug = "";

    this.debugUpdateTime = getSystemTime();

    this.prevFrameTime = -1L;

    this.debugProfilerName = "root";

    theMinecraft = this;

    this.mcLogAgent = new LogAgent("Minecraft-Client", " [CLIENT]", (new File(par6File, "output-client.log")).getAbsolutePath());

    this.mcDataDir = par6File;

    this.fileAssets = par7File;

    this.fileResourcepacks = par8File;

    this.launchedVersion = par10Str;

    this.mcDefaultResourcePack = new DefaultResourcePack(this.fileAssets);

    this.addDefaultResourcePack();

    this.proxy = par9Proxy;

    this.startTimerHackThread();

    this.session = par1Session;

    //this.mcLogAgent.logInfo("Setting user: " + par1Session.getUsername());

    //this.mcLogAgent.logInfo("(Session ID is " + par1Session.getSessionID() + ")");

    this.isDemo = par5;

    this.displayWidth = par2;

    this.displayHeight = par3;

    this.tempDisplayWidth = par2;

    this.tempDisplayHeight = par3;

    this.fullscreen = par4;

    ImageIO.setUseCache(false);

    StatList.nopInit();

   

    // Spout Start

    Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {

      public void run() {

        shutdownMinecraftApplet();

      }

    }));

    // Spout End

  }

  private void startTimerHackThread() {

    ThreadClientSleep var1 = new ThreadClientSleep(this, "Timer hack thread");

    var1.setDaemon(true);

    var1.start();

  }

  public void crashed(CrashReport par1CrashReport) {

    this.hasCrashed = true;

    this.crashReporter = par1CrashReport;

  }

  /**

   * Wrapper around displayCrashReportInternal

   */

  public void displayCrashReport(CrashReport par1CrashReport) {

    File var2 = new File(getMinecraft().mcDataDir, "crash-reports");

    File var3 = new File(var2, "crash-" + (new SimpleDateFormat("yyyy-MM-dd_HH.mm.ss")).format(new Date()) + "-client.txt");

    System.out.println(par1CrashReport.getCompleteReport());

    if (par1CrashReport.getFile() != null) {

      System.out.println("#@!@# Game crashed! Crash report saved to: #@!@# " + par1CrashReport.getFile());

      System.exit(-1);

    } else if (par1CrashReport.saveToFile(var3, this.getLogAgent())) {

      System.out.println("#@!@# Game crashed! Crash report saved to: #@!@# " + var3.getAbsolutePath());

      System.exit(-1);

    } else {

      System.out.println("#@?@# Game crashed! Crash report could not be saved. #@?@#");

      System.exit(-2);

    }

  }

  public void setServer(String par1Str, int par2) {

    this.serverName = par1Str;

    this.serverPort = par2;

  }

  /**

   * Starts the game: initializes the canvas, the title, the settings, etcetera.

   */

  public void startGame() throws LWJGLException {

    this.gameSettings = new GameSettings(this, this.mcDataDir);

    if (this.gameSettings.overrideHeight > 0 && this.gameSettings.overrideWidth > 0) {

      this.displayWidth = this.gameSettings.overrideWidth;

      this.displayHeight = this.gameSettings.overrideHeight;

    }

    if (this.fullscreen) {

      Display.setFullscreen(true);

      this.displayWidth = Display.getDisplayMode().getWidth();

      this.displayHeight = Display.getDisplayMode().getHeight();

      if (this.displayWidth <= 0) {

        this.displayWidth = 1;

      }

      if (this.displayHeight <= 0) {

        this.displayHeight = 1;

      }

      // Spout Start

      Display.setDisplayMode(new DisplayMode(this.displayWidth, this.displayHeight));

      Display.setFullscreen(this.fullscreen);

      Display.setVSyncEnabled(this.gameSettings.enableVsync);

      Display.update();

      // Spout End

    } else {

      Display.setDisplayMode(new DisplayMode(this.displayWidth, this.displayHeight));

    }

   

    Display.setResizable(true);

    Display.setTitle("Spoutcraft 1.6.4");

    //this.getLogAgent().logInfo("LWJGL Version: " + Sys.getVersion());

    if (Util.getOSType() != EnumOS.MACOS) {

      try {

        Display.setIcon(new ByteBuffer[] {this.readImage(new File(FileUtil.getAssetsDir(), "/icon/icon_16x16.png")), this.readImage(new File(FileUtil.getAssetsDir(), "/icon/icon_32x32.png"))});

      } catch (IOException var5) {

        var5.printStackTrace();

      }

    }

    try {

      Display.create(AAHelper.setupPixelFormat((new PixelFormat()).withDepthBits(24)));

    } catch (LWJGLException var4) {

      var4.printStackTrace();

      try {

        Thread.sleep(1000L);

      } catch (InterruptedException var3) {

        ;

      }

      if (this.fullscreen) {

        this.updateDisplayMode();

      }

      Display.create();

    }

    // Spout Start

    System.out.println("\nSpoutcraft Version: " + SpoutClient.getSpoutcraftVersion() + SpoutClient.getSpoutcraftBuild());

    System.out.println("\nStarting texture pack initialization...");

    // Spout End

    OpenGlHelper.initializeTextures();

    this.guiAchievement = new GuiAchievement(this);

    this.metadataSerializer_.registerMetadataSectionType(new TextureMetadataSectionSerializer(), TextureMetadataSection.class);

    this.metadataSerializer_.registerMetadataSectionType(new FontMetadataSectionSerializer(), FontMetadataSection.class);

    this.metadataSerializer_.registerMetadataSectionType(new AnimationMetadataSectionSerializer(), AnimationMetadataSection.class);

    this.metadataSerializer_.registerMetadataSectionType(new PackMetadataSectionSerializer(), PackMetadataSection.class);

    this.metadataSerializer_.registerMetadataSectionType(new LanguageMetadataSectionSerializer(), LanguageMetadataSection.class);

    this.saveLoader = new AnvilSaveConverter(new File(this.mcDataDir, "saves"));

    this.mcResourcePackRepository = new ResourcePackRepository(this.fileResourcepacks, this.mcDefaultResourcePack, this.metadataSerializer_, this.gameSettings);

    TexturePackChangeHandler.earlyInitialize("com.prupe.mcpatcher.TileLoader", "init");

    TexturePackChangeHandler.earlyInitialize("com.prupe.mcpatcher.ctm.CTMUtils", "reset");

    TexturePackChangeHandler.earlyInitialize("com.prupe.mcpatcher.cit.CITUtils", "init");

    TexturePackChangeHandler.earlyInitialize("com.prupe.mcpatcher.hd.FontUtils", "init");

    TexturePackChangeHandler.earlyInitialize("com.prupe.mcpatcher.mob.MobRandomizer", "init");

    TexturePackChangeHandler.earlyInitialize("com.prupe.mcpatcher.cc.Colorizer", "init");

    TexturePackChangeHandler.beforeChange1(true);

    this.mcResourceManager = new SimpleReloadableResourceManager(this.metadataSerializer_);

    this.mcLanguageManager = new LanguageManager(this.metadataSerializer_, this.gameSettings.language);

    this.mcResourceManager.registerReloadListener(this.mcLanguageManager);

    this.refreshResources();

    this.renderEngine = new TextureManager(this.mcResourceManager);

    this.mcResourceManager.registerReloadListener(this.renderEngine);

    this.sndManager = new SoundManager(this.mcResourceManager, this.gameSettings, this.fileAssets);

    this.mcResourceManager.registerReloadListener(this.sndManager);   

    this.loadScreen();

    this.fontRenderer = new FontRenderer(this.gameSettings, new ResourceLocation("textures/font/ascii.png"), this.renderEngine, false);

    if (this.gameSettings.language != null) {

      this.fontRenderer.setUnicodeFlag(this.mcLanguageManager.isCurrentLocaleUnicode());

      this.fontRenderer.setBidiFlag(this.mcLanguageManager.isCurrentLanguageBidirectional());

    }

    this.standardGalacticFontRenderer = new FontRenderer(this.gameSettings, new ResourceLocation("textures/font/ascii_sga.png"), this.renderEngine, false);

    this.mcResourceManager.registerReloadListener(this.fontRenderer);

    this.mcResourceManager.registerReloadListener(this.standardGalacticFontRenderer);

    this.mcResourceManager.registerReloadListener(new GrassColorReloadListener());

    this.mcResourceManager.registerReloadListener(new FoliageColorReloadListener());

    RenderManager.instance.itemRenderer = new ItemRenderer(this);

    this.entityRenderer = new EntityRenderer(this);

    this.statFileWriter = new StatFileWriter(this.session, this.mcDataDir);

    AchievementList.openInventory.setStatStringFormatter(new StatStringFormatKeyInv(this));

    this.mouseHelper = new MouseHelper();

    // Spout Start

    Keyboard.create();

    // Spout End

    this.checkGLError("Pre startup");

    GL11.glEnable(GL11.GL_TEXTURE_2D);

    GL11.glShadeModel(GL11.GL_SMOOTH);

    GL11.glClearDepth(1.0D);

    GL11.glEnable(GL11.GL_DEPTH_TEST);

    GL11.glDepthFunc(GL11.GL_LEQUAL);

    GL11.glEnable(GL11.GL_ALPHA_TEST);

    GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);

    GL11.glCullFace(GL11.GL_BACK);

    GL11.glMatrixMode(GL11.GL_PROJECTION);

    GL11.glLoadIdentity();

    GL11.glMatrixMode(GL11.GL_MODELVIEW);

    this.renderGlobal = new RenderGlobal(this);

    this.renderEngine.loadTextureMap(TextureMap.locationBlocksTexture, new TextureMap(0, "textures/blocks"));

    this.renderEngine.loadTextureMap(TextureMap.locationItemsTexture, new TextureMap(1, "textures/items"));

    GL11.glViewport(0, 0, this.displayWidth, this.displayHeight);

    TexturePackChangeHandler.afterChange1(true);

    this.effectRenderer = new EffectRenderer(this.theWorld, this.renderEngine);

    this.checkGLError("Post startup");

    this.ingameGUI = new GuiIngame(this);

    if (this.serverName != null) {

      this.displayGuiScreen(new GuiConnecting(new GuiMainMenu(), this, this.serverName, this.serverPort));

    } else {

      // Spout Start

      this.displayGuiScreen(new org.spoutcraft.client.gui.mainmenu.MainMenu());

      // Spout End

    }

    this.loadingScreen = new LoadingScreenRenderer(this);

    if (this.gameSettings.fullScreen && !this.fullscreen) {

      this.toggleFullscreen();

    }

  }

  public void refreshResources() {

    ArrayList var1 = Lists.newArrayList(this.defaultResourcePacks);

    Iterator var2 = this.mcResourcePackRepository.getRepositoryEntries().iterator();

    while (var2.hasNext()) {

      ResourcePackRepositoryEntry var3 = (ResourcePackRepositoryEntry)var2.next();

      var1.add(var3.getResourcePack());

    }

    this.mcLanguageManager.parseLanguageMetadata(var1);

    this.mcResourceManager.reloadResources(var1);

    if (this.renderGlobal != null) {

      this.renderGlobal.loadRenderers();

    }

  }

  private void addDefaultResourcePack() {

    this.defaultResourcePacks.add(this.mcDefaultResourcePack);

  }

  private ByteBuffer readImage(File par1File) throws IOException {

    BufferedImage var2 = ImageIO.read(par1File);

    int[] var3 = var2.getRGB(0, 0, var2.getWidth(), var2.getHeight(), (int[])null, 0, var2.getWidth());

    ByteBuffer var4 = ByteBuffer.allocate(4 * var3.length);

    int[] var5 = var3;

    int var6 = var3.length;

    for (int var7 = 0; var7 < var6; ++var7) {

      int var8 = var5[var7];

      var4.putInt(var8 << 8 | var8 >> 24 & 255);

    }

    var4.flip();

    return var4;

  }

  private void updateDisplayMode() throws LWJGLException {

    HashSet var1 = new HashSet();

    Collections.addAll(var1, Display.getAvailableDisplayModes());

    DisplayMode var2 = Display.getDesktopDisplayMode();

    if (!var1.contains(var2) && Util.getOSType() == EnumOS.MACOS) {

      Iterator var3 = macDisplayModes.iterator();

      while (var3.hasNext()) {

        DisplayMode var4 = (DisplayMode)var3.next();

        boolean var5 = true;

        Iterator var6 = var1.iterator();

        DisplayMode var7;

        while (var6.hasNext()) {

          var7 = (DisplayMode)var6.next();

          if (var7.getBitsPerPixel() == 32 && var7.getWidth() == var4.getWidth() && var7.getHeight() == var4.getHeight()) {

            var5 = false;

            break;

          }

        }

        if (!var5) {

          var6 = var1.iterator();

          while (var6.hasNext()) {

            var7 = (DisplayMode)var6.next();

            if (var7.getBitsPerPixel() == 32 && var7.getWidth() == var4.getWidth() / 2 && var7.getHeight() == var4.getHeight() / 2) {

              var2 = var7;

              break;

            }

          }

        }

      }

    }

    Display.setDisplayMode(var2);

    this.displayWidth = var2.getWidth();

    this.displayHeight = var2.getHeight();

  }

  /**

   * Displays a new screen.

   */

  private void loadScreen() throws LWJGLException {

    ScaledResolution var1 = new ScaledResolution(this.gameSettings, this.displayWidth, this.displayHeight);

    GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);

    GL11.glMatrixMode(GL11.GL_PROJECTION);

    GL11.glLoadIdentity();

    GL11.glOrtho(0.0D, var1.getScaledWidth_double(), var1.getScaledHeight_double(), 0.0D, 1000.0D, 3000.0D);

    GL11.glMatrixMode(GL11.GL_MODELVIEW);

    GL11.glLoadIdentity();

    GL11.glTranslatef(0.0F, 0.0F, -2000.0F);

    GL11.glViewport(0, 0, this.displayWidth, this.displayHeight);

    GL11.glClearColor(0.0F, 0.0F, 0.0F, 0.0F);

    GL11.glDisable(GL11.GL_LIGHTING);

    GL11.glEnable(GL11.GL_TEXTURE_2D);

    GL11.glDisable(GL11.GL_FOG);

    Tessellator var2 = Tessellator.instance;

    this.renderEngine.bindTexture(locationMojangPng);

    var2.startDrawingQuads();

    var2.setColorOpaque_I(16777215);

    var2.addVertexWithUV(0.0D, (double)this.displayHeight, 0.0D, 0.0D, 0.0D);

    var2.addVertexWithUV((double)this.displayWidth, (double)this.displayHeight, 0.0D, 0.0D, 0.0D);

    var2.addVertexWithUV((double)this.displayWidth, 0.0D, 0.0D, 0.0D, 0.0D);

    var2.addVertexWithUV(0.0D, 0.0D, 0.0D, 0.0D, 0.0D);

    var2.draw();

    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);

    var2.setColorOpaque_I(16777215);

    short var3 = 256;

    short var4 = 256;

    this.scaledTessellator((var1.getScaledWidth() - var3) / 2, (var1.getScaledHeight() - var4) / 2, 0, 0, var3, var4);

    GL11.glDisable(GL11.GL_LIGHTING);

    GL11.glDisable(GL11.GL_FOG);

    GL11.glEnable(GL11.GL_ALPHA_TEST);

    GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);

    Display.update();

  }

  /**

   * Loads Tessellator with a scaled resolution

   */

  public void scaledTessellator(int par1, int par2, int par3, int par4, int par5, int par6) {

    float var7 = 0.00390625F;

    float var8 = 0.00390625F;

    Tessellator var9 = Tessellator.instance;

    var9.startDrawingQuads();

    var9.addVertexWithUV((double)(par1 + 0), (double)(par2 + par6), 0.0D, (double)((float)(par3 + 0) * var7), (double)((float)(par4 + par6) * var8));

    var9.addVertexWithUV((double)(par1 + par5), (double)(par2 + par6), 0.0D, (double)((float)(par3 + par5) * var7), (double)((float)(par4 + par6) * var8));

    var9.addVertexWithUV((double)(par1 + par5), (double)(par2 + 0), 0.0D, (double)((float)(par3 + par5) * var7), (double)((float)(par4 + 0) * var8));

    var9.addVertexWithUV((double)(par1 + 0), (double)(par2 + 0), 0.0D, (double)((float)(par3 + 0) * var7), (double)((float)(par4 + 0) * var8));

    var9.draw();

  }

  /**

   * Returns the save loader that is currently being used

   */

  public ISaveFormat getSaveLoader() {

    return this.saveLoader;

  }

  // Spout Start

  private GuiScreen previousScreen = null;

  // Spout End

  /**

   * Sets the argument GuiScreen as the main (topmost visible) screen.

   */

  // Spout Start

  public void displayGuiScreen(GuiScreen screen) {

    displayGuiScreen(screen, true);

  }

  public void displayGuiScreen(GuiScreen screen, boolean notify) {

    // Part of original function

    if (screen == null && this.theWorld == null) {

      screen = new org.spoutcraft.client.gui.mainmenu.MainMenu();

    } else if (screen == null && this.thePlayer.getHealth() <= 0.0F) {

      screen = new GuiGameOver();

    }

    ScreenType display = ScreenUtil.getType(screen);

    if (notify && thePlayer != null && theWorld != null) {

      // Screen closed

      SpoutPacket packet = null;

      Screen widget = null;

      if (this.currentScreen != null && screen == null) {

        packet = new PacketScreenAction(ScreenAction.Close, ScreenUtil.getType(this.currentScreen));

        widget = currentScreen.getScreen();

      }

      // Screen opened

      if (screen != null && this.currentScreen == null) {

        packet = new PacketScreenAction(ScreenAction.Open, display);

        widget = screen.getScreen();

      }

      // Screen swapped

      if (screen != null && this.currentScreen != null) { // Hopefully just a submenu

        packet = new PacketScreenAction(ScreenAction.Open, display);

        widget = screen.getScreen();

      }

      boolean cancel = false;

      if (!cancel && packet != null) {

        SpoutClient.getInstance().getPacketManager().sendSpoutPacket(packet);

        if (widget instanceof PopupScreen) {

          ((PopupScreen) widget).close();

        }

      }

      if (cancel) {

        return;

      }

    }

    // Spout End

    if (this.currentScreen != null) {

      this.currentScreen.onGuiClosed();

    }

    this.statFileWriter.syncStats();

    // Spout Start

    if (theWorld == null && thePlayer == null && this.ingameGUI != null) {

      // Spout End

      this.ingameGUI.getChatGUI().clearChatMessages();

    }

    // Spout Start

    if (previousScreen != null || screen != null) {

      previousScreen = this.currentScreen;

    }

    this.currentScreen = screen;

    if (screen != null) {

      // Spout End

      this.setIngameNotInFocus();

      ScaledResolution var2 = new ScaledResolution(this.gameSettings, this.displayWidth, this.displayHeight);

      int var3 = var2.getScaledWidth();

      int var4 = var2.getScaledHeight();

      // Spout Start

      screen.setWorldAndResolution(this, var3, var4);

      // Spout End

      this.skipRenderWorld = false;

    } else {

      this.setIngameFocus();

    }

  }

  // Spout Start

  public void displayPreviousScreen() {

    displayGuiScreen(previousScreen, false);

    previousScreen = null;

  }

  public void clearPreviousScreen() {

    previousScreen = null;

  }

  // Spout End

  /**

   * Checks for an OpenGL error. If there is one, prints the error ID and error string.

   */

  private void checkGLError(String par1Str) {

    int var2 = GL11.glGetError();

    if (var2 != 0) {

      // Spout Start

      if (!org.spoutcraft.client.gui.mainmenu.MainMenu.hasLoaded) {

        return;

      }

    }

  }

  /**

   * Shuts down the minecraft applet by stopping the resource downloads, and clearing up GL stuff; called when the

   * application (or web page) is exited.

   */

  public void shutdownMinecraftApplet() {

    // Spout Start

    if (shutdown) {

      return;

    }

    shutdown = true;

    // Spout End

    try {

      this.statFileWriter.syncStats();

      this.getLogAgent().logInfo("Stopping!");

      try {

        this.loadWorld((WorldClient)null);

      } catch (Throwable var7) {

        ;

      }

      try {

        GLAllocation.deleteTexturesAndDisplayLists();

      } catch (Throwable var6) {

        ;

      }

      this.sndManager.cleanup();     

    } finally {

      Display.destroy();

      if (!this.hasCrashed) {

        System.exit(0);

      }

    }

    System.gc();

  }

  public void run() {

    this.running = true;