/**
   * *************************************************************************************************************************************************************************************************
   * Initialization stuff comes in here...
   * ************************************************************************************************************************************************************************************************
   */
  private void init() {

    try {
      Display.setDisplayMode(new DisplayMode(640, 480));
      Display.setVSyncEnabled(true);
      Display.setTitle("MS3D Loader [G36C]");
      Display.create();

      Keyboard.create();

    } catch (LWJGLException e) {
      Sys.alert("Error", "Initialization failed!\n\n" + e.getMessage());
      System.exit(0);
    }

    /* OpenGL */
    int width = Display.getDisplayMode().getWidth();
    int height = Display.getDisplayMode().getHeight();

    GL11.glViewport(0, 0, width, height); // Reset The Current Viewport
    GL11.glMatrixMode(GL11.GL_PROJECTION); // Select The Projection Matrix
    GL11.glLoadIdentity(); // Reset The Projection Matrix
    GLU.gluPerspective(
        45.0f,
        ((float) width / (float) height),
        0.1f,
        1000.0f); // Calculate The Aspect Ratio Of The Window
    GL11.glMatrixMode(GL11.GL_MODELVIEW); // Select The Modelview Matrix
    GL11.glLoadIdentity(); // Reset The Modelview Matrix

    GL11.glEnable(GL11.GL_TEXTURE_2D);
    GL11.glShadeModel(GL11.GL_SMOOTH);
    GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Background color
    GL11.glClearDepth(1.0f);
    GL11.glEnable(GL11.GL_DEPTH_TEST);
    GL11.glDepthFunc(GL11.GL_LEQUAL);
    GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);

    // Load model
    //		g36c = new
    // MS3DModel(resourceLoader.loadResourceAsStream("models/gsg9.ms3d"),this.getClass().getResource("./data/textures").getPath());
    g36c =
        new MS3DModel(
            resourceLoader.loadResourceAsStream("models/assassin.ms3d"),
            this.getClass().getResource("./data/textures").getPath());

    //		tdsLoader=new TDSLoader();
    //		try {
    //			tdsLoader.load(resourceLoader.loadResourceAsStream("models/face.3ds"));
    //			System.out.println(tdsLoader.getObjectSize());
    //		} catch (IOException e) {
    //			e.printStackTrace();
    //		}

    // Load font
    font = new Font(resourceLoader.loadResourceAsStream("textures/font.bmp"), 12, width, height);

    // Init timer
    timer = new Timer();
  }
  public static void updateRenderInfo(EntityPlayer par0EntityPlayer, boolean par1) {
    GL11.glGetFloat(GL11.GL_MODELVIEW_MATRIX, modelview);
    GL11.glGetFloat(GL11.GL_PROJECTION_MATRIX, projection);

    // Spout start
    modelMatrix = modelview.duplicate();
    projectionMatrix = projection.duplicate();
    // Spout end

    GL11.glGetInteger(GL11.GL_VIEWPORT, viewport);
    float var2 = (float) ((viewport.get(0) + viewport.get(2)) / 2);
    float var3 = (float) ((viewport.get(1) + viewport.get(3)) / 2);
    GLU.gluUnProject(var2, var3, 0.0F, modelview, projection, viewport, objectCoords);
    objectX = objectCoords.get(0);
    objectY = objectCoords.get(1);
    objectZ = objectCoords.get(2);
    int var4 = par1 ? 1 : 0;
    float var5 = par0EntityPlayer.rotationPitch;
    float var6 = par0EntityPlayer.rotationYaw;
    rotationX = MathHelper.cos(var6 * (float) Math.PI / 180.0F) * (float) (1 - var4 * 2);
    rotationZ = MathHelper.sin(var6 * (float) Math.PI / 180.0F) * (float) (1 - var4 * 2);
    rotationYZ =
        -rotationZ * MathHelper.sin(var5 * (float) Math.PI / 180.0F) * (float) (1 - var4 * 2);
    rotationXY =
        rotationX * MathHelper.sin(var5 * (float) Math.PI / 180.0F) * (float) (1 - var4 * 2);
    rotationXZ = MathHelper.cos(var5 * (float) Math.PI / 180.0F);
  }
Esempio n. 3
0
  public void render() {
    lock.lock();

    quads = 0;
    draw_calls = 0;
    batch_draw_calls = 0;

    GL11.glLoadIdentity();
    GLU.gluLookAt(
        camera.pos.x,
        camera.pos.y,
        camera.pos.z,
        camera.pos.x + camera.look.x,
        camera.pos.y + camera.look.y,
        camera.pos.z + camera.look.z,
        camera.up.x,
        camera.up.y,
        camera.up.z);

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

    for (ChunkNode.Batch batch : batches) render_batch(batch);

    GL11.glFlush();

    lock.unlock();
  }
  private void setupShaders() {
    int errorCheckValue = GL11.glGetError();

    // Load the vertex shader
    vsId = this.loadShader("vertex.glsl", GL20.GL_VERTEX_SHADER);
    // Load the fragment shader
    fsId = this.loadShader("fragment.glsl", GL20.GL_FRAGMENT_SHADER);

    // Create a new shader program that links both shaders
    pId = GL20.glCreateProgram();
    GL20.glAttachShader(pId, vsId);
    GL20.glAttachShader(pId, fsId);

    // Position information will be attribute 0
    GL20.glBindAttribLocation(pId, 0, "in_Position");
    // Color information will be attribute 1
    GL20.glBindAttribLocation(pId, 1, "in_Color");

    GL20.glLinkProgram(pId);
    GL20.glValidateProgram(pId);

    errorCheckValue = GL11.glGetError();
    if (errorCheckValue != GL11.GL_NO_ERROR) {
      System.out.println(
          "ERROR - Could not create the shaders:" + GLU.gluErrorString(errorCheckValue));
      System.exit(-1);
    }
  }
