Ejemplo n.º 1
0
  private void func_73968_a(float p_73968_1_) {
    this.field_73882_e.func_110434_K().func_110577_a(this.field_110351_G);
    GL11.glCopyTexSubImage2D(3553, 0, 0, 0, 0, 0, 256, 256);
    GL11.glEnable(3042);
    GL11.glBlendFunc(770, 771);
    GL11.glColorMask(true, true, true, false);
    Tessellator var2 = Tessellator.field_78398_a;
    var2.func_78382_b();
    byte var3 = 3;

    for (int var4 = 0; var4 < var3; ++var4) {
      var2.func_78369_a(1.0F, 1.0F, 1.0F, 1.0F / (float) (var4 + 1));
      int var5 = this.field_73880_f;
      int var6 = this.field_73881_g;
      float var7 = (float) (var4 - var3 / 2) / 256.0F;
      var2.func_78374_a(
          (double) var5, (double) var6, (double) this.field_73735_i, (double) (0.0F + var7), 0.0D);
      var2.func_78374_a(
          (double) var5, 0.0D, (double) this.field_73735_i, (double) (1.0F + var7), 0.0D);
      var2.func_78374_a(0.0D, 0.0D, (double) this.field_73735_i, (double) (1.0F + var7), 1.0D);
      var2.func_78374_a(
          0.0D, (double) var6, (double) this.field_73735_i, (double) (0.0F + var7), 1.0D);
    }

    var2.func_78381_a();
    GL11.glColorMask(true, true, true, true);
  }
Ejemplo n.º 2
0
  /** Rotate and blurs the skybox view in the main menu */
  private void rotateAndBlurSkybox(float p_73968_1_) {
    this.mc.getTextureManager().bindTexture(this.field_110351_G);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
    GL11.glCopyTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, 0, 0, 256, 256);
    GL11.glEnable(GL11.GL_BLEND);
    OpenGlHelper.glBlendFunc(770, 771, 1, 0);
    GL11.glColorMask(true, true, true, false);
    Tessellator var2 = Tessellator.instance;
    var2.startDrawingQuads();
    GL11.glDisable(GL11.GL_ALPHA_TEST);
    byte var3 = 3;

    for (int var4 = 0; var4 < var3; ++var4) {
      var2.setColorRGBA_F(1.0F, 1.0F, 1.0F, 1.0F / (float) (var4 + 1));
      int var5 = this.width;
      int var6 = this.height;
      float var7 = (float) (var4 - var3 / 2) / 256.0F;
      var2.addVertexWithUV(
          (double) var5, (double) var6, (double) this.zLevel, (double) (0.0F + var7), 1.0D);
      var2.addVertexWithUV((double) var5, 0.0D, (double) this.zLevel, (double) (1.0F + var7), 1.0D);
      var2.addVertexWithUV(0.0D, 0.0D, (double) this.zLevel, (double) (1.0F + var7), 0.0D);
      var2.addVertexWithUV(0.0D, (double) var6, (double) this.zLevel, (double) (0.0F + var7), 0.0D);
    }

    var2.draw();
    GL11.glEnable(GL11.GL_ALPHA_TEST);
    GL11.glColorMask(true, true, true, true);
  }
  /** Rotate and blurs the skybox view in the main menu */
  private void rotateAndBlurSkybox(float par1) {
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.viewportTexture);
    this.mc.renderEngine.func_98185_a();
    GL11.glCopyTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, 0, 0, 256, 256);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    GL11.glColorMask(true, true, true, false);
    Tessellator var2 = Tessellator.instance;
    var2.startDrawingQuads();
    byte var3 = 3;

    for (int var4 = 0; var4 < var3; ++var4) {
      var2.setColorRGBA_F(1.0F, 1.0F, 1.0F, 1.0F / (float) (var4 + 1));
      int var5 = this.width;
      int var6 = this.height;
      float var7 = (float) (var4 - var3 / 2) / 256.0F;
      var2.addVertexWithUV(
          (double) var5, (double) var6, (double) this.zLevel, (double) (0.0F + var7), 0.0D);
      var2.addVertexWithUV((double) var5, 0.0D, (double) this.zLevel, (double) (1.0F + var7), 0.0D);
      var2.addVertexWithUV(0.0D, 0.0D, (double) this.zLevel, (double) (1.0F + var7), 1.0D);
      var2.addVertexWithUV(0.0D, (double) var6, (double) this.zLevel, (double) (0.0F + var7), 1.0D);
    }

    var2.draw();
    GL11.glColorMask(true, true, true, true);
    this.mc.renderEngine.func_98185_a();
  }
  /** Rotate and blurs the skybox view in the main menu */
  private void rotateAndBlurSkybox(float par1) {
    this.mc.getTextureManager().bindTexture(this.field_110351_G);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
    GL11.glCopyTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, 0, 0, 256, 256);
    GL11.glEnable(GL11.GL_BLEND);
    OpenGlHelper.glBlendFunc(770, 771, 1, 0);
    GL11.glColorMask(true, true, true, false);
    Tessellator tessellator = Tessellator.instance;
    tessellator.startDrawingQuads();
    GL11.glDisable(GL11.GL_ALPHA_TEST);
    byte b0 = 3;

    for (int i = 0; i < b0; ++i) {
      tessellator.setColorRGBA_F(1.0F, 1.0F, 1.0F, 1.0F / (float) (i + 1));
      int j = this.width;
      int k = this.height;
      float f1 = (float) (i - b0 / 2) / 256.0F;
      tessellator.addVertexWithUV(
          (double) j, (double) k, (double) this.zLevel, (double) (0.0F + f1), 1.0D);
      tessellator.addVertexWithUV(
          (double) j, 0.0D, (double) this.zLevel, (double) (1.0F + f1), 1.0D);
      tessellator.addVertexWithUV(0.0D, 0.0D, (double) this.zLevel, (double) (1.0F + f1), 0.0D);
      tessellator.addVertexWithUV(
          0.0D, (double) k, (double) this.zLevel, (double) (0.0F + f1), 0.0D);
    }

    tessellator.draw();
    GL11.glEnable(GL11.GL_ALPHA_TEST);
    GL11.glColorMask(true, true, true, true);
  }
