public Tessellator(int p_i52_1_) {
renderingChunk = false;
defaultTexture = true;
autoGrow = true;
subTessellators = new Tessellator[0];
subTextures = new int[0];
terrainTexture = 0;
textureUpdateTime = 0L;
field_1505_h = 0;
field_1501_l = false;
field_1500_m = false;
field_35838_p = false;
field_1499_n = false;
field_1498_o = 0;
field_1497_p = 0;
field_1495_q = false;
field_1488_w = false;
field_1487_x = false;
field_1485_z = 0;
field_1496_A = 10;
field_1494_B = p_i52_1_;
field_1509_d = GLAllocation.func_1127_b(p_i52_1_ * 4);
field_1508_e = field_1509_d.asIntBuffer();
field_1507_f = field_1509_d.asFloatBuffer();
field_35836_g = field_1509_d.asShortBuffer();
field_1506_g = new int[p_i52_1_];
field_1487_x = field_1510_c && GLContext.getCapabilities().GL_ARB_vertex_buffer_object;
if (field_1487_x) {
field_1486_y = GLAllocation.func_1125_c(field_1496_A);
ARBVertexBufferObject.glGenBuffersARB(field_1486_y);
}
}
Tessellator(int par1) {
vertexCount = 0;
hasColor = false;
hasTexture = false;
hasBrightness = false;
hasNormals = false;
rawBufferIndex = 0;
addedVertices = 0;
isColorDisabled = false;
isDrawing = false;
useVBO = false;
vboIndex = 0;
vboCount = 10;
bufferSize = par1;
byteBuffer = GLAllocation.createDirectByteBuffer(par1 * 4);
intBuffer = byteBuffer.asIntBuffer();
floatBuffer = byteBuffer.asFloatBuffer();
shortBuffer = byteBuffer.asShortBuffer();
rawBuffer = new int[par1];
useVBO = tryVBO && GLContext.getCapabilities().GL_ARB_vertex_buffer_object;
if (useVBO) {
vertexBuffers = GLAllocation.createDirectIntBuffer(vboCount);
ARBVertexBufferObject.glGenBuffersARB(vertexBuffers);
}
}
public int getTexture(String par1Str) {
Integer var2 = (Integer) this.textureMap.get(par1Str);
if (var2 != null) {
return var2.intValue();
} else {
ITexturePack var6 = this.texturePack.getSelectedTexturePack();
try {
this.singleIntBuffer.clear();
GLAllocation.generateTextureNames(this.singleIntBuffer);
int var3 = this.singleIntBuffer.get(0);
if (par1Str.startsWith("##")) {
// Spout HD Start
this.setupTexture(
this.unwrapImageByColumns(
TextureUtils.getResourceAsBufferedImage(this, var6, par1Str.substring(2))),
var3);
// Spout HD End
} else if (par1Str.startsWith("%clamp%")) {
this.clampTexture = true;
// Spout HD Start
this.setupTexture(
TextureUtils.getResourceAsBufferedImage(this, var6, par1Str.substring(7)), var3);
// Spout HD End
this.clampTexture = false;
} else if (par1Str.startsWith("%blur%")) {
this.blurTexture = true;
// Spout HD Start
this.setupTexture(
TextureUtils.getResourceAsBufferedImage(this, var6, par1Str.substring(6)), var3);
// Spout HD End
this.blurTexture = false;
} else if (par1Str.startsWith("%blurclamp%")) {
this.blurTexture = true;
this.clampTexture = true;
// Spout HD Start
this.setupTexture(
TextureUtils.getResourceAsBufferedImage(this, var6, par1Str.substring(11)), var3);
// Spout HD End
this.blurTexture = false;
this.clampTexture = false;
} else {
this.setupTexture(TextureUtils.getResourceAsBufferedImage(par1Str), var3); // Spout HD
}
this.textureMap.put(par1Str, Integer.valueOf(var3));
return var3;
} catch (Exception var5) {
var5.printStackTrace();
GLAllocation.generateTextureNames(this.singleIntBuffer);
int var4 = this.singleIntBuffer.get(0);
this.setupTexture(this.missingTextureImage, var4);
this.textureMap.put(par1Str, Integer.valueOf(var4));
return var4;
}
}
}
public MouseHelper(Component p_i174_1_) {
field_1115_e = 10;
field_1117_c = p_i174_1_;
IntBuffer intbuffer = GLAllocation.func_1125_c(1);
intbuffer.put(0);
intbuffer.flip();
IntBuffer intbuffer1 = GLAllocation.func_1125_c(1024);
try {
field_1116_d = new Cursor(32, 32, 16, 16, 1, intbuffer1, intbuffer);
} catch (LWJGLException lwjglexception) {
lwjglexception.printStackTrace();
}
}
public void shutdownMinecraftApplet() {
try {
statFileWriter.func_27175_b();
statFileWriter.syncStats();
if (mcApplet != null) {
mcApplet.clearApplet();
}
try {
if (downloadResourcesThread != null) {
downloadResourcesThread.closeMinecraft();
}
} catch (Exception exception) {
}
System.out.println("Stopping!");
try {
changeWorld1(null);
} catch (Throwable throwable) {
}
try {
GLAllocation.deleteTexturesAndDisplayLists();
} catch (Throwable throwable1) {
}
sndManager.closeMinecraft();
Mouse.destroy();
Keyboard.destroy();
} finally {
Display.destroy();
if (!hasCrashed) {
System.exit(0);
}
}
System.gc();
}
/**
* Copy the supplied image onto a newly-allocated OpenGL texture, returning the allocated texture
* name
*/
public int allocateAndSetupTexture(BufferedImage par1BufferedImage) {
this.singleIntBuffer.clear();
GLAllocation.generateTextureNames(this.singleIntBuffer);
int var2 = this.singleIntBuffer.get(0);
this.setupTexture(par1BufferedImage, var2);
this.textureNameToImageMap.addKey(var2, par1BufferedImage);
return var2;
}
private void compileDisplayList(float f) {
displayList = GLAllocation.generateDisplayLists(1);
GL11.glNewList(displayList, 4864 /*GL_COMPILE*/);
Tessellator tessellator = Tessellator.instance;
for (int i = 0; i < faces.length; i++) {
faces[i].draw(tessellator, f);
}
GL11.glEndList();
compiled = true;
}
public void func_991_a(double p_991_1_, double p_991_3_, double p_991_5_) {
if (autoGrow && field_1498_o >= field_1494_B - 32) {
Config.dbg(
(new StringBuilder())
.append("Expand tessellator buffer, old: ")
.append(field_1494_B)
.append(", new: ")
.append(field_1494_B * 2)
.toString());
field_1494_B *= 2;
int ai[] = new int[field_1494_B];
System.arraycopy(field_1506_g, 0, ai, 0, field_1506_g.length);
field_1506_g = ai;
field_1509_d = GLAllocation.func_1127_b(field_1494_B * 4);
field_1508_e = field_1509_d.asIntBuffer();
field_1507_f = field_1509_d.asFloatBuffer();
field_35836_g = field_1509_d.asShortBuffer();
}
field_1497_p++;
if (field_1493_r == 7 && field_1511_b && field_1497_p % 4 == 0) {
for (int i = 0; i < 2; i++) {
int j = 8 * (3 - i);
if (field_1500_m) {
field_1506_g[field_1498_o + 3] = field_1506_g[(field_1498_o - j) + 3];
field_1506_g[field_1498_o + 4] = field_1506_g[(field_1498_o - j) + 4];
}
if (field_35838_p) {
field_1506_g[field_1498_o + 7] = field_1506_g[(field_1498_o - j) + 7];
}
if (field_1501_l) {
field_1506_g[field_1498_o + 5] = field_1506_g[(field_1498_o - j) + 5];
}
field_1506_g[field_1498_o + 0] = field_1506_g[(field_1498_o - j) + 0];
field_1506_g[field_1498_o + 1] = field_1506_g[(field_1498_o - j) + 1];
field_1506_g[field_1498_o + 2] = field_1506_g[(field_1498_o - j) + 2];
field_1505_h++;
field_1498_o += 8;
}
}
if (field_1500_m) {
field_1506_g[field_1498_o + 3] = Float.floatToRawIntBits((float) field_1504_i);
field_1506_g[field_1498_o + 4] = Float.floatToRawIntBits((float) field_1503_j);
}
if (field_35838_p) {
field_1506_g[field_1498_o + 7] = field_35837_l;
}
if (field_1501_l) {
field_1506_g[field_1498_o + 5] = field_1502_k;
}
if (field_1499_n) {
field_1506_g[field_1498_o + 6] = field_1489_v;
}
field_1506_g[field_1498_o + 0] = Float.floatToRawIntBits((float) (p_991_1_ + field_1492_s));
field_1506_g[field_1498_o + 1] = Float.floatToRawIntBits((float) (p_991_3_ + field_1491_t));
field_1506_g[field_1498_o + 2] = Float.floatToRawIntBits((float) (p_991_5_ + field_1490_u));
field_1498_o += 8;
field_1505_h++;
if (!autoGrow && field_1497_p % 4 == 0 && field_1498_o >= field_1494_B - 32) {
func_982_a();
field_1488_w = true;
}
}
public ClippingHelperImpl() {
projectionMatrixBuffer = GLAllocation.createDirectFloatBuffer(16);
modelviewMatrixBuffer = GLAllocation.createDirectFloatBuffer(16);
field_1691_h = GLAllocation.createDirectFloatBuffer(16);
}
public class RenderEndPortal extends TileEntitySpecialRenderer {
FloatBuffer field_76908_a = GLAllocation.createDirectFloatBuffer(16);
public void func_76906_a(
TileEntityEndPortal par1TileEntityEndPortal,
double par2,
double par4,
double par6,
float par8) {
float var9 = (float) this.tileEntityRenderer.playerX;
float var10 = (float) this.tileEntityRenderer.playerY;
float var11 = (float) this.tileEntityRenderer.playerZ;
GL11.glDisable(GL11.GL_LIGHTING);
Random var12 = new Random(31100L);
float var13 = 0.75F;
for (int var14 = 0; var14 < 16; ++var14) {
GL11.glPushMatrix();
float var15 = (float) (16 - var14);
float var16 = 0.0625F;
float var17 = 1.0F / (var15 + 1.0F);
if (var14 == 0) {
this.bindTextureByName("/misc/tunnel.png");
var17 = 0.1F;
var15 = 65.0F;
var16 = 0.125F;
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
}
if (var14 == 1) {
this.bindTextureByName("/misc/particlefield.png");
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_ONE, GL11.GL_ONE);
var16 = 0.5F;
}
float var18 = (float) (-(par4 + (double) var13));
float var19 = var18 + ActiveRenderInfo.objectY;
float var20 = var18 + var15 + ActiveRenderInfo.objectY;
float var21 = var19 / var20;
var21 += (float) (par4 + (double) var13);
GL11.glTranslatef(var9, var21, var11);
GL11.glTexGeni(GL11.GL_S, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
GL11.glTexGeni(GL11.GL_T, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
GL11.glTexGeni(GL11.GL_R, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
GL11.glTexGeni(GL11.GL_Q, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_EYE_LINEAR);
GL11.glTexGen(GL11.GL_S, GL11.GL_OBJECT_PLANE, this.func_76907_a(1.0F, 0.0F, 0.0F, 0.0F));
GL11.glTexGen(GL11.GL_T, GL11.GL_OBJECT_PLANE, this.func_76907_a(0.0F, 0.0F, 1.0F, 0.0F));
GL11.glTexGen(GL11.GL_R, GL11.GL_OBJECT_PLANE, this.func_76907_a(0.0F, 0.0F, 0.0F, 1.0F));
GL11.glTexGen(GL11.GL_Q, GL11.GL_EYE_PLANE, this.func_76907_a(0.0F, 1.0F, 0.0F, 0.0F));
GL11.glEnable(GL11.GL_TEXTURE_GEN_S);
GL11.glEnable(GL11.GL_TEXTURE_GEN_T);
GL11.glEnable(GL11.GL_TEXTURE_GEN_R);
GL11.glEnable(GL11.GL_TEXTURE_GEN_Q);
GL11.glPopMatrix();
GL11.glMatrixMode(GL11.GL_TEXTURE);
GL11.glPushMatrix();
GL11.glLoadIdentity();
GL11.glTranslatef(0.0F, (float) (Minecraft.getSystemTime() % 700000L) / 700000.0F, 0.0F);
GL11.glScalef(var16, var16, var16);
GL11.glTranslatef(0.5F, 0.5F, 0.0F);
GL11.glRotatef((float) (var14 * var14 * 4321 + var14 * 9) * 2.0F, 0.0F, 0.0F, 1.0F);
GL11.glTranslatef(-0.5F, -0.5F, 0.0F);
GL11.glTranslatef(-var9, -var11, -var10);
var19 = var18 + ActiveRenderInfo.objectY;
GL11.glTranslatef(
ActiveRenderInfo.objectX * var15 / var19,
ActiveRenderInfo.objectZ * var15 / var19,
-var10);
Tessellator var24 = Tessellator.instance;
var24.startDrawingQuads();
var21 = var12.nextFloat() * 0.5F + 0.1F;
float var22 = var12.nextFloat() * 0.5F + 0.4F;
float var23 = var12.nextFloat() * 0.5F + 0.5F;
if (var14 == 0) {
var23 = 1.0F;
var22 = 1.0F;
var21 = 1.0F;
}
var24.setColorRGBA_F(var21 * var17, var22 * var17, var23 * var17, 1.0F);
var24.addVertex(par2, par4 + (double) var13, par6);
var24.addVertex(par2, par4 + (double) var13, par6 + 1.0D);
var24.addVertex(par2 + 1.0D, par4 + (double) var13, par6 + 1.0D);
var24.addVertex(par2 + 1.0D, par4 + (double) var13, par6);
var24.draw();
GL11.glPopMatrix();
GL11.glMatrixMode(GL11.GL_MODELVIEW);
}
GL11.glDisable(GL11.GL_BLEND);
GL11.glDisable(GL11.GL_TEXTURE_GEN_S);
GL11.glDisable(GL11.GL_TEXTURE_GEN_T);
GL11.glDisable(GL11.GL_TEXTURE_GEN_R);
GL11.glDisable(GL11.GL_TEXTURE_GEN_Q);
GL11.glEnable(GL11.GL_LIGHTING);
}
private FloatBuffer func_76907_a(float par1, float par2, float par3, float par4) {
this.field_76908_a.clear();
this.field_76908_a.put(par1).put(par2).put(par3).put(par4);
this.field_76908_a.flip();
return this.field_76908_a;
}
public void renderTileEntityAt(
TileEntity par1TileEntity, double par2, double par4, double par6, float par8) {
this.func_76906_a((TileEntityEndPortal) par1TileEntity, par2, par4, par6, par8);
}
}
// Spout HD Start
public void setTileSize(Minecraft var1) {
this.imageData = GLAllocation.createDirectByteBuffer(TileSize.int_glBufferSize);
this.refreshTextures();
TextureUtils.refreshTextureFX(this.textureList);
}
public class RenderEngine {
private HashMap textureMap = new HashMap();
/** Texture contents map (key: texture name, value: int[] contents) */
private HashMap textureContentsMap = new HashMap();
/** A mapping from GL texture names (integers) to BufferedImage instances */
private IntHashMap textureNameToImageMap = new IntHashMap();
/** An IntBuffer storing 1 int used as scratch space in RenderEngine */
private IntBuffer singleIntBuffer = GLAllocation.createDirectIntBuffer(1);
/** Stores the image data for the texture. */
private ByteBuffer imageData = GLAllocation.createDirectByteBuffer(16777216);
public List textureList = new ArrayList(); // Spout private -> public
/** A mapping from image URLs to ThreadDownloadImageData instances */
private Map urlToImageDataMap = new HashMap();
/** Reference to the GameSettings object */
private GameSettings options;
/** Flag set when a texture should not be repeated */
public boolean clampTexture = false;
/** Flag set when a texture should use blurry resizing */
public boolean blurTexture = false;
/** Texture pack */
public TexturePackList texturePack; // Spout private -> public
/** Missing texture image */
private BufferedImage missingTextureImage = new BufferedImage(64, 64, 2);
// Spout Start
public ITexturePack oldPack = null;
// Spout End
public RenderEngine(TexturePackList par1TexturePackList, GameSettings par2GameSettings) {
this.texturePack = par1TexturePackList;
this.options = par2GameSettings;
Graphics var3 = this.missingTextureImage.getGraphics();
var3.setColor(Color.WHITE);
var3.fillRect(0, 0, 64, 64);
var3.setColor(Color.BLACK);
var3.drawString("missingtex", 1, 10);
var3.dispose();
}
public int[] getTextureContents(String par1Str) {
ITexturePack var2 = this.texturePack.getSelectedTexturePack();
int[] var3 = (int[]) this.textureContentsMap.get(par1Str);
if (var3 != null) {
return var3;
} else {
try {
Object var4 = null;
int[] var7;
if (par1Str.startsWith("##")) {
// Spout HD Start
var7 =
this.getImageContentsAndAllocate(
this.unwrapImageByColumns(
TextureUtils.getResourceAsBufferedImage(this, var2, par1Str.substring(2))));
// Spout HD End
} else if (par1Str.startsWith("%clamp%")) {
this.clampTexture = true;
// Spout HD Start
var7 =
this.getImageContentsAndAllocate(
TextureUtils.getResourceAsBufferedImage(this, var2, par1Str.substring(7)));
// Spout HD End
this.clampTexture = false;
} else if (par1Str.startsWith("%blur%")) {
this.blurTexture = true;
this.clampTexture = true;
// Spout HD Start
var7 =
this.getImageContentsAndAllocate(
TextureUtils.getResourceAsBufferedImage(this, var2, par1Str.substring(6)));
// Spout HD Start
this.clampTexture = false;
this.blurTexture = false;
} else {
InputStream var8 = var2.getResourceAsStream(par1Str);
if (var8 == null) {
var7 = this.getImageContentsAndAllocate(this.missingTextureImage);
} else {
var7 = this.getImageContentsAndAllocate(this.readTextureImage(var8));
}
}
this.textureContentsMap.put(par1Str, var7);
return var7;
} catch (IOException var6) {
var6.printStackTrace();
int[] var5 = this.getImageContentsAndAllocate(this.missingTextureImage);
this.textureContentsMap.put(par1Str, var5);
return var5;
}
}
}
private int[] getImageContentsAndAllocate(BufferedImage par1BufferedImage) {
int var2 = par1BufferedImage.getWidth();
int var3 = par1BufferedImage.getHeight();
int[] var4 = new int[var2 * var3];
par1BufferedImage.getRGB(0, 0, var2, var3, var4, 0, var2);
return var4;
}
private int[] getImageContents(BufferedImage par1BufferedImage, int[] par2ArrayOfInteger) {
// Spout HD Start
if (par1BufferedImage == null) {
return par2ArrayOfInteger;
} else {
int var3 = par1BufferedImage.getWidth();
int var4 = par1BufferedImage.getHeight();
par1BufferedImage.getRGB(0, 0, var3, var4, par2ArrayOfInteger, 0, var3);
return par2ArrayOfInteger;
}
// Spout HD End
}
public int getTexture(String par1Str) {
Integer var2 = (Integer) this.textureMap.get(par1Str);
if (var2 != null) {
return var2.intValue();
} else {
ITexturePack var6 = this.texturePack.getSelectedTexturePack();
try {
this.singleIntBuffer.clear();
GLAllocation.generateTextureNames(this.singleIntBuffer);
int var3 = this.singleIntBuffer.get(0);
if (par1Str.startsWith("##")) {
// Spout HD Start
this.setupTexture(
this.unwrapImageByColumns(
TextureUtils.getResourceAsBufferedImage(this, var6, par1Str.substring(2))),
var3);
// Spout HD End
} else if (par1Str.startsWith("%clamp%")) {
this.clampTexture = true;
// Spout HD Start
this.setupTexture(
TextureUtils.getResourceAsBufferedImage(this, var6, par1Str.substring(7)), var3);
// Spout HD End
this.clampTexture = false;
} else if (par1Str.startsWith("%blur%")) {
this.blurTexture = true;
// Spout HD Start
this.setupTexture(
TextureUtils.getResourceAsBufferedImage(this, var6, par1Str.substring(6)), var3);
// Spout HD End
this.blurTexture = false;
} else if (par1Str.startsWith("%blurclamp%")) {
this.blurTexture = true;
this.clampTexture = true;
// Spout HD Start
this.setupTexture(
TextureUtils.getResourceAsBufferedImage(this, var6, par1Str.substring(11)), var3);
// Spout HD End
this.blurTexture = false;
this.clampTexture = false;
} else {
this.setupTexture(TextureUtils.getResourceAsBufferedImage(par1Str), var3); // Spout HD
}
this.textureMap.put(par1Str, Integer.valueOf(var3));
return var3;
} catch (Exception var5) {
var5.printStackTrace();
GLAllocation.generateTextureNames(this.singleIntBuffer);
int var4 = this.singleIntBuffer.get(0);
this.setupTexture(this.missingTextureImage, var4);
this.textureMap.put(par1Str, Integer.valueOf(var4));
return var4;
}
}
}
/**
* Takes an image with multiple 16-pixel-wide columns and creates a new 16-pixel-wide image where
* the columns are stacked vertically
*/
private BufferedImage unwrapImageByColumns(BufferedImage par1BufferedImage) {
int var2 = par1BufferedImage.getWidth() / 16;
BufferedImage var3 = new BufferedImage(16, par1BufferedImage.getHeight() * var2, 2);
Graphics var4 = var3.getGraphics();
for (int var5 = 0; var5 < var2; ++var5) {
var4.drawImage(
par1BufferedImage,
-var5 * 16,
var5 * par1BufferedImage.getHeight(),
(ImageObserver) null);
}
var4.dispose();
return var3;
}
/**
* Copy the supplied image onto a newly-allocated OpenGL texture, returning the allocated texture
* name
*/
public int allocateAndSetupTexture(BufferedImage par1BufferedImage) {
this.singleIntBuffer.clear();
GLAllocation.generateTextureNames(this.singleIntBuffer);
int var2 = this.singleIntBuffer.get(0);
this.setupTexture(par1BufferedImage, var2);
this.textureNameToImageMap.addKey(var2, par1BufferedImage);
return var2;
}
/** Copy the supplied image onto the specified OpenGL texture */
public void setupTexture(BufferedImage par1BufferedImage, int par2) {
if (par1BufferedImage != null) { // Spout HD
GL11.glBindTexture(GL11.GL_TEXTURE_2D, par2);
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
if (this.blurTexture) {
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);
}
if (this.clampTexture) {
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);
} else {
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
}
// Spout Start
int textureWidth = par1BufferedImage.getWidth();
int textureHeight = par1BufferedImage.getHeight();
int[] texData = new int[textureWidth * textureHeight];
byte[] texColors = new byte[textureWidth * textureHeight * 4];
// Performance reasons
boolean handled = false;
try {
java.awt.image.DataBuffer buf = par1BufferedImage.getRaster().getDataBuffer();
if (buf instanceof java.awt.image.DataBufferInt) {
int[] srcbuf = ((java.awt.image.DataBufferInt) buf).getData();
System.arraycopy(srcbuf, 0, texData, 0, srcbuf.length);
handled = true;
}
} catch (Exception ignore) {
}
if (!handled) {
par1BufferedImage.getRGB(0, 0, textureWidth, textureHeight, texData, 0, textureWidth);
}
int var8;
int var9;
int var10;
int var11;
int var12;
int var13;
int var14;
for (int var7 = 0; var7 < texData.length; ++var7) {
var8 = texData[var7] >> 24 & 255;
var9 = texData[var7] >> 16 & 255;
var10 = texData[var7] >> 8 & 255;
var11 = texData[var7] & 255;
if (this.options != null && this.options.anaglyph) {
var12 = (var9 * 30 + var10 * 59 + var11 * 11) / 100;
var13 = (var9 * 30 + var10 * 70) / 100;
var14 = (var9 * 30 + var11 * 70) / 100;
var9 = var12;
var10 = var13;
var11 = var14;
}
texColors[var7 * 4 + 0] = (byte) var9;
texColors[var7 * 4 + 1] = (byte) var10;
texColors[var7 * 4 + 2] = (byte) var11;
texColors[var7 * 4 + 3] = (byte) var8;
}
// Spout End
this.imageData = TextureUtils.getByteBuffer(this.imageData, texColors);
GL11.glTexImage2D(
GL11.GL_TEXTURE_2D,
0,
GL11.GL_RGBA,
textureWidth,
textureHeight,
0,
GL11.GL_RGBA,
GL11.GL_UNSIGNED_BYTE,
this.imageData);
}
// Spout HD End
}
public void createTextureFromBytes(int[] par1ArrayOfInteger, int par2, int par3, int par4) {
GL11.glBindTexture(GL11.GL_TEXTURE_2D, par4);
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
if (this.blurTexture) {
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);
}
if (this.clampTexture) {
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);
} else {
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
}
byte[] var5 = new byte[par2 * par3 * 4];
for (int var6 = 0; var6 < par1ArrayOfInteger.length; ++var6) {
int var7 = par1ArrayOfInteger[var6] >> 24 & 255;
int var8 = par1ArrayOfInteger[var6] >> 16 & 255;
int var9 = par1ArrayOfInteger[var6] >> 8 & 255;
int var10 = par1ArrayOfInteger[var6] & 255;
if (this.options != null && this.options.anaglyph) {
int var11 = (var8 * 30 + var9 * 59 + var10 * 11) / 100;
int var12 = (var8 * 30 + var9 * 70) / 100;
int var13 = (var8 * 30 + var10 * 70) / 100;
var8 = var11;
var9 = var12;
var10 = var13;
}
var5[var6 * 4 + 0] = (byte) var8;
var5[var6 * 4 + 1] = (byte) var9;
var5[var6 * 4 + 2] = (byte) var10;
var5[var6 * 4 + 3] = (byte) var7;
}
// Spout HD Start
this.imageData = TextureUtils.getByteBuffer(this.imageData, var5);
// Spout HD End
GL11.glTexSubImage2D(
GL11.GL_TEXTURE_2D,
0,
0,
0,
par2,
par3,
GL11.GL_RGBA,
GL11.GL_UNSIGNED_BYTE,
this.imageData);
}
/** Deletes a single GL texture */
public void deleteTexture(int par1) {
this.textureNameToImageMap.removeObject(par1);
this.singleIntBuffer.clear();
this.singleIntBuffer.put(par1);
this.singleIntBuffer.flip();
GL11.glDeleteTextures(this.singleIntBuffer);
}
/**
* Takes a URL of a downloadable image and the name of the local image to be used as a fallback.
* If the image has been downloaded, returns the GL texture of the downloaded image, otherwise
* returns the GL texture of the fallback image.
*/
public int getTextureForDownloadableImage(String par1Str, String par2Str) {
ThreadDownloadImageData var3 = (ThreadDownloadImageData) this.urlToImageDataMap.get(par1Str);
if (var3 != null && var3.image != null && !var3.textureSetupComplete) {
if (var3.textureName < 0) {
var3.textureName = this.allocateAndSetupTexture(var3.image);
} else {
this.setupTexture(var3.image, var3.textureName);
}
var3.textureSetupComplete = true;
}
return var3 != null && var3.textureName >= 0
? var3.textureName
: (par2Str == null ? -1 : this.getTexture(par2Str));
}
public boolean func_82773_c(String par1Str) {
return this.urlToImageDataMap.containsKey(par1Str);
}
/**
* Return a ThreadDownloadImageData instance for the given URL. If it does not already exist, it
* is created and uses the passed ImageBuffer. If it does, its reference count is incremented.
*/
public ThreadDownloadImageData obtainImageData(String par1Str, IImageBuffer par2IImageBuffer) {
ThreadDownloadImageData var3 = (ThreadDownloadImageData) this.urlToImageDataMap.get(par1Str);
if (var3 == null) {
this.urlToImageDataMap.put(par1Str, new ThreadDownloadImageData(par1Str, par2IImageBuffer));
} else {
++var3.referenceCount;
}
return var3;
}
/**
* Decrements the reference count for a given URL, deleting the image data if the reference count
* hits 0
*/
public void releaseImageData(String par1Str) {
ThreadDownloadImageData var2 = (ThreadDownloadImageData) this.urlToImageDataMap.get(par1Str);
if (var2 != null) {
--var2.referenceCount;
if (var2.referenceCount == 0) {
// Spout Start
if (Minecraft.theMinecraft.theWorld != null) {
List<EntityPlayer> players = Minecraft.theMinecraft.theWorld.playerEntities;
for (EntityPlayer player : players) {
if (player.skinUrl != null && player.skinUrl.equals(par1Str)) {
var2.referenceCount++;
}
if (player.playerCloakUrl != null && player.playerCloakUrl.equals(par1Str)) {
var2.referenceCount++;
}
}
}
if (var2.referenceCount > 0) {
return;
}
// Spout End
if (var2.textureName >= 0) {
this.deleteTexture(var2.textureName);
}
this.urlToImageDataMap.remove(par1Str);
}
}
}
public void registerTextureFX(TextureFX par1TextureFX) {
// Spout HD Start
TextureUtils.registerTextureFX(this.textureList, par1TextureFX);
// Spout HD End
}
public void updateDynamicTextures() {
int var1 = -1;
for (int var2 = 0; var2 < this.textureList.size(); ++var2) {
TextureFX var3 = (TextureFX) this.textureList.get(var2);
var3.anaglyphEnabled = this.options.anaglyph;
var3.onTick();
var1 = this.func_82772_a(var3, var1);
}
}
public int func_82772_a(TextureFX par1TextureFX, int par2) {
// Spout HD Start
this.imageData = TextureUtils.getByteBuffer(this.imageData, par1TextureFX.imageData);
// Spout HD End
if (par1TextureFX.iconIndex != par2) {
par1TextureFX.bindImage(this);
par2 = par1TextureFX.iconIndex;
}
for (int var3 = 0; var3 < par1TextureFX.tileSize; ++var3) {
for (int var4 = 0; var4 < par1TextureFX.tileSize; ++var4) {
GL11.glTexSubImage2D(
GL11.GL_TEXTURE_2D,
0,
par1TextureFX.iconIndex % 16 * 16 + var3 * 16,
par1TextureFX.iconIndex / 16 * 16 + var4 * 16,
16,
16,
GL11.GL_RGBA,
GL11.GL_UNSIGNED_BYTE,
this.imageData);
}
}
return par2;
}
/**
* Call setupTexture on all currently-loaded textures again to account for changes in rendering
* options
*/
public void refreshTextures() {
ITexturePack var1 = this.texturePack.getSelectedTexturePack();
Iterator var2 = this.textureNameToImageMap.getKeySet().iterator();
BufferedImage var4;
while (var2.hasNext()) {
int var3 = ((Integer) var2.next()).intValue();
var4 = (BufferedImage) this.textureNameToImageMap.lookup(var3);
this.setupTexture(var4, var3);
}
ThreadDownloadImageData var8;
for (var2 = this.urlToImageDataMap.values().iterator();
var2.hasNext();
var8.textureSetupComplete = false) {
var8 = (ThreadDownloadImageData) var2.next();
}
var2 = this.textureMap.keySet().iterator();
String var9;
while (var2.hasNext()) {
var9 = (String) var2.next();
try {
// Spout HD Start
if (var9.startsWith("##")) {
var4 =
this.unwrapImageByColumns(
TextureUtils.getResourceAsBufferedImage(this, var1, var9.substring(2)));
} else if (var9.startsWith("%clamp%")) {
this.clampTexture = true;
var4 = TextureUtils.getResourceAsBufferedImage(this, var1, var9.substring(7));
} else if (var9.startsWith("%blur%")) {
this.blurTexture = true;
var4 = TextureUtils.getResourceAsBufferedImage(this, var1, var9.substring(6));
} else if (var9.startsWith("%blurclamp%")) {
this.blurTexture = true;
this.clampTexture = true;
var4 = TextureUtils.getResourceAsBufferedImage(this, var1, var9.substring(11));
} else {
var4 = TextureUtils.getResourceAsBufferedImage(this, var1, var9);
}
if (var4 == null) {
var2.remove();
continue;
}
// Spout HD End
int var5 = ((Integer) this.textureMap.get(var9)).intValue();
this.setupTexture(var4, var5);
this.blurTexture = false;
this.clampTexture = false;
} catch (IOException var7) {
// Spout HD Start
// Gracefully handle errors
var2.remove();
// var6.printStackTrace();
// Spout HD End
}
}
var2 = this.textureContentsMap.keySet().iterator();
while (var2.hasNext()) {
var9 = (String) var2.next();
try {
// Spout HD Start
if (var9.startsWith("##")) {
var4 =
this.unwrapImageByColumns(
TextureUtils.getResourceAsBufferedImage(this, var1, var9.substring(2)));
} else if (var9.startsWith("%clamp%")) {
this.clampTexture = true;
var4 = TextureUtils.getResourceAsBufferedImage(this, var1, var9.substring(7));
} else if (var9.startsWith("%blur%")) {
this.blurTexture = true;
var4 = TextureUtils.getResourceAsBufferedImage(this, var1, var9.substring(6));
} else {
var4 = TextureUtils.getResourceAsBufferedImage(this, var1, var9);
}
if (var4 == null) {
var2.remove();
continue;
}
// Spout HD End
this.getImageContents(var4, (int[]) this.textureContentsMap.get(var9));
this.blurTexture = false;
this.clampTexture = false;
} catch (IOException var6) {
// Spout HD Start
// Gracefully handle errors
var2.remove();
// var6.printStackTrace();
// Spout HD End
}
}
}
/** Returns a BufferedImage read off the provided input stream. Args: inputStream */
private BufferedImage readTextureImage(InputStream par1InputStream) throws IOException {
BufferedImage var2 = ImageIO.read(par1InputStream);
par1InputStream.close();
return var2;
}
public void bindTexture(int par1) {
if (par1 >= 0) {
GL11.glBindTexture(GL11.GL_TEXTURE_2D, par1);
}
}
// Spout HD Start
public void setTileSize(Minecraft var1) {
this.imageData = GLAllocation.createDirectByteBuffer(TileSize.int_glBufferSize);
this.refreshTextures();
TextureUtils.refreshTextureFX(this.textureList);
}
// Spout HD End
}
public RenderEndPortal() {
field_40448_a = GLAllocation.func_1123_d(16);
}
public class ActiveRenderInfo {
public static float objectX = 0.0F;
public static float objectY = 0.0F;
public static float objectZ = 0.0F;
private static IntBuffer viewport = GLAllocation.createDirectIntBuffer(16);
private static FloatBuffer modelview = GLAllocation.createDirectFloatBuffer(16);
private static FloatBuffer projection = GLAllocation.createDirectFloatBuffer(16);
private static FloatBuffer objectCoords = GLAllocation.createDirectFloatBuffer(3);
public static float rotationX;
public static float rotationXZ;
public static float rotationZ;
public static float rotationYZ;
public static float rotationXY;
// Spout start
public static FloatBuffer modelMatrix;
public static FloatBuffer projectionMatrix;
// Spout end
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);
}
public static Vec3D projectViewFromEntity(EntityLiving par0EntityLiving, double par1) {
double var3 =
par0EntityLiving.prevPosX + (par0EntityLiving.posX - par0EntityLiving.prevPosX) * par1;
double var5 =
par0EntityLiving.prevPosY
+ (par0EntityLiving.posY - par0EntityLiving.prevPosY) * par1
+ (double) par0EntityLiving.getEyeHeight();
double var7 =
par0EntityLiving.prevPosZ + (par0EntityLiving.posZ - par0EntityLiving.prevPosZ) * par1;
double var9 = var3 + (double) (objectX * 1.0F);
double var11 = var5 + (double) (objectY * 1.0F);
double var13 = var7 + (double) (objectZ * 1.0F);
return Vec3D.createVector(var9, var11, var13);
}
public static int getBlockIdAtEntityViewpoint(
World par0World, EntityLiving par1EntityLiving, float par2) {
Vec3D var3 = projectViewFromEntity(par1EntityLiving, (double) par2);
ChunkPosition var4 = new ChunkPosition(var3);
int var5 = par0World.getBlockId(var4.x, var4.y, var4.z);
if (var5 != 0 && Block.blocksList[var5].blockMaterial.isLiquid()) {
float var6 =
BlockFluid.getFluidHeightPercent(par0World.getBlockMetadata(var4.x, var4.y, var4.z))
- 0.11111111F;
float var7 = (float) (var4.y + 1) - var6;
if (var3.yCoord >= (double) var7) {
var5 = par0World.getBlockId(var4.x, var4.y + 1, var4.z);
}
}
return var5;
}
}