Esempio n. 5
0
    /** Regenerates any dirty mimaps. */
    public void regenerateMipmaps() {
      if (mipmapDirty) {
        ByteBuffer data1 =
            BufferUtils.createByteBuffer(size.getWidth() * size.getHeight() * format.bytes);
        ByteBuffer data = data1;

        GL11.glBindTexture(GL11.GL_TEXTURE_2D, id);

        // read the texture out
        GL11.glGetTexImage(GL11.GL_TEXTURE_2D, 0, format.glFormat, GL11.GL_UNSIGNED_BYTE, data);

        data.rewind();

        // regenerate the mipmaps
        GLU.gluBuild2DMipmaps(
            GL11.GL_TEXTURE_2D,
            format.glInternalFormat,
            size.getWidth(),
            size.getHeight(),
            format.glFormat,
            GL11.GL_UNSIGNED_BYTE,
            data);

        mipmapDirty = false;
      }
    }
Esempio n. 6
0
  @Override
  public boolean gluUnProject(
      float winX,
      float winY,
      float winZ,
      float[] model,
      int modelOffset,
      float[] project,
      int projectOffset,
      int[] view,
      int viewOffset,
      float[] obj,
      int objOffset) {
    modelb.clear();
    modelb.put(model, modelOffset, 16);
    projectb.clear();
    projectb.put(project, projectOffset, 16);
    viewb.clear();
    viewb.put(view, viewOffset, 4);
    winb.clear();

    boolean result =
        org.lwjgl.util.glu.GLU.gluUnProject(winX, winY, winZ, modelb, projectb, viewb, winb);
    obj[objOffset] = winb.get(0);
    obj[objOffset + 1] = winb.get(1);
    obj[objOffset + 2] = winb.get(2);
    return result;
  }
 /**
  * Replaces the projection matrix by the one generated by the camera. The matrix mode will be
  * returned it its previous value. to GL_MODELVIEW.
  */
 public void applyPerspectiveMatrix() {
   int previousMatrixMode = glGetInteger(GL_MATRIX_MODE);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   GLU.gluPerspective(fov, aspectRatio, zNear, zFar);
   glMatrixMode(previousMatrixMode);
 }
Esempio n. 8
0
  /** Enters the Main-Loop */
  private void beginLoop() {
    this.isRunning = true;

    this.timing.init();
    while (this.isRunning) {
      int delta = this.timing.getDelta();

      this.handleDisplayResize();
      if (Display.isCloseRequested()) this.isRunning = false;

      // Mouse updates
      this.profiler.start("Mouse updates");
      this.mouseX = Mouse.getX();
      this.mouseY = this.height - Mouse.getY();

      if (!this.isGamePaused) {
        this.input.mousePos(this.mouseX, this.mouseY);
        if (Mouse.isButtonDown(0) && !this.lastButtonState)
          this.input.mouseClick(this.mouseX, this.mouseY);
        this.lastButtonState = Mouse.isButtonDown(0);
      }

      // Scrolling
      if (!this.isGamePaused) {
        int scroll = Mouse.getDWheel();
        if (scroll > 0) this.camera.zoom(-1);
        else if (scroll < 0) this.camera.zoom(1);
      }

      // Keyboard updates
      this.profiler.endStart("Keyboard updates");
      this.keyboardListener.update();

      // Audio
      this.profiler.endStart("Audio updates");
      this.soundEngine.update(delta);

      // Rendering
      this.profiler.endStart("Render game");
      this.camera.update(delta);
      this.renderer.render(this.camera, this.logic.getGameState(), delta);
      this.profiler.endStart("Render GUI");
      this.guiRenderer.render(this.width, this.height, this.mouseX, this.mouseY);
      this.profiler.end();

      Display.update();
      Display.sync(60);

      int error = glGetError();
      if (error != GL_NO_ERROR)
        System.out.println("GLError " + error + ": " + GLU.gluErrorString(error));

      this.timing.updateFPS();
    }

    this.soundEngine.dispose();
    Settings.saveSettings(this.settings);
    if (Display.isCreated()) Display.destroy();
  }
Esempio n. 9
0
  public static void checkGlError(String var0) {
    int var1 = GL11.glGetError();

    if (var1 != 0) {
      String var2 = GLU.gluErrorString(var1);
      dbg("OpenGlError: " + var1 + " (" + var2 + "), at: " + var0);
    }
  }
Esempio n. 10
0
  void setup_camera(float fov, float ratio, float view_distance) {
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glLoadIdentity();
    GLU.gluPerspective(fov, ratio, 0.01f, view_distance);
    GL11.glMatrixMode(GL11.GL_MODELVIEW);

    camera.set_attribs(fov, ratio, 0.01f, view_distance);
  }
Esempio n. 11
0
  public static Vec3 unproject(float winX, float winY, float winZ) {
    GLU.gluUnProject(winX, winY, winZ, modelview, projection, viewport, objectCoords);

    float objectX = objectCoords.get(0);
    float objectY = objectCoords.get(1);
    float objectZ = objectCoords.get(2);

    return Vec3.createVectorHelper(objectX, objectY, objectZ);
  }
Esempio n. 12
0
 private void checkGLError(String s) {
   int i = GL11.glGetError();
   if (i != 0) {
     String s1 = GLU.gluErrorString(i);
     System.out.println("########## GL ERROR ##########");
     System.out.println((new StringBuilder()).append("@ ").append(s).toString());
     System.out.println((new StringBuilder()).append(i).append(": ").append(s1).toString());
   }
 }