Ejemplo n.º 5
0
 private void rotateAndBlurSkybox() {
   this.mc.getTextureManager().bindTexture(GuiStarBackground.backgroundTexture);
   GL11.glEnable(GL11.GL_BLEND);
   GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
   GL11.glColorMask(true, true, true, false);
   GL11.glPushMatrix();
   GL11.glPopMatrix();
   GL11.glColorMask(true, true, true, true);
 }
Ejemplo n.º 6
0
  public void clearBuffers(boolean color, boolean depth, boolean stencil) {
    int bits = 0;
    if (color) {
      // See explanations of the depth below, we must enable color write to be able to clear the
      // color buffer
      if (context.colorWriteEnabled == false) {
        glColorMask(true, true, true, true);
        context.colorWriteEnabled = true;
      }
      bits = GL_COLOR_BUFFER_BIT;
    }
    if (depth) {

      // glClear(GL_DEPTH_BUFFER_BIT) seems to not work when glDepthMask is false
      // here s some link on openl board
      // http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=257223
      // if depth clear is requested, we enable the depthMask
      if (context.depthWriteEnabled == false) {
        glDepthMask(true);
        context.depthWriteEnabled = true;
      }
      bits |= GL_DEPTH_BUFFER_BIT;
    }
    if (stencil) {
      bits |= GL_STENCIL_BUFFER_BIT;
    }
    if (bits != 0) {
      glClear(bits);
    }
  }
  private void a(float paramFloat) {
    GL11.glBindTexture(3553, this.n);
    GL11.glCopyTexSubImage2D(3553, 0, 0, 0, 0, 0, 256, 256);

    GL11.glEnable(3042);
    GL11.glBlendFunc(770, 771);
    GL11.glColorMask(true, true, true, false);
    avd localavd = avd.a;
    localavd.b();

    int i = 3;
    for (int j = 0; j < i; j++) {
      localavd.a(1.0F, 1.0F, 1.0F, 1.0F / (j + 1));
      int k = this.f;
      int i1 = this.g;
      float f = (j - i / 2) / 256.0F;
      localavd.a(k, i1, this.i, 0.0F + f, 0.0D);
      localavd.a(k, 0.0D, this.i, 1.0F + f, 0.0D);
      localavd.a(0.0D, 0.0D, this.i, 1.0F + f, 1.0D);
      localavd.a(0.0D, i1, this.i, 0.0F + f, 1.0D);
    }
    localavd.a();
    GL11.glColorMask(true, true, true, true);
  }
Ejemplo n.º 8
0
  /** Rotate and blurs the skybox view in the main menu */
  private void rotateAndBlurSkybox(float par1) {
    mc.func_110434_K().func_110577_a(field_110351_G);
    GL11.glCopyTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, 0, 0, 256, 256);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    GL11.glColorMask(true, true, true, false);
    Tessellator tessellator = Tessellator.instance;
    tessellator.startDrawingQuads();
    byte byte0 = 3;

    for (int i = 0; i < byte0; i++) {
      tessellator.setColorRGBA_F(1.0F, 1.0F, 1.0F, 1.0F / (float) (i + 1));
      int j = width;
      int k = height;
      float f = (float) (i - byte0 / 2) / 256F;
      tessellator.addVertexWithUV(j, k, zLevel, 0.0F + f, 0.0D);
      tessellator.addVertexWithUV(j, 0.0D, zLevel, 1.0F + f, 0.0D);
      tessellator.addVertexWithUV(0.0D, 0.0D, zLevel, 1.0F + f, 1.0D);
      tessellator.addVertexWithUV(0.0D, k, zLevel, 0.0F + f, 1.0D);
    }

    tessellator.draw();
    GL11.glColorMask(true, true, true, true);
  }