Esempio n. 13
0
  private void initGL() {
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // sets background to grey
    glClearDepth(1.0f); // clear depth buffer
    glEnable(GL_DEPTH_TEST); // Enables depth testing
    glDepthFunc(GL_LEQUAL); // sets the type of test to use for depth testing
    glMatrixMode(GL_PROJECTION); // sets the matrix mode to project

    // GLU.gluOrtho2D(-10, 10, -10, 10);
    // GLU.gluOrtho2D(0 - COORD_WIDTH / 2, 0 + COORD_WIDTH / 2, 0 - COORD_HEIGHT / 2, 0 +
    // COORD_HEIGHT / 2);
    float fovy = 90.0f;
    float aspect = DISPLAY_MODE.getWidth() / (float) DISPLAY_MODE.getHeight();
    float zNear = 0.1f;
    float zFar = 20000.0f;
    GLU.gluPerspective(fovy, aspect, zNear, zFar);

    glViewport(0, 0, DISPLAY_MODE.getWidth(), DISPLAY_MODE.getHeight());
    // GLU.gluOrtho2D(-10, 10, -10, 10);
    // GLU.gluOrtho2D(-1, 1, -1, 1);

    glOrtho(
        0 - COORD_WIDTH / 2,
        0 + COORD_WIDTH / 2,
        0 - COORD_HEIGHT / 2,
        0 + COORD_HEIGHT / 2,
        zNear,
        zFar);

    System.out.println(COORD_WIDTH + ", " + COORD_HEIGHT);

    glMatrixMode(GL_MODELVIEW);

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

    // ----------- Variables & method calls added for Lighting Test -----------//
    initLightArrays();
    glShadeModel(GL_SMOOTH);
    glMaterial(GL_FRONT, GL_SPECULAR, matSpecular); // sets specular material color
    glMaterialf(GL_FRONT, GL_SHININESS, 50.0f); // sets shininess

    glLight(GL_LIGHT0, GL_POSITION, lightPosition); // sets light position
    glLight(GL_LIGHT0, GL_SPECULAR, whiteLight); // sets specular light to white
    glLight(GL_LIGHT0, GL_DIFFUSE, whiteLight); // sets diffuse light to white
    glLightModel(GL_LIGHT_MODEL_AMBIENT, lModelAmbient); // global ambient light

    glEnable(GL_LIGHTING); // enables lighting
    glEnable(GL_LIGHT0); // enables light0

    glEnable(GL_COLOR_MATERIAL); // enables opengl to use glColor3f to define material color
    glColorMaterial(
        GL_FRONT,
        GL_AMBIENT_AND_DIFFUSE); // tell opengl glColor3f effects the ambient and diffuse properties
                                 // of material
    // ----------- END: Variables & method calls added for Lighting Test -----------//

  }
Esempio n. 14
0
 private static void doPicking() {
   IntBuffer buffer = ByteBuffer.allocateDirect(nextName).asIntBuffer();
   GL11.glSelectBuffer(buffer);
   GL11.glRenderMode(GL11.GL_SELECT);
   GL11.glMatrixMode(GL11.GL_PROJECTION);
   GL11.glPushMatrix();
   GL11.glLoadIdentity();
   GLU.gluPickMatrix(Mouse.getX(), Mouse.getY(), 4, 4, buffer);
   GL11.glRenderMode(GL11.GL_RENDER);
 }
  private FancyDial(TextureAtlasSprite icon, PropertiesFile properties) {
    this.icon = icon;
    this.properties = properties;
    name = IconAPI.getIconName(icon);
    x0 = IconAPI.getIconX0(icon);
    y0 = IconAPI.getIconY0(icon);
    width = IconAPI.getIconWidth(icon);
    height = IconAPI.getIconHeight(icon);
    scratchBuffer = ByteBuffer.allocateDirect(4 * width * height);

    int itemsTexture = TexturePackAPI.getTextureIfLoaded(TexturePackAPI.ITEMS_PNG);
    if (itemsTexture < 0) {
      logger.severe("could not get items texture");
      return;
    }
    itemsFBO = new FBO(itemsTexture, x0, y0, width, height);

    if (useScratchTexture) {
      logger.fine("rendering %s to %dx%d scratch texture", name, width, height);
      for (int i = 0; i < scratchFBO.length; i++) {
        scratchFBO[i] = new FBO(width, height);
      }
    } else {
      logger.fine("rendering %s directly to atlas", name);
    }

    boolean debug = false;
    for (int i = 0; ; i++) {
      Layer layer = newLayer(properties, "." + i);
      if (layer == null) {
        if (i > 0) {
          break;
        }
        continue;
      }
      layers.add(layer);
      debug |= layer.debug;
      logger.fine("  new %s", layer);
    }
    keyboard = new InputHandler(name, debug);
    if (layers.size() < 2) {
      logger.error("custom %s needs at least two layers defined", name);
      return;
    }

    outputFrames = properties.getInt("outputFrames", 0);

    int glError = GL11.glGetError();
    if (glError != 0) {
      logger.severe("%s during %s setup", GLU.gluErrorString(glError), name);
      return;
    }
    ok = true;
  }
Esempio n. 16
0
 public static void set() {
   GL11.glViewport(0, 0, HouseCalc.programFrame.getWidth(), HouseCalc.programFrame.getHeight());
   GL11.glMatrixMode(GL11.GL_PROJECTION);
   GL11.glLoadIdentity();
   float width = HouseCalc.programFrame.getWidth();
   float height = HouseCalc.programFrame.getHeight();
   GLU.gluPerspective(70, width / height, 0.1f, 600.0f);
   GL11.glMatrixMode(GL11.GL_MODELVIEW);
   GL11.glLoadIdentity();
   GLU.gluLookAt(
       (float) posx,
       (float) posy,
       (float) posz,
       (float) posx + dirx,
       (float) posy + diry,
       (float) posz + dirz,
       0,
       1,
       0);
   MatrixTools.multMatrix(matrix);
 }