Ejemplo n.º 9
0
  public void renderSkybox() {

    this.mc.getTextureManager().bindTexture(bg);

    // 这里开始的是我辛辛苦苦自创的
    double w = this.width; // k
    double h = this.height; // l
    double imgw = 256;
    double imgh = 256;
    double nimgh = w * imgh / imgw;
    double nimgw = h * imgw / imgh;

    if (w > h * imgw / imgh) {
      de(0, -nimgh / 2 + h / 2, 0, 0, w, nimgh, w, 256);
    } else if (w <= h * imgw / imgh) {
      de(-nimgw / 2 + w / 2, 0, 0, 0, h, nimgw, h, imgh);
    }
    GL11.glColorMask(true, true, true, true);
  }
Ejemplo n.º 10
0
  private void func_73970_b(int p_73970_1_, int p_73970_2_, float p_73970_3_) {
    Tessellator var4 = Tessellator.field_78398_a;
    GL11.glMatrixMode(5889);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    Project.gluPerspective(120.0F, 1.0F, 0.05F, 10.0F);
    GL11.glMatrixMode(5888);
    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(3042);
    GL11.glDisable(3008);
    GL11.glDisable(2884);
    GL11.glDepthMask(false);
    GL11.glBlendFunc(770, 771);
    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.func_76126_a(((float) this.field_73979_m + p_73970_3_) / 400.0F) * 25.0F
              + 20.0F,
          1.0F,
          0.0F,
          0.0F);
      GL11.glRotatef(-((float) this.field_73979_m + p_73970_3_) * 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.field_73882_e.func_110434_K().func_110577_a(field_73978_o[var10]);
        var4.func_78382_b();
        var4.func_78384_a(16777215, 255 / (var6 + 1));
        float var11 = 0.0F;
        var4.func_78374_a(-1.0D, -1.0D, 1.0D, (double) (0.0F + var11), (double) (0.0F + var11));
        var4.func_78374_a(1.0D, -1.0D, 1.0D, (double) (1.0F - var11), (double) (0.0F + var11));
        var4.func_78374_a(1.0D, 1.0D, 1.0D, (double) (1.0F - var11), (double) (1.0F - var11));
        var4.func_78374_a(-1.0D, 1.0D, 1.0D, (double) (0.0F + var11), (double) (1.0F - var11));
        var4.func_78381_a();
        GL11.glPopMatrix();
      }

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

    var4.func_78373_b(0.0D, 0.0D, 0.0D);
    GL11.glColorMask(true, true, true, true);
    GL11.glMatrixMode(5889);
    GL11.glPopMatrix();
    GL11.glMatrixMode(5888);
    GL11.glPopMatrix();
    GL11.glDepthMask(true);
    GL11.glEnable(2884);
    GL11.glEnable(3008);
    GL11.glEnable(2929);
  }
Ejemplo n.º 11
0
 public void glColorMask(boolean red, boolean green, boolean blue, boolean alpha) {
   GL11.glColorMask(red, green, blue, alpha);
 }
Ejemplo n.º 12
0
  public void renderParticle(
      Tessellator par1Tessellator,
      float par2,
      float par3,
      float par4,
      float par5,
      float par6,
      float par7) {
    float var8 = ((float) this.particleAge + par2) / (float) this.particleMaxAge;
    this.particleScale = this.reddustParticleScale * (1.0F - var8 * var8);
    super.renderParticle(par1Tessellator, par2, par3, par4, par5, par6, par7);

    GL11.glPushMatrix();

    GL11.glDepthMask(false);

    GL11.glDisable(3008);
    GL11.glEnable(3042);

    GL11.glColorMask(true, true, true, true);
    GL11.glBlendFunc(770, 1);
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 0.5F);

    float var81 = 0.05F;
    float var9 = 0.05F;
    float var10 = 0.05F;
    float var11 = 0.05F;
    float var12 = 0.2F * this.particleScale;
    float var13 =
        (float) (this.prevPosX + (this.posX - this.prevPosX) * (double) par2 - interpPosX);
    float var14 =
        (float) (this.prevPosY + (this.posY - this.prevPosY) * (double) par2 - interpPosY);
    float var15 =
        (float) (this.prevPosZ + (this.posZ - this.prevPosZ) * (double) par2 - interpPosZ);
    float var16 = 1.0F;
    par1Tessellator.setColorRGBA_F(
        var16 * this.particleRed, var16 * this.particleGreen, var16 * this.particleBlue, 1.0F);
    par1Tessellator.addVertexWithUV(
        (var13 - par3 * var12 - par6 * var12),
        (var14 - par4 * var12),
        (var15 - par5 * var12 - par7 * var12),
        var81,
        var11);
    par1Tessellator.addVertexWithUV(
        (var13 - par3 * var12 + par6 * var12),
        (var14 + par4 * var12),
        (var15 - par5 * var12 + par7 * var12),
        var81,
        var10);
    par1Tessellator.addVertexWithUV(
        (var13 + par3 * var12 + par6 * var12),
        (var14 + par4 * var12),
        (var15 + par5 * var12 + par7 * var12),
        var9,
        var10);
    par1Tessellator.addVertexWithUV(
        (var13 + par3 * var12 - par6 * var12),
        (var14 - par4 * var12),
        (var15 + par5 * var12 - par7 * var12),
        var9,
        var11);

    GL11.glDisable(3042);
    GL11.glEnable(3008);
    GL11.glDepthMask(true);

    GL11.glPopMatrix();
  }