Esempio n. 17
0
  @SubscribeEvent
  @SideOnly(Side.CLIENT)
  public void renderLast(RenderWorldLastEvent evt) {
    // TODO: while the urbanist is deactivated, this code can be dormant.
    // it happens to be very expensive at run time, so we need some way
    // to operate it only when relevant (e.g. in the cycle following a
    // click request).
    if (NONRELEASED_BLOCKS) {
      return;
    }

    /**
     * Note (SpaceToad): Why on earth this thing eventually worked out is a mystery to me. In
     * particular, all the examples I got computed y in a different way. Anyone with further OpenGL
     * understanding would be welcome to explain.
     *
     * <p>Anyway, the purpose of this code is to store the block position pointed by the mouse at
     * each frame, relative to the entity that has the camera.
     *
     * <p>It got heavily inspire from the two following sources:
     * http://nehe.gamedev.net/article/using_gluunproject/16013/ #ActiveRenderInfo.updateRenderInfo.
     *
     * <p>See EntityUrbanist#rayTraceMouse for a usage example.
     */
    if (modelviewF == null) {
      modelviewF = GLAllocation.createDirectFloatBuffer(16);
      projectionF = GLAllocation.createDirectFloatBuffer(16);
      viewport = GLAllocation.createDirectIntBuffer(16);
    }

    GL11.glGetFloat(GL11.GL_MODELVIEW_MATRIX, modelviewF);
    GL11.glGetFloat(GL11.GL_PROJECTION_MATRIX, projectionF);
    GL11.glGetInteger(GL11.GL_VIEWPORT, viewport);
    float f = (viewport.get(0) + viewport.get(2)) / 2;
    float f1 = (viewport.get(1) + viewport.get(3)) / 2;

    float x = Mouse.getX();
    float y = Mouse.getY();

    // TODO: Minecraft seems to instist to have this winZ re-created at
    // each frame - looks like a memory leak to me but I couldn't use a
    // static variable instead, as for the rest.
    FloatBuffer winZ = GLAllocation.createDirectFloatBuffer(1);
    GL11.glReadPixels((int) x, (int) y, 1, 1, GL11.GL_DEPTH_COMPONENT, GL11.GL_FLOAT, winZ);

    GLU.gluUnProject(x, y, winZ.get(), modelviewF, projectionF, viewport, pos);

    diffX = pos.get(0);
    diffY = pos.get(1);
    diffZ = pos.get(2);
  }
Esempio n. 18
0
 @Override
 public void gluLookAt(
     GL10 gl,
     float eyeX,
     float eyeY,
     float eyeZ,
     float centerX,
     float centerY,
     float centerZ,
     float upX,
     float upY,
     float upZ) {
   org.lwjgl.util.glu.GLU.gluLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);
 }
Esempio n. 19
0
  public Point2D[] project(
      int tube, float[] modelMatrix, float[] projectionMatrix, int[] viewport, int step) {
    GLU glu = new GLU();

    FloatBuffer modelbuf = BufferUtils.createFloatBuffer(16);
    modelbuf.put(modelMatrix);
    modelbuf.rewind();
    FloatBuffer projbuf = BufferUtils.createFloatBuffer(16);
    projbuf.put(projectionMatrix);
    projbuf.rewind();
    IntBuffer viewportbuf = BufferUtils.createIntBuffer(4);
    viewportbuf.put(viewport);
    viewportbuf.rewind();

    Point2D[] projectedSegments =
        new Point2D[(int) Math.ceil(tubes[tube].segments.length / (double) step)];

    int cnt = 0;
    for (int j = 0; j < tubes[tube].segments.length; j = j + step) {
      FloatBuffer result = BufferUtils.createFloatBuffer(3);

      glu.gluProject(
          tubes[tube].segments[j].x,
          tubes[tube].segments[j].y,
          tubes[tube].segments[j].z,
          modelbuf,
          projbuf,
          viewportbuf,
          result);

      Point2D p = new Point2D.Double(result.get(0), viewport[3] - result.get(1) - 1);

      projectedSegments[cnt++] = p;
    }

    return projectedSegments;
  }
Esempio n. 20
0
  /** Initialisation de la fenêtre OpenGl, de la camera et des textures. */
  public final void initGL() {
    // Création de la fenetre
    try {
      if (Setting.getFullScreen()) {
        Display.setDisplayModeAndFullscreen(
            new DisplayMode(Setting.get3DWidth(), Setting.get3DHeight()));
      } else {
        Display.setDisplayMode(new DisplayMode(Setting.get3DWidth(), Setting.get3DHeight()));
      }

      Display.setTitle("Visualisation 3D");
      Display.sync(Setting.getFps());
      Display.create();

    } catch (LWJGLException e) {
      e.printStackTrace();
      System.exit(0);
    }

    float fAspect = (float) Setting.getWWidth() / (float) Setting.getWHeight();
    GL11.glViewport(0, 0, Setting.getWWidth(), Setting.getWHeight());
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glLoadIdentity();
    GLU.gluPerspective(45.0f, fAspect, 1.0f, 1000.0f);
    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glLoadIdentity();
    GL11.glEnable(GL11.GL_DEPTH_TEST);
    GL11.glDepthFunc(GL11.GL_LEQUAL);
    GL11.glShadeModel(GL11.GL_SMOOTH);
    GL11.glEnable(GL11.GL_CULL_FACE);

    // Initialisation de la Camera
    camera = new Camera("3D");
    camera.init();
    camera.yaw(140.0f);
    camera.pitch(20.0f);

    // Récupération des textures
    textures = new Textures();
    textures.init();
    textures.loadTexture();

    wind = new Wind();

    matrice.loadImg();
  }
Esempio n. 21
0
 private void doEye() {
   int mouseX = Mouse.getX();
   int mouseY = Mouse.getY();
   FloatBuffer modelview = BufferUtils.createFloatBuffer(16);
   GL11.glGetFloat(GL11.GL_MODELVIEW_MATRIX, modelview);
   FloatBuffer projection = BufferUtils.createFloatBuffer(16);
   GL11.glGetFloat(GL11.GL_PROJECTION_MATRIX, projection);
   IntBuffer viewport = BufferUtils.createIntBuffer(16);
   GL11.glGetInteger(GL11.GL_VIEWPORT, viewport);
   float winX = mouseX;
   float winY = viewport.get(3) - mouseY;
   FloatBuffer winZBuffer = BufferUtils.createFloatBuffer(1);
   GL11.glReadPixels(mouseX, mouseY, 1, 1, GL11.GL_DEPTH_COMPONENT, GL11.GL_FLOAT, winZBuffer);
   float winZ = winZBuffer.get(0);
   FloatBuffer pos = BufferUtils.createFloatBuffer(3);
   GLU.gluUnProject(winX, winY, winZ, modelview, projection, viewport, pos);
   mEyeRay = new Point3f(pos.get(0), pos.get(1), pos.get(2));
 }
Esempio n. 22
0
    private void recreate() {
      id = GL11.glGenTextures();

      GL11.glBindTexture(GL11.GL_TEXTURE_2D, id);

      GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, format.bytes);

      ByteBuffer data =
          BufferUtils.createByteBuffer(size.getWidth() * size.getHeight() * format.bytes);

      if (mipmap) {
        GLU.gluBuild2DMipmaps(
            GL11.GL_TEXTURE_2D,
            format.glInternalFormat,
            size.getWidth(),
            size.getHeight(),
            format.glFormat,
            GL11.GL_UNSIGNED_BYTE,
            data);
      } else {
        GL11.glTexImage2D(
            GL11.GL_TEXTURE_2D,
            0,
            format.glInternalFormat,
            size.getWidth(),
            size.getHeight(),
            0,
            format.glFormat,
            GL11.GL_UNSIGNED_BYTE,
            data);
      }
      GLUtil.checkGLError();

      for (Texture t : residentTextures) {
        RectanglePacker.Rectangle rpr = packer.findRectangle(t.getSourceImage());

        if (rpr != null) {
          writeToTexture(rpr, t.getSourceImage().getData());
        }
      }

      regenerateMipmaps();
    }
Esempio n. 23
0
  @Override
  public void draw() {
    GL11.glClearColor(0.8f, 0.8f, 0.8f, 0.0f);

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

    GL11.glLoadIdentity();
    GLU.gluLookAt(5.0f, 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
    GL11.glRotatef(rot, 0.0f, 1.0f, 0.0f);
    GL11.glRotatef(rot2, 1.0f, 0.0f, 0.0f);
    drawer.draw();

    Keyboard.poll();

    while (Keyboard.next()) {
      if (Keyboard.getEventKeyState()) {
        if (Keyboard.getEventKey() == Keyboard.KEY_ESCAPE) {
          return;
        }
        if (Keyboard.getEventKey() == Keyboard.KEY_RIGHT) {
          rot -= 15.0f;
        }
        if (Keyboard.getEventKey() == Keyboard.KEY_LEFT) {
          rot += 15.0f;
        }
        if (Keyboard.getEventKey() == Keyboard.KEY_UP) {
          rot2 -= 15.0f;
        }
        if (Keyboard.getEventKey() == Keyboard.KEY_DOWN) {
          rot2 += 15.0f;
        }

        if (Keyboard.getEventKey() == Keyboard.KEY_T) {
          if (renderMode == GL11.GL_POLYGON) {
            renderMode = GL11.GL_LINE_LOOP;
          } else {
            renderMode = GL11.GL_POLYGON;
          }
        }
      }
    }
  }
  /** Generates the specified number of display lists and returns the first index. */
  public static synchronized int generateDisplayLists(int range) {
    int i = GlStateManager.glGenLists(range);

    if (i == 0) {
      int j = GlStateManager.glGetError();
      String s = "No error code reported";

      if (j != 0) {
        s = GLU.gluErrorString(j);
      }

      throw new IllegalStateException(
          "glGenLists returned an ID of 0 for a count of "
              + range
              + ", GL error ("
              + j
              + "): "
              + s);
    } else {
      return i;
    }
  }
Esempio n. 25
0
  // ***************************************************************************
  // initGL
  // ***************************************************************************
  private static boolean initGL() {
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glLoadIdentity();

    // Calculate the aspect ratio of the window
    GLU.gluPerspective(45.0f, ((float) targetWidth) / ((float) targetHeight), 0.1f, 100.0f);

    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glLoadIdentity();

    GL11.glEnable(GL11.GL_TEXTURE_2D);

    // Enable Texture Mapping (NEW)
    GL11.glShadeModel(GL11.GL_SMOOTH);
    GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    GL11.glClearDepth(1.0f);
    GL11.glEnable(GL11.GL_DEPTH_TEST);
    GL11.glDepthFunc(GL11.GL_LEQUAL);
    GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);

    return true;
  }