Ejemplo n.º 13
0
  public void applyRenderState(RenderState state) {
    if (state.isWireframe() && !context.wireframe) {
      glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
      context.wireframe = true;
    } else if (!state.isWireframe() && context.wireframe) {
      glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
      context.wireframe = false;
    }

    if (state.isDepthTest() && !context.depthTestEnabled) {
      glEnable(GL_DEPTH_TEST);
      glDepthFunc(GL_LEQUAL);
      context.depthTestEnabled = true;
    } else if (!state.isDepthTest() && context.depthTestEnabled) {
      glDisable(GL_DEPTH_TEST);
      context.depthTestEnabled = false;
    }

    if (state.isAlphaTest()) {
      setFixedFuncBinding(FixedFuncBinding.AlphaTestFallOff, state.getAlphaFallOff());
    } else {
      setFixedFuncBinding(FixedFuncBinding.AlphaTestFallOff, 0f); // disable it
    }

    if (state.isDepthWrite() && !context.depthWriteEnabled) {
      glDepthMask(true);
      context.depthWriteEnabled = true;
    } else if (!state.isDepthWrite() && context.depthWriteEnabled) {
      glDepthMask(false);
      context.depthWriteEnabled = false;
    }

    if (state.isColorWrite() && !context.colorWriteEnabled) {
      glColorMask(true, true, true, true);
      context.colorWriteEnabled = true;
    } else if (!state.isColorWrite() && context.colorWriteEnabled) {
      glColorMask(false, false, false, false);
      context.colorWriteEnabled = false;
    }

    if (state.isPointSprite()) {
      logger.log(Level.WARNING, "Point Sprite unsupported!");
    }

    if (state.isPolyOffset()) {
      if (!context.polyOffsetEnabled) {
        glEnable(GL_POLYGON_OFFSET_FILL);
        glPolygonOffset(state.getPolyOffsetFactor(), state.getPolyOffsetUnits());
        context.polyOffsetEnabled = true;
        context.polyOffsetFactor = state.getPolyOffsetFactor();
        context.polyOffsetUnits = state.getPolyOffsetUnits();
      } else {
        if (state.getPolyOffsetFactor() != context.polyOffsetFactor
            || state.getPolyOffsetUnits() != context.polyOffsetUnits) {
          glPolygonOffset(state.getPolyOffsetFactor(), state.getPolyOffsetUnits());
          context.polyOffsetFactor = state.getPolyOffsetFactor();
          context.polyOffsetUnits = state.getPolyOffsetUnits();
        }
      }
    } else {
      if (context.polyOffsetEnabled) {
        glDisable(GL_POLYGON_OFFSET_FILL);
        context.polyOffsetEnabled = false;
        context.polyOffsetFactor = 0;
        context.polyOffsetUnits = 0;
      }
    }
    if (state.getFaceCullMode() != context.cullMode) {
      if (state.getFaceCullMode() == RenderState.FaceCullMode.Off) {
        glDisable(GL_CULL_FACE);
      } else {
        glEnable(GL_CULL_FACE);
      }

      switch (state.getFaceCullMode()) {
        case Off:
          break;
        case Back:
          glCullFace(GL_BACK);
          break;
        case Front:
          glCullFace(GL_FRONT);
          break;
        case FrontAndBack:
          glCullFace(GL_FRONT_AND_BACK);
          break;
        default:
          throw new UnsupportedOperationException(
              "Unrecognized face cull mode: " + state.getFaceCullMode());
      }

      context.cullMode = state.getFaceCullMode();
    }

    if (state.getBlendMode() != context.blendMode) {
      if (state.getBlendMode() == RenderState.BlendMode.Off) {
        glDisable(GL_BLEND);
      } else {
        glEnable(GL_BLEND);
        switch (state.getBlendMode()) {
          case Off:
            break;
          case Additive:
            glBlendFunc(GL_ONE, GL_ONE);
            break;
          case AlphaAdditive:
            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
            break;
          case Color:
            glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
            break;
          case Alpha:
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            break;
          case PremultAlpha:
            glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
            break;
          case Modulate:
            glBlendFunc(GL_DST_COLOR, GL_ZERO);
            break;
          case ModulateX2:
            glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
            break;
          default:
            throw new UnsupportedOperationException(
                "Unrecognized blend mode: " + state.getBlendMode());
        }
      }

      context.blendMode = state.getBlendMode();
    }

    if (state.isStencilTest()) {
      throw new UnsupportedOperationException(
          "OpenGL 1.1 doesn't support two sided stencil operations.");
    }
  }
Ejemplo n.º 14
0
  /** Draws the main menu panorama */
  private void drawPanorama(int p_73970_1_, int p_73970_2_, float p_73970_3_) {
    Tessellator var4 = Tessellator.instance;
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    Project.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.glRotatef(90.0F, 0.0F, 0.0F, 1.0F);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glDisable(GL11.GL_ALPHA_TEST);
    GL11.glDisable(GL11.GL_CULL_FACE);
    GL11.glDepthMask(false);
    OpenGlHelper.glBlendFunc(770, 771, 1, 0);
    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 + p_73970_3_) / 400.0F) * 25.0F + 20.0F,
          1.0F,
          0.0F,
          0.0F);
      GL11.glRotatef(-((float) this.panoramaTimer + p_73970_3_) * 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.getTextureManager().bindTexture(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_DEPTH_TEST);
  }