Esempio n. 26
0
  public static void init(VorxelSettings set, Geode gamep) {
    world = new World();
    game = gamep;
    try {
      DisplayMode d[] = Display.getAvailableDisplayModes();
      DisplayMode displayMode = d[0];
      Display.setDisplayMode(displayMode);
      Display.create();

      Mouse.create();
      Keyboard.create();

      GL11.glEnable(GL11.GL_TEXTURE_2D); // Enable Texture Mapping
      GL11.glShadeModel(GL11.GL_SMOOTH); // Enable Smooth Shading
      GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black Background
      GL11.glClearDepth(1.0); // Depth Buffer Setup
      GL11.glEnable(GL11.GL_DEPTH_TEST); // Enables Depth Testing
      GL11.glDepthFunc(GL11.GL_LEQUAL); // The Type Of Depth Testing To Do

      GL11.glMatrixMode(GL11.GL_PROJECTION); // Select The Projection Matrix
      GL11.glLoadIdentity(); // Reset The Projection Matrix
      // Calculate The Aspect Ratio Of The Window
      GLU.gluPerspective(
          45.0f, (float) displayMode.getWidth() / (float) displayMode.getHeight(), 0.1f, 100.0f);
      GL11.glMatrixMode(GL11.GL_MODELVIEW); // Select The Modelview Matrix

      // Really Nice Perspective Calculations
      GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
      TextureHelper.init();
      Cube.dirt.texture = new VTex(4);
      Cube.grass.texture = Cube.dirt.texture;
      Cube.grass.toptexture = new VTex(1);
      Mouse.setGrabbed(true);
      world.createSpawn();
    } catch (LWJGLException e) {
      e.printStackTrace();
    }
  }
Esempio n. 27
0
  public static int loadImage(BufferedImage bufferedImage) {
    try {
      short width = (short) bufferedImage.getWidth();
      short height = (short) bufferedImage.getHeight();
      // textureLoader.bpp = bufferedImage.getColorModel().hasAlpha() ? (byte)32 : (byte)24;
      int bpp = (byte) bufferedImage.getColorModel().getPixelSize();
      ByteBuffer byteBuffer;
      DataBuffer db = bufferedImage.getData().getDataBuffer();
      if (db instanceof DataBufferInt) {
        int intI[] = ((DataBufferInt) (bufferedImage.getData().getDataBuffer())).getData();
        byte newI[] = new byte[intI.length * 4];
        for (int i = 0; i < intI.length; i++) {
          byte b[] = intToByteArray(intI[i]);
          int newIndex = i * 4;

          newI[newIndex] = b[1];
          newI[newIndex + 1] = b[2];
          newI[newIndex + 2] = b[3];
          newI[newIndex + 3] = b[0];
        }

        byteBuffer =
            ByteBuffer.allocateDirect(width * height * (bpp / 8))
                .order(ByteOrder.nativeOrder())
                .put(newI);
      } else {
        byteBuffer =
            ByteBuffer.allocateDirect(width * height * (bpp / 8))
                .order(ByteOrder.nativeOrder())
                .put(((DataBufferByte) (bufferedImage.getData().getDataBuffer())).getData());
      }
      byteBuffer.flip();

      int internalFormat = GL11.GL_RGBA8, format = GL11.GL_RGBA;
      IntBuffer textureId = BufferUtils.createIntBuffer(1);
      ;
      GL11.glGenTextures(textureId);
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureId.get(0));

      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP);
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP);

      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);

      GL11.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_MODULATE);

      GLU.gluBuild2DMipmaps(
          GL11.GL_TEXTURE_2D,
          internalFormat,
          width,
          height,
          format,
          GL11.GL_UNSIGNED_BYTE,
          byteBuffer);
      return textureId.get(0);

    } catch (Exception e) {
      e.printStackTrace();
      System.exit(-1);
    }

    return -1;
  }
Esempio n. 28
0
  public void display() {
    GL11.glViewport(0, 0, width, height);
    GL11.glClearColor(0.5f, 0.5f, 0.5f, 0.1f);

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

    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glLoadIdentity();
    float widthHeightRatio = width / height;
    GLU.gluPerspective(45, widthHeightRatio, 1, 1000);
    GLU.gluLookAt(
        player.getX(),
        player.getY(),
        player.getZ(),
        player.getCamX(),
        player.getCamY(),
        player.getCamZ(),
        0,
        1,
        0);
    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glLoadIdentity();
    // Level

    GL11.glDepthFunc(GL11.GL_LEQUAL);
    GL11.glEnable(GL11.GL_DEPTH_TEST);

    for (byte i = 0; i < level.getSizeX(); i += 1) {
      for (byte j = 0; j < level.getSizeY(); j += 1) {
        for (byte k = 0; k < level.getSizeZ(); k += 1) {
          if (level.getCubeName(i, j, k).equals(Cube.CUBE_BOMB)) {
            objects.DrawCubeBomb(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_EXPLOSION)) {
            objects.DrawCubeExplosion(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_EXPLOSION_HIDE_EXIT)) {
            objects.DrawCubeExplosion(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_EXPLOSION_HIDE_ITEM)) {
            objects.DrawCubeExplosion(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_ITEM_HEALTH)) {
            objects.DrawCubeItemHealth(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_ITEM_XTRA_BOMB)) {
            objects.DrawCubeItemXtraBomb(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_ITEM_BOMB_RANGE)) {
            objects.DrawCubeItemBombRange(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_ITEM_BOMB_STRENGTH)) {
            objects.DrawCubeItemBombStrength(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_ITEM_PORTAL)) {
            objects.DrawCubeItemPortal(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_ITEM_DOUBLE_SCORE)) {
            objects.DrawCubeItemDoubleScore(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_SOLID)) {
            objects.DrawCubeSolid(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_OUTSIDE)) {
            objects.DrawCubeOutside(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_OBSTACLE)) {
            objects.DrawCubeObstacle(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_OBSTACLE_HIDE_EXIT)) {
            objects.DrawCubeObstacle(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_EXIT)) {
            objects.DrawCubeExit(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.CUBE_SOLID_RAMP)) {
            objects.DrawCubeRamp(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
            // Menüwürfel
          } else if (level.getCubeName(i, j, k).equals(Cube.MENU_CUBE_NEW_GAME)) {
            objects.DrawMenuCubeNewGame(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.MENU_CUBE_NEW_GAME_GRAVITY)) {
            objects.DrawMenuCubeNewGameGravity(
                i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.MENU_CUBE_EXIT_PROGRAM)) {
            objects.DrawMenuCubeExitProgram(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.MENU_CUBE_MULTI)) {
            objects.DrawMenuCubeMulti(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.MENU_CUBE_SERVER)) {
            objects.DrawMenuCubeServer(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.MENU_CUBE_OPTIONS)) {
            objects.DrawMenuCubeOptions(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          } else if (level.getCubeName(i, j, k).equals(Cube.MENU_CUBE_LOAD_LEVEL)) {
            objects.DrawMenuCubeLoadLevel(i * SIZE_OF_CUBE, j * SIZE_OF_CUBE, k * SIZE_OF_CUBE);
          }
        }
      }
    }
    if (listPlayer != null) {
      for (int i = 0; i < listPlayer.size(); i++) {
        if (listPlayer.get(i).getNumber() != player.getNumber()) {
          objects.DrawPlayer(
              listPlayer.get(i).getX() - (SIZE_OF_CUBE / 2),
              listPlayer.get(i).getY() - (SIZE_OF_CUBE / 2),
              listPlayer.get(i).getZ() - (SIZE_OF_CUBE / 2));
        }
      }
    }

    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glLoadIdentity();

    // GL11.glOrtho(-CLIPSIZE, +CLIPSIZE, -CLIPSIZE, +CLIPSIZE, -CLIPSIZE *
    // 100.0f, +CLIPSIZE * 100.0f);
    // GL11.glOrtho(-CLIPSIZE, +CLIPSIZE, -CLIPSIZE, +CLIPSIZE, -CLIPSIZE,
    // +CLIPSIZE);
    GL11.glOrtho(
        -Window.width / 2,
        +Window.width / 2,
        -Window.height / 2,
        +Window.height / 2,
        -CLIPSIZE,
        +CLIPSIZE);

    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glLoadIdentity();
    // GL11.glTranslatef(1f, 1f, 0.0f);

    GL11.glDisable(GL11.GL_DEPTH_TEST);

    hud.renderHUD();

    GL11.glFlush();
  }
  /** Draws the main menu panorama */
  private void drawPanorama(int par1, int par2, float par3) {
    Tessellator var4 = Tessellator.instance;
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    GLU.gluPerspective(120.0F, 1.0F, 0.05F, 10.0F);
    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    GL11.glRotatef(180.0F, 1.0F, 0.0F, 0.0F);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glDisable(GL11.GL_ALPHA_TEST);
    GL11.glDisable(GL11.GL_CULL_FACE);
    GL11.glDepthMask(false);
    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    byte var5 = 8;

    for (int var6 = 0; var6 < var5 * var5; ++var6) {
      GL11.glPushMatrix();
      float var7 = ((float) (var6 % var5) / (float) var5 - 0.5F) / 64.0F;
      float var8 = ((float) (var6 / var5) / (float) var5 - 0.5F) / 64.0F;
      float var9 = 0.0F;
      GL11.glTranslatef(var7, var8, var9);
      GL11.glRotatef(
          MathHelper.sin(((float) this.panoramaTimer + par3) / 400.0F) * 25.0F + 20.0F,
          1.0F,
          0.0F,
          0.0F);
      GL11.glRotatef(-((float) this.panoramaTimer + par3) * 0.1F, 0.0F, 1.0F, 0.0F);

      for (int var10 = 0; var10 < 6; ++var10) {
        GL11.glPushMatrix();

        if (var10 == 1) {
          GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
        }

        if (var10 == 2) {
          GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F);
        }

        if (var10 == 3) {
          GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F);
        }

        if (var10 == 4) {
          GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F);
        }

        if (var10 == 5) {
          GL11.glRotatef(-90.0F, 1.0F, 0.0F, 0.0F);
        }

        this.mc.renderEngine.func_98187_b(titlePanoramaPaths[var10]);
        var4.startDrawingQuads();
        var4.setColorRGBA_I(16777215, 255 / (var6 + 1));
        float var11 = 0.0F;
        var4.addVertexWithUV(-1.0D, -1.0D, 1.0D, (double) (0.0F + var11), (double) (0.0F + var11));
        var4.addVertexWithUV(1.0D, -1.0D, 1.0D, (double) (1.0F - var11), (double) (0.0F + var11));
        var4.addVertexWithUV(1.0D, 1.0D, 1.0D, (double) (1.0F - var11), (double) (1.0F - var11));
        var4.addVertexWithUV(-1.0D, 1.0D, 1.0D, (double) (0.0F + var11), (double) (1.0F - var11));
        var4.draw();
        GL11.glPopMatrix();
      }

      GL11.glPopMatrix();
      GL11.glColorMask(true, true, true, false);
    }

    var4.setTranslation(0.0D, 0.0D, 0.0D);
    GL11.glColorMask(true, true, true, true);
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glPopMatrix();
    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glPopMatrix();
    GL11.glDepthMask(true);
    GL11.glEnable(GL11.GL_CULL_FACE);
    GL11.glEnable(GL11.GL_ALPHA_TEST);
    GL11.glEnable(GL11.GL_DEPTH_TEST);
  }