Ejemplo n.º 15
0
  /** Draws the main menu panorama */
  private void drawPanorama(int par1, int par2, float par3) {
    Tessellator tessellator = Tessellator.instance;
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    Project.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.glRotatef(90.0F, 0.0F, 0.0F, 1.0F);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glDisable(GL11.GL_ALPHA_TEST);
    GL11.glDisable(GL11.GL_CULL_FACE);
    GL11.glDepthMask(false);
    OpenGlHelper.glBlendFunc(770, 771, 1, 0);
    byte b0 = 8;

    for (int k = 0; k < b0 * b0; ++k) {
      GL11.glPushMatrix();
      float f1 = ((float) (k % b0) / (float) b0 - 0.5F) / 64.0F;
      float f2 = ((float) (k / b0) / (float) b0 - 0.5F) / 64.0F;
      float f3 = 0.0F;
      GL11.glTranslatef(f1, f2, f3);
      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 l = 0; l < 6; ++l) {
        GL11.glPushMatrix();

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

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

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

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

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

        this.mc.getTextureManager().bindTexture(titlePanoramaPaths[l]);
        tessellator.startDrawingQuads();
        tessellator.setColorRGBA_I(16777215, 255 / (k + 1));
        float f4 = 0.0F;
        tessellator.addVertexWithUV(-1.0D, -1.0D, 1.0D, (double) (0.0F + f4), (double) (0.0F + f4));
        tessellator.addVertexWithUV(1.0D, -1.0D, 1.0D, (double) (1.0F - f4), (double) (0.0F + f4));
        tessellator.addVertexWithUV(1.0D, 1.0D, 1.0D, (double) (1.0F - f4), (double) (1.0F - f4));
        tessellator.addVertexWithUV(-1.0D, 1.0D, 1.0D, (double) (0.0F + f4), (double) (1.0F - f4));
        tessellator.draw();
        GL11.glPopMatrix();
      }

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

    tessellator.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_DEPTH_TEST);
  }
Ejemplo n.º 16
0
  /** Draws the main menu panorama */
  private void drawPanorama(int par1, int par2, float par3) {
    Tessellator tessellator = Tessellator.instance;
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    Project.gluPerspective(120F, 1.0F, 0.05F, 10F);
    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    GL11.glRotatef(180F, 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);
    int i = 8;

    for (int j = 0; j < i * i; j++) {
      GL11.glPushMatrix();
      float f = ((float) (j % i) / (float) i - 0.5F) / 64F;
      float f1 = ((float) (j / i) / (float) i - 0.5F) / 64F;
      float f2 = 0.0F;
      GL11.glTranslatef(f, f1, f2);
      GL11.glRotatef(
          MathHelper.sin(((float) panoramaTimer + par3) / 400F) * 25F + 20F, 1.0F, 0.0F, 0.0F);
      GL11.glRotatef(-((float) panoramaTimer + par3) * 0.1F, 0.0F, 1.0F, 0.0F);

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

        if (k == 1) {
          GL11.glRotatef(90F, 0.0F, 1.0F, 0.0F);
        }

        if (k == 2) {
          GL11.glRotatef(180F, 0.0F, 1.0F, 0.0F);
        }

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

        if (k == 4) {
          GL11.glRotatef(90F, 1.0F, 0.0F, 0.0F);
        }

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

        mc.func_110434_K().func_110577_a(titlePanoramaPaths[k]);
        tessellator.startDrawingQuads();
        tessellator.setColorRGBA_I(0xffffff, 255 / (j + 1));
        float f3 = 0.0F;
        tessellator.addVertexWithUV(-1D, -1D, 1.0D, 0.0F + f3, 0.0F + f3);
        tessellator.addVertexWithUV(1.0D, -1D, 1.0D, 1.0F - f3, 0.0F + f3);
        tessellator.addVertexWithUV(1.0D, 1.0D, 1.0D, 1.0F - f3, 1.0F - f3);
        tessellator.addVertexWithUV(-1D, 1.0D, 1.0D, 0.0F + f3, 1.0F - f3);
        tessellator.draw();
        GL11.glPopMatrix();
      }

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

    tessellator.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);
  }
  /** 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);
        }

        GL11.glBindTexture(
            GL11.GL_TEXTURE_2D, this.mc.renderEngine.getTexture(field_73978_o[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);
  }
Ejemplo n.º 18
0
  /** Simulation of reflections by stencil buffer and blending equations */
  public void stencilPlannarReflections() {

    // outside this plane reflected objects won't be rendered
    glColorMask(false, false, false, false);
    glDisable(GL_DEPTH_TEST);

    glEnable(GL_STENCIL_TEST);
    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);

    glStencilFunc(GL_ALWAYS, 1, 0xFF);
    glStencilMask(0xFF);
    glClear(GL_STENCIL_BUFFER_BIT);

    glPushMatrix();
    {
      glCallList(2);
      glCallList(3);
    }
    glPopMatrix();

    glColorMask(true, true, true, true);
    glEnable(GL_DEPTH_TEST);

    glStencilMask(0x00);
    glStencilFunc(GL_EQUAL, 1, 0xFF);
    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

    // drawing reflected object
    glPushMatrix();
    {
      box.setTranslate(new Vector3f(.0f, -10.0f, .0f));
      box.setScale(new Vector3f(1.0f, -1.0f, 1.0f));
      box.setColor(new Vector3f(1.0f, .0f, .0f));
      box.setAngleofRotation(rotationAngle);
      box.setRotate(new Vector3f(1, 1, 1));

      box.draw();

      box.setTranslate(new Vector3f(-20.0f, 10.0f, .0f));
      box.setScale(new Vector3f(-1.0f, 1.0f, 1.0f));
      box.setColor(new Vector3f(1.0f, .0f, .0f));
      box.setAngleofRotation(rotationAngle);
      box.setRotate(new Vector3f(1, 1, 1));

      box.draw();
    }
    glPopMatrix();

    glDisable(GL_STENCIL_TEST);

    // drawing blended floor
    glDisable(GL_LIGHTING);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    glPushMatrix();
    {
      glCallList(2);
      glCallList(3);
    }
    glPopMatrix();

    glPushMatrix();
    {
      bottonCoverSurface.draw();
      wallCoverSurface.draw();
    }
    glPopMatrix();

    glDisable(GL_BLEND);
    glEnable(GL_LIGHTING);

    // drawing actual box
    glPushMatrix();
    {
      box.setTranslate(new Vector3f(.0f, 10.0f, .0f));
      box.setScale(new Vector3f().makeIdentity());
      box.draw();
    }
    glPopMatrix();

    rotationAngle += .5f;
  }