Esempio n. 30
0
  protected void func_74185_a(float p_74185_1_, int p_74185_2_, int p_74185_3_) {
    int var4 = this.field_73882_e.field_71446_o.func_78341_b("/gui/enchant.png");
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    this.field_73882_e.field_71446_o.func_78342_b(var4);
    int var5 = (this.field_73880_f - this.field_74194_b) / 2;
    int var6 = (this.field_73881_g - this.field_74195_c) / 2;
    this.func_73729_b(var5, var6, 0, 0, this.field_74194_b, this.field_74195_c);
    GL11.glPushMatrix();
    GL11.glMatrixMode(5889);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    ScaledResolution var7 =
        new ScaledResolution(
            this.field_73882_e.field_71474_y,
            this.field_73882_e.field_71443_c,
            this.field_73882_e.field_71440_d);
    GL11.glViewport(
        (var7.func_78326_a() - 320) / 2 * var7.func_78325_e(),
        (var7.func_78328_b() - 240) / 2 * var7.func_78325_e(),
        320 * var7.func_78325_e(),
        240 * var7.func_78325_e());
    GL11.glTranslatef(-0.34F, 0.23F, 0.0F);
    GLU.gluPerspective(90.0F, 1.3333334F, 9.0F, 80.0F);
    float var8 = 1.0F;
    GL11.glMatrixMode(5888);
    GL11.glLoadIdentity();
    RenderHelper.func_74519_b();
    GL11.glTranslatef(0.0F, 3.3F, -16.0F);
    GL11.glScalef(var8, var8, var8);
    float var9 = 5.0F;
    GL11.glScalef(var9, var9, var9);
    GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F);
    this.field_73882_e.field_71446_o.func_78342_b(
        this.field_73882_e.field_71446_o.func_78341_b("/item/book.png"));
    GL11.glRotatef(20.0F, 1.0F, 0.0F, 0.0F);
    float var10 = this.field_74208_u + (this.field_74209_t - this.field_74208_u) * p_74185_1_;
    GL11.glTranslatef((1.0F - var10) * 0.2F, (1.0F - var10) * 0.1F, (1.0F - var10) * 0.25F);
    GL11.glRotatef(-(1.0F - var10) * 90.0F - 90.0F, 0.0F, 1.0F, 0.0F);
    GL11.glRotatef(180.0F, 1.0F, 0.0F, 0.0F);
    float var11 =
        this.field_74212_q + (this.field_74213_p - this.field_74212_q) * p_74185_1_ + 0.25F;
    float var12 =
        this.field_74212_q + (this.field_74213_p - this.field_74212_q) * p_74185_1_ + 0.75F;
    var11 = (var11 - (float) MathHelper.func_76140_b((double) var11)) * 1.6F - 0.3F;
    var12 = (var12 - (float) MathHelper.func_76140_b((double) var12)) * 1.6F - 0.3F;
    if (var11 < 0.0F) {
      var11 = 0.0F;
    }

    if (var12 < 0.0F) {
      var12 = 0.0F;
    }

    if (var11 > 1.0F) {
      var11 = 1.0F;
    }

    if (var12 > 1.0F) {
      var12 = 1.0F;
    }

    GL11.glEnable('\u803a');
    field_74206_w.func_78088_a((Entity) null, 0.0F, var11, var12, var10, 0.0F, 0.0625F);
    GL11.glDisable('\u803a');
    RenderHelper.func_74518_a();
    GL11.glMatrixMode(5889);
    GL11.glViewport(0, 0, this.field_73882_e.field_71443_c, this.field_73882_e.field_71440_d);
    GL11.glPopMatrix();
    GL11.glMatrixMode(5888);
    GL11.glPopMatrix();
    RenderHelper.func_74518_a();
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    this.field_73882_e.field_71446_o.func_78342_b(var4);
    EnchantmentNameParts.field_78061_a.func_78058_a(this.field_74215_y.field_75166_f);

    for (int var13 = 0; var13 < 3; ++var13) {
      String var14 = EnchantmentNameParts.field_78061_a.func_78057_a();
      this.field_73735_i = 0.0F;
      this.field_73882_e.field_71446_o.func_78342_b(var4);
      int var15 = this.field_74215_y.field_75167_g[var13];
      GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
      if (var15 == 0) {
        this.func_73729_b(var5 + 60, var6 + 14 + 19 * var13, 0, 185, 108, 19);
      } else {
        String var16 = "" + var15;
        FontRenderer var17 = this.field_73882_e.field_71464_q;
        int var18 = 6839882;
        if (this.field_73882_e.field_71439_g.field_71068_ca < var15
            && !this.field_73882_e.field_71439_g.field_71075_bZ.field_75098_d) {
          this.func_73729_b(var5 + 60, var6 + 14 + 19 * var13, 0, 185, 108, 19);
          var17.func_78279_b(
              var14, var5 + 62, var6 + 16 + 19 * var13, 104, (var18 & 16711422) >> 1);
          var17 = this.field_73882_e.field_71466_p;
          var18 = 4226832;
          var17.func_78261_a(
              var16,
              var5 + 62 + 104 - var17.func_78256_a(var16),
              var6 + 16 + 19 * var13 + 7,
              var18);
        } else {
          int var19 = p_74185_2_ - (var5 + 60);
          int var20 = p_74185_3_ - (var6 + 14 + 19 * var13);
          if (var19 >= 0 && var20 >= 0 && var19 < 108 && var20 < 19) {
            this.func_73729_b(var5 + 60, var6 + 14 + 19 * var13, 0, 204, 108, 19);
            var18 = 16777088;
          } else {
            this.func_73729_b(var5 + 60, var6 + 14 + 19 * var13, 0, 166, 108, 19);
          }

          var17.func_78279_b(var14, var5 + 62, var6 + 16 + 19 * var13, 104, var18);
          var17 = this.field_73882_e.field_71466_p;
          var18 = 8453920;
          var17.func_78261_a(
              var16,
              var5 + 62 + 104 - var17.func_78256_a(var16),
              var6 + 16 + 19 * var13 + 7,
              var18);
        }
      }
    }
  }