Ejemplo n.º 19
0
  @SideOnly(Side.CLIENT)
  public static void renderClouds(
      GenericWorldProvider provider, DimensionInformation information, float partialTicks) {
    GL11.glDisable(GL11.GL_CULL_FACE);
    Minecraft mc = Minecraft.getMinecraft();
    TextureManager renderEngine = mc.getTextureManager();
    float f1 =
        (float)
            (mc.renderViewEntity.lastTickPosY
                + (mc.renderViewEntity.posY - mc.renderViewEntity.lastTickPosY) * partialTicks);
    Tessellator tessellator = Tessellator.instance;
    float f2 = 12.0F;
    float f3 = 4.0F;
    RenderGlobal renderGlobal = mc.renderGlobal;
    double d0 = (CloudRenderAccessHelper.getCloudTickCounter(renderGlobal) + partialTicks);

    double entityX =
        mc.renderViewEntity.prevPosX
            + (mc.renderViewEntity.posX - mc.renderViewEntity.prevPosX) * partialTicks;
    double entityZ =
        mc.renderViewEntity.prevPosZ
            + (mc.renderViewEntity.posZ - mc.renderViewEntity.prevPosZ) * partialTicks;

    double d1 = (entityX + d0 * 0.029999999329447746D) / f2;
    double d2 = entityZ / f2 + 0.33000001311302185D;
    float y = provider.getCloudHeight() - f1 + 0.33F;
    int i = MathHelper.floor_double(d1 / 2048.0D);
    int j = MathHelper.floor_double(d2 / 2048.0D);
    d1 -= (i * 2048);
    d2 -= (j * 2048);
    renderEngine.bindTexture(locationCloudsPng);
    GL11.glEnable(GL11.GL_BLEND);
    OpenGlHelper.glBlendFunc(770, 771, 1, 0);
    Vec3 vec3 = provider.worldObj.getCloudColour(partialTicks);
    float red = (float) vec3.xCoord;
    float green = (float) vec3.yCoord;
    float blue = (float) vec3.zCoord;
    float f8;
    float f9;
    float f10;

    if (mc.gameSettings.anaglyph) {
      f8 = (red * 30.0F + green * 59.0F + blue * 11.0F) / 100.0F;
      f9 = (red * 30.0F + green * 70.0F) / 100.0F;
      f10 = (red * 30.0F + blue * 70.0F) / 100.0F;
      red = f8;
      green = f9;
      blue = f10;
    }

    f10 = 0.00390625F;
    f8 = MathHelper.floor_double(d1) * f10;
    f9 = MathHelper.floor_double(d2) * f10;
    float f11 = (float) (d1 - MathHelper.floor_double(d1));
    float f12 = (float) (d2 - MathHelper.floor_double(d2));
    byte b0 = 8;
    byte b1 = 4;
    float f13 = 9.765625E-4F;
    GL11.glScalef(f2, 1.0F, f2);

    float cr = information.getSkyDescriptor().getCloudColorFactorR();
    float cg = information.getSkyDescriptor().getCloudColorFactorG();
    float cb = information.getSkyDescriptor().getCloudColorFactorB();
    boolean randomColors = information.isPatreonBitSet(Patreons.PATREON_KENNEY);

    for (int k = 0; k < 2; ++k) {
      if (k == 0) {
        GL11.glColorMask(false, false, false, false);
      } else if (mc.gameSettings.anaglyph) {
        if (EntityRenderer.anaglyphField == 0) {
          GL11.glColorMask(false, true, true, true);
        } else {
          GL11.glColorMask(true, false, false, true);
        }
      } else {
        GL11.glColorMask(true, true, true, true);
      }

      for (int l = -b1 + 1; l <= b1; ++l) {
        for (int i1 = -b1 + 1; i1 <= b1; ++i1) {
          tessellator.startDrawingQuads();
          float u = (l * b0);
          float v = (i1 * b0);
          float x = u - f11;
          float z = v - f12;
          if (randomColors) {
            //                        cr = (float) ((u % 10.0f) / 10.0f);
            //                        cg = (float) (((u + v) % 10.0f) / 10.0f);
            //                        cb = (float) ((v % 10.0f) / 10.0f);
            cr = x % 1.0f;
            cg = (x + z) % 1.0f;
            cb = z % 1.0f;
          }

          if (y > -f3 - 1.0F) {
            tessellator.setColorRGBA_F(red * 0.7F * cr, green * 0.7F * cg, blue * 0.7F * cb, 0.8F);
            tessellator.setNormal(0.0F, -1.0F, 0.0F);
            tessellator.addVertexWithUV(
                (x + 0.0F), (y + 0.0F), (z + b0), ((u + 0.0F) * f10 + f8), ((v + b0) * f10 + f9));
            tessellator.addVertexWithUV(
                (x + b0), (y + 0.0F), (z + b0), ((u + b0) * f10 + f8), ((v + b0) * f10 + f9));
            tessellator.addVertexWithUV(
                (x + b0), (y + 0.0F), (z + 0.0F), ((u + b0) * f10 + f8), ((v + 0.0F) * f10 + f9));
            tessellator.addVertexWithUV(
                (x + 0.0F),
                (y + 0.0F),
                (z + 0.0F),
                ((u + 0.0F) * f10 + f8),
                ((v + 0.0F) * f10 + f9));
          }

          if (y <= f3 + 1.0F) {
            tessellator.setColorRGBA_F(red * cr, green * cg, blue * cb, 0.8F);
            tessellator.setNormal(0.0F, 1.0F, 0.0F);
            tessellator.addVertexWithUV(
                (x + 0.0F),
                (y + f3 - f13),
                (z + b0),
                ((u + 0.0F) * f10 + f8),
                ((v + b0) * f10 + f9));
            tessellator.addVertexWithUV(
                (x + b0), (y + f3 - f13), (z + b0), ((u + b0) * f10 + f8), ((v + b0) * f10 + f9));
            tessellator.addVertexWithUV(
                (x + b0),
                (y + f3 - f13),
                (z + 0.0F),
                ((u + b0) * f10 + f8),
                ((v + 0.0F) * f10 + f9));
            tessellator.addVertexWithUV(
                (x + 0.0F),
                (y + f3 - f13),
                (z + 0.0F),
                ((u + 0.0F) * f10 + f8),
                ((v + 0.0F) * f10 + f9));
          }

          tessellator.setColorRGBA_F(red * 0.9F * cr, green * 0.9F * cg, blue * 0.9F * cb, 0.8F);
          int j1;

          if (l > -1) {
            tessellator.setNormal(-1.0F, 0.0F, 0.0F);

            for (j1 = 0; j1 < b0; ++j1) {
              tessellator.addVertexWithUV(
                  (x + j1 + 0.0F),
                  (y + 0.0F),
                  (z + b0),
                  ((u + j1 + 0.5F) * f10 + f8),
                  ((v + b0) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + j1 + 0.0F),
                  (y + f3),
                  (z + b0),
                  ((u + j1 + 0.5F) * f10 + f8),
                  ((v + b0) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + j1 + 0.0F),
                  (y + f3),
                  (z + 0.0F),
                  ((u + j1 + 0.5F) * f10 + f8),
                  ((v + 0.0F) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + j1 + 0.0F),
                  (y + 0.0F),
                  (z + 0.0F),
                  ((u + j1 + 0.5F) * f10 + f8),
                  ((v + 0.0F) * f10 + f9));
            }
          }

          if (l <= 1) {
            tessellator.setNormal(1.0F, 0.0F, 0.0F);

            for (j1 = 0; j1 < b0; ++j1) {
              tessellator.addVertexWithUV(
                  (x + j1 + 1.0F - f13),
                  (y + 0.0F),
                  (z + b0),
                  ((u + j1 + 0.5F) * f10 + f8),
                  ((v + b0) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + j1 + 1.0F - f13),
                  (y + f3),
                  (z + b0),
                  ((u + j1 + 0.5F) * f10 + f8),
                  ((v + b0) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + j1 + 1.0F - f13),
                  (y + f3),
                  (z + 0.0F),
                  ((u + j1 + 0.5F) * f10 + f8),
                  ((v + 0.0F) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + j1 + 1.0F - f13),
                  (y + 0.0F),
                  (z + 0.0F),
                  ((u + j1 + 0.5F) * f10 + f8),
                  ((v + 0.0F) * f10 + f9));
            }
          }

          tessellator.setColorRGBA_F(red * 0.8F * cr, green * 0.8F * cg, blue * 0.8F * cb, 0.8F);

          if (i1 > -1) {
            tessellator.setNormal(0.0F, 0.0F, -1.0F);

            for (j1 = 0; j1 < b0; ++j1) {
              tessellator.addVertexWithUV(
                  (x + 0.0F),
                  (y + f3),
                  (z + j1 + 0.0F),
                  ((u + 0.0F) * f10 + f8),
                  ((v + j1 + 0.5F) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + b0),
                  (y + f3),
                  (z + j1 + 0.0F),
                  ((u + b0) * f10 + f8),
                  ((v + j1 + 0.5F) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + b0),
                  (y + 0.0F),
                  (z + j1 + 0.0F),
                  ((u + b0) * f10 + f8),
                  ((v + j1 + 0.5F) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + 0.0F),
                  (y + 0.0F),
                  (z + j1 + 0.0F),
                  ((u + 0.0F) * f10 + f8),
                  ((v + j1 + 0.5F) * f10 + f9));
            }
          }

          if (i1 <= 1) {
            tessellator.setNormal(0.0F, 0.0F, 1.0F);

            for (j1 = 0; j1 < b0; ++j1) {
              tessellator.addVertexWithUV(
                  (x + 0.0F),
                  (y + f3),
                  (z + j1 + 1.0F - f13),
                  ((u + 0.0F) * f10 + f8),
                  ((v + j1 + 0.5F) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + b0),
                  (y + f3),
                  (z + j1 + 1.0F - f13),
                  ((u + b0) * f10 + f8),
                  ((v + j1 + 0.5F) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + b0),
                  (y + 0.0F),
                  (z + j1 + 1.0F - f13),
                  ((u + b0) * f10 + f8),
                  ((v + j1 + 0.5F) * f10 + f9));
              tessellator.addVertexWithUV(
                  (x + 0.0F),
                  (y + 0.0F),
                  (z + j1 + 1.0F - f13),
                  ((u + 0.0F) * f10 + f8),
                  ((v + j1 + 0.5F) * f10 + f9));
            }
          }

          tessellator.draw();
        }
      }
    }

    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    GL11.glDisable(GL11.GL_BLEND);
    GL11.glEnable(GL11.GL_CULL_FACE);
  }
  private void b(int paramInt1, int paramInt2, float paramFloat) {
    avd localavd = avd.a;

    GL11.glMatrixMode(5889);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    GLU.gluPerspective(120.0F, 1.0F, 0.05F, 10.0F);

    GL11.glMatrixMode(5888);
    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(3042);
    GL11.glDisable(3008);
    GL11.glDisable(2884);
    GL11.glDepthMask(false);
    GL11.glBlendFunc(770, 771);
    int i = 8;

    for (int j = 0; j < i * i; j++) {
      GL11.glPushMatrix();
      float f1 = (j % i / i - 0.5F) / 64.0F;
      float f2 = (j / i / i - 0.5F) / 64.0F;
      float f3 = 0.0F;
      GL11.glTranslatef(f1, f2, f3);

      GL11.glRotatef(ig.a((this.m + paramFloat) / 400.0F) * 25.0F + 20.0F, 1.0F, 0.0F, 0.0F);
      GL11.glRotatef(-(this.m + paramFloat) * 0.1F, 0.0F, 1.0F, 0.0F);

      for (int k = 0; k < 6; k++) {
        GL11.glPushMatrix();
        if (k == 1) GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
        if (k == 2) GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F);
        if (k == 3) GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F);
        if (k == 4) GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F);
        if (k == 5) GL11.glRotatef(-90.0F, 1.0F, 0.0F, 0.0F);
        GL11.glBindTexture(3553, this.e.o.b(o[k]));
        localavd.b();
        localavd.a(16777215, 255 / (j + 1));
        float f4 = 0.0F;
        localavd.a(-1.0D, -1.0D, 1.0D, 0.0F + f4, 0.0F + f4);
        localavd.a(1.0D, -1.0D, 1.0D, 1.0F - f4, 0.0F + f4);
        localavd.a(1.0D, 1.0D, 1.0D, 1.0F - f4, 1.0F - f4);
        localavd.a(-1.0D, 1.0D, 1.0D, 0.0F + f4, 1.0F - f4);
        localavd.a();
        GL11.glPopMatrix();
      }
      GL11.glPopMatrix();
      GL11.glColorMask(true, true, true, false);
    }
    localavd.b(0.0D, 0.0D, 0.0D);
    GL11.glColorMask(true, true, true, true);

    GL11.glMatrixMode(5889);
    GL11.glPopMatrix();
    GL11.glMatrixMode(5888);
    GL11.glPopMatrix();
    GL11.glDepthMask(true);
    GL11.glEnable(2884);

    GL11.glEnable(3008);
    GL11.glEnable(2929);
  }