commit dccbbdd63d6e04b428f90d4db85eed76d8559faa Author: Raven Szewczyk Date: Mon Aug 22 16:27:02 2022 +0100 Initial commit from the source zip for version 2.3.18 diff --git a/LICENCE b/LICENCE new file mode 100644 index 000000000..1352fad79 --- /dev/null +++ b/LICENCE @@ -0,0 +1,173 @@ +Original license from java/shadersmodcore/client/Shaders.java, we (as GTNH developers) relicense it under LGPL. + +// Code written by daxnitro modified by id_miner and karyonix. +// Do what you want with it but give us some credit if you use it in whole or in part. + +New license: + + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. + diff --git a/README.MD b/README.MD new file mode 100644 index 000000000..f78940a10 --- /dev/null +++ b/README.MD @@ -0,0 +1,19 @@ +# Angelica +the little angle that supports shaders while saving your fps from a certain death - boubou + +Not yet in an usable state + +Original build instructions obtained via minecraftforums archeology: +``` +Developing environment + - Extract forge src to forge folder. Run "gradlew setupDecompWorkspace setupDevWorkspace" until it succeeded, then "gradlew build", then "gradlew eclipse". + - Delete everything in src\main folder inside forge folder. + - Extract smc-2.3.18-mc1.7.10-src.7z to src\main folder. + - Read patch file shadersmod-mcf.patch + - Find %userprofile%\.gradle\caches\minecraft\net\minecraftforge\forge\*\forgeSrc-*-sources.jar and extract it somewhere. + -- Select files that need to be patched and copy them to src\main with correct folder structure. + - Apply patch shadersmod-mcf.patch + - In eclipse, add java_dev folder as another source folder. + - In eclipse, exclude InitNames in src folder from build path. Use InitNames in java_dev folder instead. + - Find %userprofile%\.gradle\caches\modules-2\files-2.1\net.minecraftforge\forge\*\*\forge-*-userdev.jar and extract conf\*.csv and conf\*.srg in it to forge\conf and rename packaged.srg to joined.srg. +``` diff --git a/java/shadersmodcore/client/DefaultTexture.java b/java/shadersmodcore/client/DefaultTexture.java new file mode 100644 index 000000000..03c1e6c64 --- /dev/null +++ b/java/shadersmodcore/client/DefaultTexture.java @@ -0,0 +1,19 @@ +package shadersmodcore.client; + +import net.minecraft.client.renderer.texture.AbstractTexture; +import net.minecraft.client.resources.IResourceManager; + +public class DefaultTexture extends AbstractTexture { + + public DefaultTexture() + { + loadTexture(null); + } + + @Override + public void loadTexture(IResourceManager resourcemanager) + { + int[] aint = ShadersTex.createAIntImage(1,0xFFFFFFFF); + ShadersTex.setupTexture(this.getMultiTexID(), aint, 1, 1, false, false); + } +} diff --git a/java/shadersmodcore/client/GuiShaders.java b/java/shadersmodcore/client/GuiShaders.java new file mode 100644 index 000000000..57f031296 --- /dev/null +++ b/java/shadersmodcore/client/GuiShaders.java @@ -0,0 +1,355 @@ +package shadersmodcore.client; + +import java.io.File; +import java.io.IOException; +import java.net.URI; +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.settings.GameSettings; + +import org.lwjgl.Sys; + +public class GuiShaders extends GuiScreen +{ + /** This GUI's parent GUI. */ + protected GuiScreen parentGui; + + private int updateTimer = -1; + public boolean needReinit; + + /* + private class GuiListShaderpacks { + int posX,posY,sizeX,sizeY; + int viewPosY; + int itemHeight = 20; + int selection; + ArrayList listShaderpacks; + public void draw() { + Tessellator tess = Tessellator.instance; + int listSize = listShaderpacks.size(); + int i,j; + for (i=viewPosY/itemHeight, j=Math.min((viewPosY+sizeY)/itemHeight,listSize); i=0 && val<=choices[i]; --i) {} + if (i<0) i=choices.length-1; + } + Shaders.configHandDepthMul = choices[i]; + par1GuiButton.displayString = "HandDepth: "+String.format("%.4f",Shaders.configHandDepthMul); + break; + } + + case 15: /* Render Resolution Multiplier */ + { + float val = Shaders.configRenderResMul; + float[] choices = { 0.25f,0.3333333333f,0.5f,0.7071067812f,1.0f,1.414213562f,2.0f }; + int i; + if (!isShiftKeyDown()) { + for (i=0; i=0 && val<=choices[i]; --i) {} + if (i<0) i=choices.length-1; + } + Shaders.configRenderResMul = choices[i]; + par1GuiButton.displayString = "RenderResMul: "+String.format("%.4f",Shaders.configRenderResMul); + Shaders.scheduleResize(); + break; + } + + case 16: /* Shadow Resolution Multiplier */ + { + float val = Shaders.configShadowResMul; + float[] choices = { 0.25f,0.3333333333f,0.5f,0.7071067812f,1.0f,1.414213562f,2.0f,3.0f,4.0f }; + int i; + if (!isShiftKeyDown()) { + for (i=0; i=0 && val<=choices[i]; --i) {} + if (i<0) i=choices.length-1; + } + Shaders.configShadowResMul = choices[i]; + par1GuiButton.displayString = "ShadowResMul: "+String.format("%.4f",Shaders.configShadowResMul); + Shaders.scheduleResizeShadow(); + break; + } + + case 17: /* Normal Map */ + { + Shaders.configNormalMap = !Shaders.configNormalMap; + //displayString + par1GuiButton.displayString = "NormapMap: " +toStringOnOff(Shaders.configNormalMap); + mc.scheduleResourcesRefresh(); // schedule refresh texture + break; + } + + case 18: /* Normal Map */ + { + Shaders.configSpecularMap = !Shaders.configSpecularMap; + //displayString + par1GuiButton.displayString = "SpecularMap: " +toStringOnOff(Shaders.configSpecularMap); + mc.scheduleResourcesRefresh(); // schedule refresh texture + break; + } + + case 19: /* old Lighting */ + { + Shaders.configOldLighting = !Shaders.configOldLighting; + //displayString + par1GuiButton.displayString = "OldLighting: " +toStringOnOff(Shaders.configOldLighting); + Shaders.updateBlockLightLevel(); + mc.renderGlobal.loadRenderers(); + break; + } + + case 11: /* texture filter */ + { + Shaders.configTexMinFilB = (Shaders.configTexMinFilB+1)%Shaders.texMinFilRange; + Shaders.configTexMinFilN = Shaders.configTexMinFilS = Shaders.configTexMinFilB; + par1GuiButton.displayString = "Tex Min: " +Shaders.texMinFilDesc[Shaders.configTexMinFilB]; + ShadersTex.updateTextureMinMagFilter(); + break; + } + + case 12: /* texture filter */ + { + Shaders.configTexMagFilN = (Shaders.configTexMagFilN+1)%Shaders.texMagFilRange; + par1GuiButton.displayString = "Tex_n Mag: " +Shaders.texMagFilDesc[Shaders.configTexMagFilN]; + ShadersTex.updateTextureMinMagFilter(); + break; + } + + case 13: /* texture filter */ + { + Shaders.configTexMagFilS = (Shaders.configTexMagFilS+1)%Shaders.texMagFilRange; + par1GuiButton.displayString = "Tex_s Mag: " +Shaders.texMagFilDesc[Shaders.configTexMagFilS]; + ShadersTex.updateTextureMinMagFilter(); + break; + } + + case 14: /* shadow frustum clipping */ + { + Shaders.configShadowClipFrustrum = !Shaders.configShadowClipFrustrum; + par1GuiButton.displayString = "ShadowClipFrustrum: " +toStringOnOff(Shaders.configShadowClipFrustrum); + ShadersTex.updateTextureMinMagFilter(); + break; + } + + case 5: /* Open shaderpacks folder */ + switch(net.minecraft.util.Util.getOSType()) + { + case OSX: + { + try + { + Runtime.getRuntime().exec(new String[] {"/usr/bin/open", Shaders.shaderpacksdir.getAbsolutePath()}); + return; + } + catch (IOException var7) + { + var7.printStackTrace(); + } + } + break; + case WINDOWS: + { + String var2 = String.format("cmd.exe /C start \"Open file\" \"%s\"", new Object[] {Shaders.shaderpacksdir.getAbsolutePath()}); + + try + { + Runtime.getRuntime().exec(var2); + return; + } + catch (IOException var6) + { + var6.printStackTrace(); + } + } + break; + default: + break; + } + boolean var8 = false; + + try + { + Class var3 = Class.forName("java.awt.Desktop"); + Object var4 = var3.getMethod("getDesktop", new Class[0]).invoke((Object)null, new Object[0]); + var3.getMethod("browse", new Class[] {URI.class}).invoke(var4, new Object[] {(new File(mc.mcDataDir, Shaders.shaderpacksdirname)).toURI()}); + } + catch (Throwable var5) + { + var5.printStackTrace(); + var8 = true; + } + + if (var8) + { + System.out.println("Opening via system class!"); + Sys.openURL("file://" + Shaders.shaderpacksdir.getAbsolutePath()); + } + break; + + case 6: /* Done */ + File confshader = new File(Shaders.shadersdir,"current.cfg"); + try + { + Shaders.storeConfig(); + } + catch (Exception ex) + { + } + if (needReinit) + { + needReinit = false; + Shaders.loadShaderPack(); + Shaders.uninit(); + this.mc.renderGlobal.loadRenderers(); + } + this.mc.displayGuiScreen(this.parentGui);//displayGuiScreen + break; + + default: + this.shaderList.actionPerformed(par1GuiButton);//actionPerformed + } + } + } + + @Override + /** + * Draws the screen and all the components in it. + */ + public void drawScreen(int par1, int par2, float par3) + { + drawDefaultBackground(); // background + this.shaderList.drawScreen(par1, par2, par3);//drawScreen + + if (this.updateTimer <= 0) + { + this.shaderList.updateList(); + this.updateTimer += 20; + } + + this.drawCenteredString(this.fontRendererObj, "Shaders " , this.width / 2, 16, 0xffffff); + this.drawCenteredString(this.fontRendererObj, " v"+Shaders.versionString, this.width - 40, 10, 0x808080); + //this.drawCenteredString(this.fontRenderer, "( Place zipped Shader files here. )", this.width / 4 + 10, this.height - 26, 0x808080); + super.drawScreen(par1, par2, par3); + } + + @Override + /** + * Called from the main game loop to update the screen. + */ + public void updateScreen() + { + super.updateScreen(); + --this.updateTimer; + } + + public Minecraft getMc() + { + return this.mc; + } + + public void drawCenteredString(String par1, int par2, int par3, int par4) + { + this.drawCenteredString(this.fontRendererObj, par1, par2, par3, par4); + } + +} diff --git a/java/shadersmodcore/client/GuiSlotShaders.java b/java/shadersmodcore/client/GuiSlotShaders.java new file mode 100644 index 000000000..0b2da0d17 --- /dev/null +++ b/java/shadersmodcore/client/GuiSlotShaders.java @@ -0,0 +1,73 @@ +package shadersmodcore.client; + +import java.util.ArrayList; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiSlot; +import net.minecraft.client.renderer.Tessellator; + +class GuiSlotShaders extends GuiSlot +{ + private ArrayList shaderslist; + + final GuiShaders shadersGui; + + public GuiSlotShaders(GuiShaders par1GuiShaders) + { + //super(par1GuiShaders.getMc(), par1GuiShaders.width / 2 + 20, par1GuiShaders.height, 40, par1GuiShaders.height - 70, 16); + super(par1GuiShaders.getMc(), par1GuiShaders.width / 2 + 20, par1GuiShaders.height, 40, par1GuiShaders.height - 70, 16); + this.shadersGui = par1GuiShaders; + this.shaderslist = Shaders.listofShaders(); + } + + public void updateList() + { + this.shaderslist = Shaders.listofShaders(); + } + + @Override + /** getSize */ + protected int getSize() { + return this.shaderslist.size(); + } + + @Override + /** elementClicked */ + protected void elementClicked(int par1, boolean par2, int par3, int par4) { + Shaders.setShaderPack((String)shaderslist.get(par1)); + shadersGui.needReinit = false; + Shaders.loadShaderPack(); + Shaders.uninit(); + } + + @Override + /** isSelected */ + protected boolean isSelected(int par1) { + return ((String)this.shaderslist.get(par1)).equals(Shaders.currentshadername); + } + + @Override + /** getScrollBarX */ + protected int getScrollBarX() { + return this.width - 6; + } + + @Override + /** getContentHeight */ + protected int getContentHeight() { + return this.getSize() * 18; + } + + @Override + /** drawBackground */ + protected void drawBackground() { + //this.shadersGui.drawDefaultBackground(); + } + + @Override + /** drawSlot */ + protected void drawSlot(int par1, int par2, int par3, int par4, + Tessellator par5, int par6, int par7) { + this.shadersGui.drawCenteredString((String)this.shaderslist.get(par1), this.shadersGui.width / 4 + 10, par3 + 1, 0xffffff); + } +} diff --git a/java/shadersmodcore/client/HFNoiseTexture.java b/java/shadersmodcore/client/HFNoiseTexture.java new file mode 100644 index 000000000..4f4a4efe9 --- /dev/null +++ b/java/shadersmodcore/client/HFNoiseTexture.java @@ -0,0 +1,80 @@ +package shadersmodcore.client; + +import java.nio.ByteBuffer; +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL13; +import org.lwjgl.opengl.GL30; + +/** + * + * @author Nathanael Lane + */ +public class HFNoiseTexture { + public int texID; + public int textureUnit; + + public HFNoiseTexture(int width, int height){ + texID = GL11.glGenTextures(); + textureUnit = 15; + + byte[] image = genHFNoiseImage(width, height); + ByteBuffer data = BufferUtils.createByteBuffer(image.length); + data.put(image); + data.flip(); + + //GL13.glActiveTexture(GL13.GL_TEXTURE0 + this.textureUnit); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, texID); + GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGB, width, height, 0, + GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, data); + 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); + 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); + //GL30.glGenerateMipmap(GL11.GL_TEXTURE_2D); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0); + } + + public int getID(){ + return texID; + } + + public void destroy(){ + GL11.glDeleteTextures(texID); + texID = 0; + } + + + //from George Marsaglia's paper on XORshift PRNGs + private int random(int seed){ + seed ^= (seed << 13); + seed ^= (seed >> 17); + seed ^= (seed << 5); + return seed; + } + + private byte random(int x, int y, int z){ + int seed = (random(x) + random(y * 19)) * random(z * 23) - z; + return (byte) (random(seed) % 128); + } + + /* + * Just a random value for each pixel to get maximum frequency + */ + private byte[] genHFNoiseImage(int width, int height){ + + byte[] image = new byte[width * height * 3]; + int index = 0; + + for(int y = 0; y < height; y++){ + for(int x = 0; x < width; x++){ + for(int z = 1; z < 4; z++){ + image[index++] = random(x, y, z); + } + } + } + + return image; + } + +} diff --git a/java/shadersmodcore/client/IShaderPack.java b/java/shadersmodcore/client/IShaderPack.java new file mode 100644 index 000000000..32bbddcdd --- /dev/null +++ b/java/shadersmodcore/client/IShaderPack.java @@ -0,0 +1,11 @@ +package shadersmodcore.client; + +import java.io.InputStream; + +public interface IShaderPack { + + void close(); + + InputStream getResourceAsStream(String resName); + +} diff --git a/java/shadersmodcore/client/MultiTexID.java b/java/shadersmodcore/client/MultiTexID.java new file mode 100644 index 000000000..3013ecc0a --- /dev/null +++ b/java/shadersmodcore/client/MultiTexID.java @@ -0,0 +1,17 @@ +package shadersmodcore.client; + +import java.util.HashMap; +import java.util.Map; + +public class MultiTexID { + public int base; + public int norm; + public int spec; + + public MultiTexID(int baseTex, int normTex, int specTex) + { + base = baseTex; + norm = normTex; + spec = specTex; + } +} diff --git a/java/shadersmodcore/client/ShaderPackDefault.java b/java/shadersmodcore/client/ShaderPackDefault.java new file mode 100644 index 000000000..45353f85e --- /dev/null +++ b/java/shadersmodcore/client/ShaderPackDefault.java @@ -0,0 +1,18 @@ +package shadersmodcore.client; + +import java.io.InputStream; + +public class ShaderPackDefault implements IShaderPack { + + public ShaderPackDefault() { + } + + @Override + public void close() { + } + + @Override + public InputStream getResourceAsStream(String resName) { + return ShaderPackDefault.class.getResourceAsStream(resName); + } +} diff --git a/java/shadersmodcore/client/ShaderPackFolder.java b/java/shadersmodcore/client/ShaderPackFolder.java new file mode 100644 index 000000000..71f62cd10 --- /dev/null +++ b/java/shadersmodcore/client/ShaderPackFolder.java @@ -0,0 +1,38 @@ +package shadersmodcore.client; + +import java.io.BufferedInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.InputStream; + +public class ShaderPackFolder implements IShaderPack { + + protected File packFile; + + public ShaderPackFolder(String name, File file) + { + packFile = file; + } + + @Override + public void close() { + } + + @Override + public InputStream getResourceAsStream(String resName) + { + try + { + File resFile = new File(packFile, resName.substring(1)); + if (resFile != null) + { + return new BufferedInputStream(new FileInputStream(resFile)); + } + } + catch (Exception excp) + { + } + return null; + } + +} diff --git a/java/shadersmodcore/client/ShaderPackNone.java b/java/shadersmodcore/client/ShaderPackNone.java new file mode 100644 index 000000000..bc71008ac --- /dev/null +++ b/java/shadersmodcore/client/ShaderPackNone.java @@ -0,0 +1,22 @@ +package shadersmodcore.client; + +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; + +import javax.imageio.ImageIO; + +public class ShaderPackNone implements IShaderPack { + + public ShaderPackNone() { + } + + @Override + public void close() { + } + + @Override + public InputStream getResourceAsStream(String resName) { + return null; + } +} diff --git a/java/shadersmodcore/client/ShaderPackZip.java b/java/shadersmodcore/client/ShaderPackZip.java new file mode 100644 index 000000000..2343b2eb9 --- /dev/null +++ b/java/shadersmodcore/client/ShaderPackZip.java @@ -0,0 +1,65 @@ +package shadersmodcore.client; + +import java.io.File; +import java.io.InputStream; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + +public class ShaderPackZip implements IShaderPack { + + protected File packFile; + protected ZipFile packZipFile; + + public ShaderPackZip(String name, File file) + { + packFile = file; + packZipFile = null; + } + + @Override + public void close() + { + if(packZipFile != null) + { + try + { + packZipFile.close(); + } + catch (Exception excp) + { + } + packZipFile = null; + } + } + + @Override + public InputStream getResourceAsStream(String resName) + { + if (packZipFile == null) + { + try + { + packZipFile = new ZipFile(packFile); + } + catch (Exception excp) + { + } + } + if (packZipFile != null) + { + try + { + ZipEntry entry = packZipFile.getEntry(resName.substring(1)); + if (entry != null) + { + return packZipFile.getInputStream(entry); + } + } + catch (Exception excp) + { + } + } + return null; + } + +} diff --git a/java/shadersmodcore/client/Shaders.java b/java/shadersmodcore/client/Shaders.java new file mode 100644 index 000000000..490fb5e33 --- /dev/null +++ b/java/shadersmodcore/client/Shaders.java @@ -0,0 +1,3871 @@ +// Code written by daxnitro modified by id_miner and karyonix. +// Do what you want with it but give us some credit if you use it in whole or in part. + +package shadersmodcore.client; + +import static org.lwjgl.opengl.ARBFragmentShader.GL_FRAGMENT_SHADER_ARB; +import static org.lwjgl.opengl.ARBShaderObjects.GL_OBJECT_INFO_LOG_LENGTH_ARB; +import static org.lwjgl.opengl.ARBShaderObjects.glAttachObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glCompileShaderARB; +import static org.lwjgl.opengl.ARBShaderObjects.glCreateProgramObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glCreateShaderObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glDeleteObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glDetachObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glGetInfoLogARB; +import static org.lwjgl.opengl.ARBShaderObjects.glGetObjectParameterARB; +import static org.lwjgl.opengl.ARBShaderObjects.glGetUniformLocationARB; +import static org.lwjgl.opengl.ARBShaderObjects.glLinkProgramARB; +import static org.lwjgl.opengl.ARBShaderObjects.glShaderSourceARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniform1fARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniform1iARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniform2iARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniform3fARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniformMatrix4ARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUseProgramObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glValidateProgramARB; +import static org.lwjgl.opengl.ARBVertexShader.GL_VERTEX_SHADER_ARB; +import static org.lwjgl.opengl.ARBVertexShader.glBindAttribLocationARB; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_COLOR_ATTACHMENT0_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_COLOR_ATTACHMENT1_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_DEPTH_ATTACHMENT_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_FRAMEBUFFER_COMPLETE_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_FRAMEBUFFER_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_INVALID_FRAMEBUFFER_OPERATION_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_MAX_COLOR_ATTACHMENTS_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glBindFramebufferEXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glCheckFramebufferStatusEXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glDeleteFramebuffersEXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glFramebufferTexture2DEXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glGenFramebuffersEXT; +import static org.lwjgl.opengl.GL11.GL_ALPHA_TEST; +import static org.lwjgl.opengl.GL11.GL_ALWAYS; +import static org.lwjgl.opengl.GL11.GL_BLEND; +import static org.lwjgl.opengl.GL11.GL_CLAMP; +import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT; +import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT; +import static org.lwjgl.opengl.GL11.GL_DEPTH_COMPONENT; +import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST; +import static org.lwjgl.opengl.GL11.GL_FOG; +import static org.lwjgl.opengl.GL11.GL_LEQUAL; +import static org.lwjgl.opengl.GL11.GL_LINEAR; +import static org.lwjgl.opengl.GL11.GL_LINEAR_MIPMAP_LINEAR; +import static org.lwjgl.opengl.GL11.GL_LUMINANCE; +import static org.lwjgl.opengl.GL11.GL_MODELVIEW; +import static org.lwjgl.opengl.GL11.GL_MODELVIEW_MATRIX; +import static org.lwjgl.opengl.GL11.GL_NEAREST; +import static org.lwjgl.opengl.GL11.GL_NEAREST_MIPMAP_NEAREST; +import static org.lwjgl.opengl.GL11.GL_NONE; +import static org.lwjgl.opengl.GL11.GL_NO_ERROR; +import static org.lwjgl.opengl.GL11.GL_PROJECTION; +import static org.lwjgl.opengl.GL11.GL_PROJECTION_MATRIX; +import static org.lwjgl.opengl.GL11.GL_QUADS; +import static org.lwjgl.opengl.GL11.GL_RGB16; +import static org.lwjgl.opengl.GL11.GL_RGB8; +import static org.lwjgl.opengl.GL11.GL_RGBA; +import static org.lwjgl.opengl.GL11.GL_RGBA16; +import static org.lwjgl.opengl.GL11.GL_RGBA8; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_MAG_FILTER; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_MIN_FILTER; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_WRAP_S; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_WRAP_T; +import static org.lwjgl.opengl.GL11.GL_TRUE; +import static org.lwjgl.opengl.GL11.glBegin; +import static org.lwjgl.opengl.GL11.glBindTexture; +import static org.lwjgl.opengl.GL11.glClear; +import static org.lwjgl.opengl.GL11.glClearColor; +import static org.lwjgl.opengl.GL11.glColor4f; +import static org.lwjgl.opengl.GL11.glColorMask; +import static org.lwjgl.opengl.GL11.glCopyTexSubImage2D; +import static org.lwjgl.opengl.GL11.glDeleteTextures; +import static org.lwjgl.opengl.GL11.glDepthFunc; +import static org.lwjgl.opengl.GL11.glDepthMask; +import static org.lwjgl.opengl.GL11.glDisable; +import static org.lwjgl.opengl.GL11.glEnable; +import static org.lwjgl.opengl.GL11.glEnd; +import static org.lwjgl.opengl.GL11.glFlush; +import static org.lwjgl.opengl.GL11.glGenTextures; +import static org.lwjgl.opengl.GL11.glGetError; +import static org.lwjgl.opengl.GL11.glGetFloat; +import static org.lwjgl.opengl.GL11.glGetInteger; +import static org.lwjgl.opengl.GL11.glLoadIdentity; +import static org.lwjgl.opengl.GL11.glMatrixMode; +import static org.lwjgl.opengl.GL11.glOrtho; +import static org.lwjgl.opengl.GL11.glPopMatrix; +import static org.lwjgl.opengl.GL11.glPushMatrix; +import static org.lwjgl.opengl.GL11.glReadBuffer; +import static org.lwjgl.opengl.GL11.glReadPixels; +import static org.lwjgl.opengl.GL11.glRotatef; +import static org.lwjgl.opengl.GL11.glTexCoord2f; +import static org.lwjgl.opengl.GL11.glTexImage2D; +import static org.lwjgl.opengl.GL11.glTexParameterf; +import static org.lwjgl.opengl.GL11.glTexParameteri; +import static org.lwjgl.opengl.GL11.glTranslatef; +import static org.lwjgl.opengl.GL11.glVertex3f; +import static org.lwjgl.opengl.GL11.glViewport; +import static org.lwjgl.opengl.GL13.GL_TEXTURE0; +import static org.lwjgl.opengl.GL13.GL_TEXTURE1; +import static org.lwjgl.opengl.GL13.GL_TEXTURE11; +import static org.lwjgl.opengl.GL13.GL_TEXTURE12; +import static org.lwjgl.opengl.GL13.GL_TEXTURE13; +import static org.lwjgl.opengl.GL13.GL_TEXTURE14; +import static org.lwjgl.opengl.GL13.GL_TEXTURE2; +import static org.lwjgl.opengl.GL13.GL_TEXTURE3; +import static org.lwjgl.opengl.GL13.GL_TEXTURE4; +import static org.lwjgl.opengl.GL13.GL_TEXTURE5; +import static org.lwjgl.opengl.GL13.GL_TEXTURE6; +import static org.lwjgl.opengl.GL13.GL_TEXTURE7; +import static org.lwjgl.opengl.GL13.glActiveTexture; +import static org.lwjgl.opengl.GL14.GL_DEPTH_TEXTURE_MODE; +import static org.lwjgl.opengl.GL14.GL_TEXTURE_COMPARE_MODE; +import static org.lwjgl.opengl.GL20.GL_MAX_DRAW_BUFFERS; +import static org.lwjgl.opengl.GL20.GL_MAX_TEXTURE_IMAGE_UNITS; +import static org.lwjgl.opengl.GL20.GL_VALIDATE_STATUS; +import static org.lwjgl.opengl.GL20.glDrawBuffers; +import static org.lwjgl.opengl.GL20.glGetProgrami; +import static org.lwjgl.opengl.GL30.GL_COMPARE_REF_TO_TEXTURE; +import static org.lwjgl.opengl.GL30.GL_R16; +import static org.lwjgl.opengl.GL30.GL_R32F; +import static org.lwjgl.opengl.GL30.GL_R8; +import static org.lwjgl.opengl.GL30.GL_RG16; +import static org.lwjgl.opengl.GL30.GL_RG32F; +import static org.lwjgl.opengl.GL30.GL_RG8; +import static org.lwjgl.opengl.GL30.GL_RGB32F; +import static org.lwjgl.opengl.GL30.GL_RGBA32F; +import static org.lwjgl.opengl.GL30.glGenerateMipmap; +import static org.lwjgl.util.glu.GLU.gluErrorString; +import static org.lwjgl.util.glu.GLU.gluPerspective; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.InputStreamReader; +import java.nio.ByteBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.Properties; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.Minecraft; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; +import net.minecraft.client.renderer.EntityRenderer; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.entity.Render; +import net.minecraft.client.renderer.entity.RenderManager; +import net.minecraft.client.renderer.entity.RendererLivingEntity; +import net.minecraft.client.renderer.texture.ITextureObject; +import net.minecraft.client.settings.GameSettings; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.Vec3; + +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.ContextCapabilities; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; +import org.lwjgl.opengl.GLContext; +//import org.lwjgl.opengl.ARBVertexProgram; + +public class Shaders { + + public static final String versionString = "2.3.18"; + public static final int versionNumber = 0x020312; + public static final int buildNumber = 53; + + private static Minecraft mc; + + public static boolean isInitialized = false; + private static boolean notFirstInit = false; + public static ContextCapabilities capabilities; + public static boolean hasGlGenMipmap = false; + public static int numberResetDisplayList = 0; + + private static int renderDisplayWidth = 0; + private static int renderDisplayHeight = 0; + public static int renderWidth = 0; + public static int renderHeight = 0; + + public static boolean isRenderingWorld = false; + public static boolean isRenderingSky = false; + public static boolean isCompositeRendered = false; + public static boolean isRenderingDfb = false; + public static boolean isShadowPass = false; + public static int activeTexUnit = 0; + + public static boolean isHandRendered; + public static ItemStack itemToRender; + + private static float[] sunPosition = new float[4]; + private static float[] moonPosition = new float[4]; + private static float[] upPosition = new float[4]; + + private static float[] upPosModelView = new float[]{ 0.0F, 100.0F, 0.0F, 0.0F}; + private static float[] sunPosModelView = new float[]{ 0.0F, 100.0F, 0.0F, 0.0F}; + private static float[] moonPosModelView = new float[]{ 0.0F,-100.0F, 0.0F, 0.0F}; + private static float[] tempMat = new float[16]; + + private static float clearColorR; + private static float clearColorG; + private static float clearColorB; + + private static float skyColorR; + private static float skyColorG; + private static float skyColorB; + + private static long worldTime = 0; + private static long lastWorldTime = 0; + private static long diffWorldTime = 0; + private static float sunAngle = 0; + private static float shadowAngle = 0; + private static int moonPhase = 0; + + private static long systemTime = 0; + private static long lastSystemTime = 0; + private static long diffSystemTime = 0; + + private static int frameCounter = 0; + private static float frameTimeCounter = 0.0f; + + private static int systemTimeInt32 = 0; + + private static float rainStrength = 0.0f; + private static float wetness = 0.0f; + public static float wetnessHalfLife = 30*20; + public static float drynessHalfLife = 10*20; + public static float eyeBrightnessHalflife = 10.0f; + private static boolean usewetness = false; + private static int isEyeInWater = 0; + private static int eyeBrightness = 0; + private static float eyeBrightnessFadeX = 0; + private static float eyeBrightnessFadeY = 0; + private static float eyePosY = 0; + private static float centerDepth = 0; + private static float centerDepthSmooth = 0; + private static float centerDepthSmoothHalflife = 1.0f; + private static boolean centerDepthSmoothEnabled = false; + private static int superSamplingLevel = 1; + + private static boolean updateChunksErrorRecorded = false; + + private static boolean lightmapEnabled = false; + private static boolean fogEnabled = true; + + public static int entityAttrib = 10; + public static int midTexCoordAttrib = 11; + public static boolean useEntityAttrib = false; + public static boolean useMidTexCoordAttrib = false; + public static boolean useMultiTexCoord3Attrib = false; + public static boolean progUseEntityAttrib = false; + public static boolean progUseMidTexCoordAttrib = false; + + public static int atlasSizeX = 0, atlasSizeY = 0; + public static int uniformEntityHurt = -1; + public static int uniformEntityFlash = -1; + public static boolean useEntityHurtFlash; + + private static double[] previousCameraPosition = new double[3]; + private static double[] cameraPosition = new double[3]; + + // Shadow stuff + + // configuration + private static int shadowPassInterval = 0; + public static boolean needResizeShadow = false; + private static int shadowMapWidth = 1024; + private static int shadowMapHeight = 1024; + private static int spShadowMapWidth = 1024; + private static int spShadowMapHeight = 1024; + private static float shadowMapFOV = 90.0f; + private static float shadowMapHalfPlane = 160.0f; + private static boolean shadowMapIsOrtho = true; + + private static int shadowPassCounter = 0; + + private static int preShadowPassThirdPersonView; + + public static boolean shouldSkipDefaultShadow = false; + + + private static boolean waterShadowEnabled = false; + + + // Color attachment stuff + + private static final int MaxDrawBuffers = 8; + private static final int MaxColorBuffers = 8; + private static final int MaxDepthBuffers = 3; + private static final int MaxShadowColorBuffers = 8; + private static final int MaxShadowDepthBuffers = 2; + private static int usedColorBuffers = 0; + private static int usedDepthBuffers = 0; + private static int usedShadowColorBuffers = 0; + private static int usedShadowDepthBuffers = 0; + private static int usedColorAttachs = 0; + private static int usedDrawBuffers = 0; + + private static int dfb = 0; + private static int sfb = 0; + + private static int[] gbuffersFormat = new int[MaxColorBuffers]; + + // Program stuff + + public static int activeProgram = 0; + + public final static int ProgramNone = 0; + public final static int ProgramBasic = 1; + public final static int ProgramTextured = 2; + public final static int ProgramTexturedLit = 3; + public final static int ProgramSkyBasic = 4; + public final static int ProgramSkyTextured = 5; + public final static int ProgramTerrain = 6; + public final static int ProgramWater = 7; + public final static int ProgramEntities = 8; + public final static int ProgramSpiderEyes = 9; + public final static int ProgramHand = 10; + public final static int ProgramWeather = 11; + public final static int ProgramComposite = 12; + public final static int ProgramComposite1 = 13; + public final static int ProgramComposite2 = 14; + public final static int ProgramComposite3 = 15; + public final static int ProgramComposite4 = 16; + public final static int ProgramComposite5 = 17; + public final static int ProgramComposite6 = 18; + public final static int ProgramComposite7 = 19; + public final static int ProgramFinal = 20; + public final static int ProgramShadow = 21; + public final static int ProgramCount = 22; + public final static int MaxCompositePasses = 8; + + private static final String[] programNames = new String[] { + "", + "gbuffers_basic", + "gbuffers_textured", + "gbuffers_textured_lit", + "gbuffers_skybasic", + "gbuffers_skytextured", + "gbuffers_terrain", + "gbuffers_water", + "gbuffers_entities", + "gbuffers_spidereyes", + "gbuffers_hand", + "gbuffers_weather", + "composite", + "composite1", + "composite2", + "composite3", + "composite4", + "composite5", + "composite6", + "composite7", + "final", + "shadow", + }; + + private static final int[] programBackups = new int[] { + ProgramNone, // none + ProgramNone, // basic + ProgramBasic, // textured + ProgramTextured, // textured/lit + ProgramBasic, // skybasic + ProgramTextured, // skytextured + ProgramTexturedLit, // terrain + ProgramTerrain, // water + ProgramTexturedLit, // entities + ProgramTextured, // spidereyes + ProgramTexturedLit, // hand + ProgramTexturedLit, // weather + ProgramNone, // composite + ProgramNone, // composite1 + ProgramNone, // composite2 + ProgramNone, // composite3 + ProgramNone, // composite4 + ProgramNone, // composite5 + ProgramNone, // composite6 + ProgramNone, // composite7 + ProgramNone, // final + ProgramNone, // shadow + }; + + private static int[] programsID = new int[ProgramCount]; + private static int[] programsRef = new int[ProgramCount]; + private static int programIDCopyDepth = 0; + + private static String[] programsDrawBufSettings = new String[ProgramCount]; + private static String newDrawBufSetting = null; + private static IntBuffer[] programsDrawBuffers = new IntBuffer[ProgramCount]; + static IntBuffer activeDrawBuffers = null; + + private static String[] programsColorAtmSettings = new String[ProgramCount]; + private static String newColorAtmSetting = null; + private static String activeColorAtmSettings = null; + + private static int[] programsCompositeMipmapSetting = new int[ProgramCount]; + private static int newCompositeMipmapSetting = 0; + private static int activeCompositeMipmapSetting = 0; + + public static Properties loadedShaders = null; + public static Properties shadersConfig = null; + + //public static TextureManager textureManager = null; + public static ITextureObject defaultTexture = null; + public static boolean normalMapEnabled = false; + public static boolean[] shadowHardwareFilteringEnabled = new boolean[MaxShadowDepthBuffers]; + public static boolean[] shadowMipmapEnabled = new boolean[MaxShadowDepthBuffers]; + public static boolean[] shadowFilterNearest = new boolean[MaxShadowDepthBuffers]; + public static boolean[] shadowColorMipmapEnabled = new boolean[MaxShadowColorBuffers]; + public static boolean[] shadowColorFilterNearest = new boolean[MaxShadowColorBuffers]; + + // config + public static boolean configTweakBlockDamage = false; + public static boolean configCloudShadow = true; + public static float configHandDepthMul = 0.125f; + public static float configRenderResMul = 1.0f; + public static float configShadowResMul = 1.0f; + public static int configTexMinFilB = 0; + public static int configTexMinFilN = 0; + public static int configTexMinFilS = 0; + public static int configTexMagFilB = 0; + public static int configTexMagFilN = 0; + public static int configTexMagFilS = 0; + public static boolean configShadowClipFrustrum = true; + public static boolean configNormalMap = true; + public static boolean configSpecularMap = true; + public static boolean configOldLighting = false; + + // related to config + public static final int texMinFilRange = 3; + public static final int texMagFilRange = 2; + public static final String[] texMinFilDesc = { "Nearest","Nearest-Nearest","Nearest-Linear" }; + public static final String[] texMagFilDesc = { "Nearest","Linear" }; + public static final int[] texMinFilValue = { GL11.GL_NEAREST, GL11.GL_NEAREST_MIPMAP_NEAREST, GL11.GL_NEAREST_MIPMAP_LINEAR }; + public static final int[] texMagFilValue = { GL11.GL_NEAREST, GL11.GL_LINEAR }; + + // shaderpack + static IShaderPack shaderPack = null; + static File currentshader; + static String currentshadername; + static String packNameNone = "(none)"; + static String packNameDefault = "(internal)"; + static String shaderpacksdirname = "shaderpacks"; + static String optionsfilename = "optionsshaders.txt"; + static File shadersdir = new File(Minecraft.getMinecraft().mcDataDir,"shaders"); + static File shaderpacksdir = new File(Minecraft.getMinecraft().mcDataDir,shaderpacksdirname); + static File configFile = new File(Minecraft.getMinecraft().mcDataDir, optionsfilename); + + public static final boolean enableShadersOption = true; + private static final boolean enableShadersDebug = true; + + public static float blockLightLevel05 = 0.5f; + public static float blockLightLevel06 = 0.6f; + public static float blockLightLevel08 = 0.8f; + + public static float aoLevel = 0.8f; + public static float blockAoLight = 1.0f - aoLevel; + + public static float sunPathRotation = 0.0f; + public static float shadowAngleInterval = 0.0f; + public static int fogMode = 0; + public static float fogColorR, fogColorG, fogColorB; + public static float shadowIntervalSize = 2.0f; + public static int terrainIconSize = 16; + public static int[] terrainTextureSize = new int[2]; + + private static HFNoiseTexture noiseTexture; + private static boolean noiseTextureEnabled = false; + private static int noiseTextureResolution = 256; + + // direct buffers + private static final int bigBufferSize = ( + 16*12 + + MaxColorBuffers + MaxDepthBuffers + MaxShadowColorBuffers + MaxShadowDepthBuffers + + MaxDrawBuffers*8 + MaxDrawBuffers*ProgramCount + )*4; + private static final ByteBuffer bigBuffer = (ByteBuffer)BufferUtils.createByteBuffer(bigBufferSize).limit(0); + + private static final FloatBuffer previousProjection = nextFloatBuffer(16); + private static final FloatBuffer projection = nextFloatBuffer(16); + private static final FloatBuffer projectionInverse = nextFloatBuffer(16); + private static final FloatBuffer previousModelView = nextFloatBuffer(16); + private static final FloatBuffer modelView = nextFloatBuffer(16); + private static final FloatBuffer modelViewInverse = nextFloatBuffer(16); + private static final FloatBuffer shadowProjection = nextFloatBuffer(16); + private static final FloatBuffer shadowProjectionInverse = nextFloatBuffer(16); + private static final FloatBuffer shadowModelView = nextFloatBuffer(16); + private static final FloatBuffer shadowModelViewInverse = nextFloatBuffer(16); + private static final FloatBuffer tempMatrixDirectBuffer = nextFloatBuffer(16); + private static final FloatBuffer tempDirectFloatBuffer = nextFloatBuffer(16); + + private static final IntBuffer dfbColorTextures = nextIntBuffer(MaxColorBuffers); + private static final IntBuffer dfbDepthTextures = nextIntBuffer(MaxDepthBuffers); + private static final IntBuffer sfbColorTextures = nextIntBuffer(MaxShadowColorBuffers); + private static final IntBuffer sfbDepthTextures = nextIntBuffer(MaxShadowDepthBuffers); + + static final IntBuffer dfbDrawBuffers = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer sfbDrawBuffers = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersNone = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersAll = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersClear0 = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersClear1 = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersClearColor = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersColorAtt0 = nextIntBuffer(MaxDrawBuffers); + + static final IntBuffer[] drawBuffersBuffer = nextIntBufferArray(ProgramCount, MaxDrawBuffers); + + //static final String ofVersion = "OptiFine_x.x.x_HD_U_xx"; + //static final String ofVersion = Config.VERSION; + + //static int lastversion = version; + //static int updateinterval = 48; + //public static final String siteurl = "http://glslshadersof.no-ip.org"; + //public static final String updatecheckurl = "http:....../lastversion145.html"; + //static JFrame frame; + + static { + drawBuffersNone.limit(0); + drawBuffersColorAtt0.put(GL_COLOR_ATTACHMENT0_EXT).position(0).limit(1); + } + + private Shaders() { + } + + /** set position to limit and advance limit by size */ + private static ByteBuffer nextByteBuffer(int size) + { + ByteBuffer buffer = bigBuffer; + int pos = buffer.limit(); + buffer.position(pos).limit(pos+size); + return buffer.slice(); + } + + private static IntBuffer nextIntBuffer(int size) + { + ByteBuffer buffer = bigBuffer; + int pos = buffer.limit(); + buffer.position(pos).limit(pos+size*4); + return buffer.asIntBuffer(); + } + + private static FloatBuffer nextFloatBuffer(int size) + { + ByteBuffer buffer = bigBuffer; + int pos = buffer.limit(); + buffer.position(pos).limit(pos+size*4); + return buffer.asFloatBuffer(); + } + + private static IntBuffer[] nextIntBufferArray(int count, int size) + { + IntBuffer[] aib = new IntBuffer[count]; + for (int i=0; i 0 && vv < 24 ) || vv > 736) + { + System.out.println("[Shaders] Skipping bad option: updateinterval, range is: 0, 24-736"); + } + else + { + updateinterval = vv; + } + } + else if (as[0].equals("lastcheck")) + { + lastcheck = Integer.parseInt(as[1]); + } + else if (as[0].equals("lastversion")) + { + lastversion = Integer.parseInt(as[1]); + } + } + catch (Exception exception1) + { + System.out.println("[Shaders] "+(new StringBuilder()).append("Skipping bad option: ").append(s).toString()); + } + } + bufferedreader2.close(); + } + } + catch(Exception ex){} + + if (updateinterval > 0) + { + try + { + if (lastversion > version) + { + updatenotify(versiontostring(lastversion)); + System.out.println("[Shaders] New version "+versiontostring(lastversion)+" of the GLSL Shaders OF mod is available, go to "+ siteurl +" to download."); + } + else + { + int currenthours = (int) (System.currentTimeMillis() / 3600000); + if (currenthours - lastcheck > updateinterval ) + { + System.out.println("[Shaders] Checking for updates. Last checked "+Integer.toString(currenthours - lastcheck)+" hours ago."); + lastcheck = currenthours; + try + { + URL url = new URL( updatecheckurl ); + HttpURLConnection.setFollowRedirects(true); + HttpURLConnection uconn; + uconn = (HttpURLConnection) url.openConnection(); + uconn.setConnectTimeout(2500); + uconn.setReadTimeout(1500); + try + { + uconn.connect(); + } + catch (SocketTimeoutException excep) + { + System.out.println("[Shaders] Failed to connect to " + updatecheckurl); + return; + } + + BufferedReader bufferedreader2 = new BufferedReader(new InputStreamReader( uconn.getInputStream())); + + for (String s = ""; (s = bufferedreader2.readLine()) != null;) + { + try + { + String as[] = s.split(":"); + if (as[1].equals("lastversion")) + { + lastversion = Integer.parseInt(as[2]); + break; + } + } + catch (Exception exception1){} + } + bufferedreader2.close(); + } + catch (Exception exception) + { + System.out.println("[Shaders] Failed to download " + updatecheckurl); + return; + } + + BufferedWriter bufferedwriter2 = new BufferedWriter(new FileWriter(updatecheck)); + bufferedwriter2.write("updateinterval:"+updateinterval); + bufferedwriter2.newLine(); + bufferedwriter2.write("lastcheck:"+Integer.toString(lastcheck)); + bufferedwriter2.newLine(); + bufferedwriter2.write("lastversion:"+Integer.toString(lastversion)); + bufferedwriter2.newLine(); + bufferedwriter2.close(); + + if (lastversion > version) + { + updatenotify(versiontostring(lastversion)); + System.out.println("[Shaders] New version "+versiontostring(lastversion)+" of the GLSL Shaders OF mod is available, go to "+ siteurl +" to download."); + } + } + } + } + catch (Exception exception) + { + System.out.println("[Shaders] Failed to load GLSL Shaders update file."); + exception.printStackTrace(); + } + } + } + + public static void updatenotify(String lastversion) + { + try + { + frame = new JFrame("GLSL Shaders OF mod update"); + } + catch(Exception e) + { + return; + } + + Color bgcolor=new Color(194,205,234); + Color txcolor=new Color(50,50,50); + frame.setLocation(20,20); + JLabel label=new JLabel("New version of the GLSL Shaders OF mod is available! (v"+lastversion+") "); + JPanel panel = new JPanel(); + panel.setBackground(bgcolor); + label.setForeground(txcolor); + label.setFont(new Font("Dialog", 1, 14)); + panel.add(label); + + if( java.awt.Desktop.isDesktopSupported() ) + { + JButton button; + final java.awt.Desktop desktop = java.awt.Desktop.getDesktop(); + if( desktop.isSupported( java.awt.Desktop.Action.BROWSE ) ) + { + button = new JButton("Download"); + button.setActionCommand("BPUPD"); + + } + else + { + button = new JButton("Copy URL to Clipboard"); + button.setActionCommand("CPURL"); + } + button.setFont(new Font("Dialog", 1, 14)); + button.addActionListener(new ButtonListener()); + panel.add(button); + } + frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); + frame.getContentPane().add(panel); + frame.pack(); + frame.setFocusableWindowState(false); + frame.setVisible(true); + frame.setFocusableWindowState(true); + } + + static class ButtonListener implements ActionListener + { + ButtonListener() + { + } + public void actionPerformed(ActionEvent e) + { + String cmd = e.getActionCommand(); + if (cmd == "BPUPD") + { + try + { + java.net.URI uri = new java.net.URI( siteurl ); + java.awt.Desktop.getDesktop().browse( uri ); + frame.dispose(); + } + catch ( Exception exx ) {} + } + else if (cmd == "CPURL") + { + StringSelection ss = new StringSelection(siteurl); + Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss, null); + } + + } + } +*/ + + public static void loadConfig() + { + System.out.println("[Shaders] Loading configuration."); + try { + if (!shaderpacksdir.exists()) + shaderpacksdir.mkdir(); + } catch (Exception e) { + System.err.println("[Shaders] Failed openning shaderpacks directory."); + } + + shadersConfig = new Properties(); + shadersConfig.setProperty("shaderPack", ""); + if (configFile.exists()) + { + try { + FileReader reader = new FileReader(configFile); + shadersConfig.load(reader); + reader.close(); + } catch (Exception e) { + } + } + + if (!configFile.exists()) + { + try { + storeConfig(); + } catch (Exception e) { + } + } + String value = null; + configNormalMap = Boolean.parseBoolean(shadersConfig.getProperty("normalMapEnabled","true")); + configSpecularMap = Boolean.parseBoolean(shadersConfig.getProperty("specularMapEnabled","true")); + configTweakBlockDamage = Boolean.parseBoolean(shadersConfig.getProperty("tweakBlockDamage",shadersConfig.getProperty("dtweak","false"))); + configCloudShadow = Boolean.parseBoolean(shadersConfig.getProperty("cloudShadow","true")); + configHandDepthMul = Float.parseFloat(shadersConfig.getProperty("handDepthMul","0.125")); + configRenderResMul = Float.parseFloat(shadersConfig.getProperty("renderResMul","1.0")); + configShadowResMul = Float.parseFloat(shadersConfig.getProperty("shadowResMul","1.0")); + configShadowClipFrustrum = Boolean.parseBoolean(shadersConfig.getProperty("shadowClipFrustrum","true")); + configOldLighting = Boolean.parseBoolean(shadersConfig.getProperty("oldLighting","false")); + configTexMinFilB = Integer.parseInt(shadersConfig.getProperty("TexMinFilB","0")) % texMinFilRange; + configTexMinFilN = Integer.parseInt(shadersConfig.getProperty("TexMinFilN",Integer.toString(configTexMinFilB))) % texMinFilRange; + configTexMinFilS = Integer.parseInt(shadersConfig.getProperty("TexMinFilS",Integer.toString(configTexMinFilB))) % texMinFilRange; + configTexMagFilB = Integer.parseInt(shadersConfig.getProperty("TexMagFilB","0")) % texMagFilRange; + configTexMagFilN = Integer.parseInt(shadersConfig.getProperty("TexMagFilN","0")) % texMagFilRange; + configTexMagFilS = Integer.parseInt(shadersConfig.getProperty("TexMagFilS","0")) % texMagFilRange; + currentshadername = shadersConfig.getProperty("shaderPack", packNameDefault); + loadShaderPack(); + } + + public static void storeConfig() + { + System.out.println("[Shaders] Save configuration."); + shadersConfig.setProperty("normalMapEnabled", Boolean.toString(configNormalMap)); + shadersConfig.setProperty("specularMapEnabled", Boolean.toString(configSpecularMap)); + shadersConfig.setProperty("tweakBlockDamage", Boolean.toString(configTweakBlockDamage)); + shadersConfig.setProperty("cloudShadow", Boolean.toString(configCloudShadow)); + shadersConfig.setProperty("handDepthMul", Float.toString(configHandDepthMul)); + shadersConfig.setProperty("renderResMul", Float.toString(configRenderResMul)); + shadersConfig.setProperty("shadowResMul", Float.toString(configShadowResMul)); + shadersConfig.setProperty("shadowClipFrustrum", Boolean.toString(configShadowClipFrustrum)); + shadersConfig.setProperty("oldLighting", Boolean.toString(configOldLighting)); + shadersConfig.setProperty("TexMinFilB", Integer.toString(configTexMinFilB)); + shadersConfig.setProperty("TexMinFilN", Integer.toString(configTexMinFilN)); + shadersConfig.setProperty("TexMinFilS", Integer.toString(configTexMinFilS)); + shadersConfig.setProperty("TexMagFilB", Integer.toString(configTexMagFilB)); + shadersConfig.setProperty("TexMagFilN", Integer.toString(configTexMagFilN)); + shadersConfig.setProperty("TexMagFilS", Integer.toString(configTexMagFilS)); + try + { + FileWriter writer = new FileWriter(configFile); + shadersConfig.store(writer, null); + writer.close(); + } + catch (Exception ex) + {} + } + + public static void setShaderPack(String par1name) { + currentshadername = par1name; + shadersConfig.setProperty("shaderPack", par1name); + //loadShaderPack(); + } + + public static void loadShaderPack() + { + if (shaderPack != null) { + shaderPack.close(); + shaderPack = null; + } + String packName = shadersConfig.getProperty("shaderPack", packNameDefault); + if (!packName.isEmpty() && !packName.equals(packNameNone)) { + if (packName.equals(packNameDefault)) { + shaderPack = new ShaderPackDefault(); + } else { + try { + File packFile = new File(shaderpacksdir, packName); + if (packFile.isDirectory()) { + shaderPack = new ShaderPackFolder(packName, packFile); + } else if (packFile.isFile() && packName.toLowerCase().endsWith(".zip")) { + shaderPack = new ShaderPackZip(packName, packFile); + } + } + catch(Exception e) + { + } + } + } + if (shaderPack != null) { + System.out.println("[Shaders] Loaded shaderpack."); + } else { + System.out.println("[Shaders] Did not load shaderpack."); + shaderPack = new ShaderPackNone(); + } + } + +// public static void loadShader0() +// { +// Set shaderfiles = new HashSet(); +// for (int si = 1; si < 10; si++) +// { +// shaderfiles.add(programNames[si]+".fsh"); +// shaderfiles.add(programNames[si]+".vsh"); +// } +// +// try +// { +// +// ZipInputStream inp = new ZipInputStream(new FileInputStream(currentshader)); +// System.out.println("[Shaders] Shader selected: " + currentshadername); +// boolean found = false; +// +// ZipEntry entry = inp.getNextEntry(); +// while(entry != null ) +// { +// if (entry.isDirectory()) +// { +// if (entry.getName().toLowerCase().contains("shaders/contents/files/shaders/")) +// { +// found = true; +// break; +// } +// } +// entry = inp.getNextEntry(); +// } +// +// if (!found) +// { +// inp.close(); +// inp = new ZipInputStream(new FileInputStream(currentshader)); +// entry = inp.getNextEntry(); +// while(entry != null ) +// { +// if (entry.isDirectory()) +// { +// if (entry.getName().toLowerCase().contains("shaders/")) +// { +// found = true; +// break; +// } +// } +// entry = inp.getNextEntry(); +// } +// } +// +// if (!found) +// { +// inp.close(); +// inp = new ZipInputStream(new FileInputStream(currentshader)); +// entry = inp.getNextEntry(); +// } +// +// byte[] buf = new byte[1024]; +// int n; +// String zipfile; +// String zippath = ""; +// String zippathfile; +// +// FileOutputStream fileoutputstream, fileoutputstream2; +// boolean seusrc5tweak = false; +// +// while(entry != null && shaderfiles.size() > 0) +// { +// zipfile = new File(entry.getName()).getName(); +// if (shaderfiles.contains(zipfile) && !entry.isDirectory()) +// { +// zippathfile = new File(entry.getName()).getPath(); +// if (shaderfiles.size() == 18) +// { +// zippath = zippathfile.substring(0,zippathfile.length()-zipfile.length()); +// } +// if (zippathfile.equals(zippath+zipfile)) +// { +// shaderfiles.remove(zipfile); +// if (zipfile.equals("gbuffers_water.vsh") && entry.getCrc() == 2530345120L ) seusrc5tweak = true; +// +// fileoutputstream = new FileOutputStream(shadersdir + File.separator + "temp" + File.separator + zipfile); +// while ((n = inp.read(buf, 0, 1024)) > -1) fileoutputstream.write(buf, 0, n); +// fileoutputstream.close(); +// System.out.println("[Shaders] Shader loaded: " + zippathfile); +// } +// } +// entry = inp.getNextEntry(); +// } +// inp.close(); +// +// if (seusrc5tweak) +// { +// new File(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.fsh").delete(); +// new File(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.vsh").delete(); +// FileInputStream file = new FileInputStream(shadersdir + File.separator + "temp" + File.separator + "gbuffers_textured_lit.fsh"); +// FileOutputStream file2 = new FileOutputStream(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.fsh",false); +// while ((n = file.read(buf, 0, 1024)) > -1) file2.write(buf, 0, n); +// file.close(); +// file2.close(); +// file = new FileInputStream(shadersdir + File.separator + "temp" + File.separator + "gbuffers_textured_lit.vsh"); +// file2 = new FileOutputStream(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.vsh",false); +// while ((n = file.read(buf, 0, 1024)) > -1) file2.write(buf, 0, n); +// file.close(); +// file2.close(); +// System.out.println("[Shaders] Detected SEUS v10 RC5, copied gbuffers_textured_lit. to gbuffers_water."); +// } +// } +// catch (Exception exc) +// {} +// +// isInitialized = false; +// if (shaderfiles.size() == 18 ) System.out.println("[Shaders] No Shader found in: " + currentshadername); +// else System.out.println("[Shaders] Shader loaded: " + currentshadername); +// } + + + static ArrayList listofShaders() + { + ArrayList list = new ArrayList(); + list.add(packNameNone); + list.add(packNameDefault); + try { + if (!shaderpacksdir.exists()) + shaderpacksdir.mkdir(); + File[] listOfFiles = shaderpacksdir.listFiles(); + for (int i = 0; i < listOfFiles.length; i++) + { + File file = listOfFiles[i]; + String name = file.getName(); + if (file.isDirectory() || + file.isFile() && name.toLowerCase().endsWith(".zip")) + { + list.add(name); + } + } + } + catch (Exception e) { + } + return list; + } + + + static String versiontostring(int vv) + { + String vs = Integer.toString(vv); + return Integer.toString(Integer.parseInt(vs.substring(1,3)))+"."+Integer.toString(Integer.parseInt(vs.substring(3,5)))+"."+Integer.toString(Integer.parseInt(vs.substring(5))); + } + + + static void checkOptifine() + { + /* + try + { + System.out.println("[Shaders] Required OptiFine version : " + ofVersion); + String configVersion = (String)(Config.class.getDeclaredField("VERSION").get(null)); + System.out.println("[Shaders] Detected OptiFine version : "+ configVersion); + if (configVersion.equals(ofVersion) ) + { + System.out.println("[Shaders] ShadersMod loaded. version: " + versiontostring(version)); + } + else + { + System.err.println("[Shaders] Wrong OptiFine version!"); + System.exit(-1); + } + } + catch(Exception e) + { + System.err.println("[Shaders] OptiFine missing or wrong version! Install OptiFine "+ofVersion+" first and then the ShadersMod!"); + System.exit(-1); + } + //Tessellator.shaders = true; + */ + } + + + public static int checkFramebufferStatus(String location) + { + int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + if (status != GL_FRAMEBUFFER_COMPLETE_EXT) + System.err.format("FramebufferStatus 0x%04X at %s\n", status, location); + return status; + } + + public static int checkGLError(String location) + { + int errorCode = glGetError(); + if (errorCode != GL_NO_ERROR) { + boolean skipPrint = false; + //if (location.equals("updatechunks")) { + // if (updateChunksErrorRecorded) { + // skipPrint = true; + // } else { + // updateChunksErrorRecorded = true; + // } + //} + if (!skipPrint) { + if (errorCode == GL_INVALID_FRAMEBUFFER_OPERATION_EXT) { + int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + System.err.format("GL error 0x%04X: %s (Fb status 0x%04X) at %s\n", errorCode, gluErrorString(errorCode), status, location); + } else { + System.err.format("GL error 0x%04X: %s at %s\n", errorCode, gluErrorString(errorCode), location); + } + } + } + return errorCode; + } + + public static int checkGLError(String location, String info) + { + int errorCode = glGetError(); + if (errorCode != GL_NO_ERROR) { + System.err.format("GL error 0x%04x: %s at %s %s\n", errorCode, gluErrorString(errorCode), location, info); + } + return errorCode; + } + + public static int checkGLError(String location, String info1, String info2) + { + int errorCode = glGetError(); + if (errorCode != GL_NO_ERROR) { + System.err.format("GL error 0x%04x: %s at %s %s %s\n", errorCode, gluErrorString(errorCode), location, info1, info2); + } + return errorCode; + } + + private static String printChatAndLogError(String str) + { + mc.ingameGUI.getChatGUI().printChatMessage(new ChatComponentText(str)); + System.err.println(str); + return str; + } + + public static void printIntBuffer(String title, IntBuffer buf) { + StringBuilder sb = new StringBuilder(128); + sb.append(title).append(" [pos ").append(buf.position()) + .append(" lim ").append(buf.limit()) + .append(" cap ").append(buf.capacity()) + .append(" :"); + for (int lim=buf.limit(),i=0; i drawBuffersMap = new HashMap(); + for (int p = 0; p < ProgramCount; ++p) { + if (p==ProgramFinal) + { + programsDrawBuffers[p] = null; + } + else if (programsID[p] == 0) + { + if (p==ProgramShadow) { + programsDrawBuffers[p] = drawBuffersNone; + } else { + programsDrawBuffers[p] = drawBuffersColorAtt0; + } + } + else + { + String str = programsDrawBufSettings[p]; + if (str != null) { + IntBuffer intbuf = drawBuffersBuffer[p]; + int numDB = str.length(); + if (numDB > usedDrawBuffers) + { + usedDrawBuffers = numDB; + } + if (numDB > maxDrawBuffers) + { + numDB = maxDrawBuffers; + } + programsDrawBuffers[p] = intbuf; + intbuf.limit(numDB); + for (int i = 0; i < numDB; ++i) { + int d = GL_NONE; + if (str.length()>i) + { + int ca = str.charAt(i) - '0'; + if (p!=ProgramShadow) { + if (ca>=0 && ca<=7) + { + d = ca + GL_COLOR_ATTACHMENT0_EXT; + if (ca > usedColorAttachs) + { + usedColorAttachs = ca; + } + if (ca > usedColorBuffers) + { + usedColorBuffers = ca; + } + } + } else { + if (ca>=0 && ca<=1) + { + d = ca + GL_COLOR_ATTACHMENT0_EXT; + if (ca > usedShadowColorBuffers) + { + usedShadowColorBuffers = ca; + } + } + } + } + intbuf.put(i, d); + } + } else { + if (p!=ProgramShadow) { + programsDrawBuffers[p] = dfbDrawBuffers; + usedDrawBuffers = usedColorBuffers; + } else { + programsDrawBuffers[p] = sfbDrawBuffers; + } + } + } + } + + //if (programIDCopyDepth==0) + // programIDCopyDepth = setupProgramCopyDepth(); + + // TO DO: add color attachment option + usedColorAttachs = usedColorBuffers; + + shadowPassInterval = (usedShadowDepthBuffers > 0)? 1 : 0; + shouldSkipDefaultShadow = (usedShadowDepthBuffers > 0); + + + dfbDrawBuffers.position(0).limit(usedDrawBuffers); + dfbColorTextures.position(0).limit(usedColorBuffers); + //dfbRenderBuffers.limit(colorAttachments); + + for (int i = 0; i < usedDrawBuffers; ++i) { + dfbDrawBuffers.put(i, GL_COLOR_ATTACHMENT0_EXT + i); + } + + if (usedDrawBuffers > maxDrawBuffers) { + printChatAndLogError("[Shaders] Not enough draw buffers! Requires "+ usedDrawBuffers + ". Has " + maxDrawBuffers + "."); + } + //if (usedColorBuffers > maxColorAttach) { + // printChatAndLogError("[Shaders] Not enough color attachment! Requires "+ usedColorBuffers + ". Has " + maxColorAttach + "."); + //} + + sfbDrawBuffers.position(0).limit(usedShadowColorBuffers); + for (int i = 0; i < usedShadowColorBuffers; ++i) { + sfbDrawBuffers.put(i, GL_COLOR_ATTACHMENT0_EXT + i); + } + + + // Use programBackups for missing programs + for (int i = 0; i < ProgramCount; ++i) { + int n = i; + while (programsID[n]==0 && programBackups[n]!=n) + n = programBackups[n]; + if (n != i && i != ProgramShadow) + { + programsID[i] = programsID[n]; + programsDrawBufSettings[i] = programsDrawBufSettings[n]; + programsDrawBuffers[i] = programsDrawBuffers[n]; + } + } + + //printIntBuffer("dfb drawbuffers",dfbDrawBuffers); + //printIntBuffer("sfb drawbuffers",sfbDrawBuffers); + //printIntBuffer("pgshadow drawbf",programsDrawBuffers[ProgramShadow]); + + // setup scene frame buffer and textures + resize(); + + // setup shadow frame buffer and texture + resizeShadow(); + + if (noiseTextureEnabled) + setupNoiseTexture(); + + if (defaultTexture==null) + defaultTexture = ShadersTex.createDefaultTexture(); + //TextureNM texBlocks = (TextureNM)textureManager.textureMapBlocks.getTexture(); + //TextureNM texItems = (TextureNM)textureManager.textureMapBlocks.getTexture(); + //terrainTextureIdArray = new int[] { texBlocks.getGlTextureId(), texBlocks.normalMap.getGlTextureId(), texBlocks.specularMap.getGlTextureId() }; + //textureIdMap.put(terrainTextureIdArray[0], terrainTextureIdArray); + //int[] itemsTextureIdArray; + //itemsTextureIdArray = new int[] { texItems.getGlTextureId(), texItems.normalMap.getGlTextureId(), texItems.specularMap.getGlTextureId() }; + //textureIdMap.put(itemsTextureIdArray[0], itemsTextureIdArray); + + + isInitialized = true; + + resetDisplayList(); + if (notFirstInit) { + mc.ingameGUI.getChatGUI().printChatMessage(new ChatComponentText("Shaders initialized.")); + } + checkGLError("Shaders.init"); + } + } + + public static void resetDisplayList() + { + ++numberResetDisplayList; + System.out.println("Reset model renderers"); + if (Shaders.useMidTexCoordAttrib || Shaders.useMultiTexCoord3Attrib) { + Iterator it = RenderManager.instance.entityRenderMap.values().iterator(); + while (it.hasNext()) + { + Render ren = it.next(); + if (ren instanceof RendererLivingEntity) + { + RendererLivingEntity rle = (RendererLivingEntity)ren; + //System.out.format("Reset %s\n", rle.toString()); + resetDisplayListModel(rle.mainModel); + resetDisplayListModel(rle.renderPassModel); + } + } + } + System.out.println("Reset world renderers"); + mc.renderGlobal.loadRenderers(); + } + public static void resetDisplayListModel(ModelBase mbase) + { + if (mbase != null) + { + Iterator it = mbase.boxList.iterator(); + while (it.hasNext()) { + Object obj = it.next(); + if (obj instanceof ModelRenderer) { + resetDisplayListModelRenderer((ModelRenderer)obj); + } + } + } + } + public static void resetDisplayListModelRenderer(ModelRenderer mrr) + { + mrr.resetDisplayList(); +// if (mrr.compiled) +// { +// GLAllocation.deleteDisplayLists(mrr.displayList); +// mrr.displayList = 0; +// mrr.compiled = false; +// if (mrr instanceof ModelRotationRenderer) { +// ModelRotationRenderer mrt = (ModelRotationRenderer)mrr; +// mrt.compiled = false; +// } +// } + if (mrr.childModels != null) { + for (int i=0, n=mrr.childModels.size(); i < n; ++i) + { + resetDisplayListModelRenderer((ModelRenderer)mrr.childModels.get(i)); + } + } + } + + // ---------------------------------------- + +// private static final String shaderCodeCopyDepthV = +// "#version 120\n"+ +// "varying vec4 texcoord;\n"+ +// "void main()\n"+ +// "{\n"+ +// " texcoord = gl_MultiTexCoord0;\n"+ +// " gl_Position = ftransform();\n"+ +// "}\n" +// ; +// private static final String shaderCodeCopyDepthF = +// "#version 120\n"+ +// "varying vec4 texcoord;\n"+ +// "uniform sampler2D depthtex0;\n"+ +// "void main()\n"+ +// "{\n"+ +// " gl_FragDepth = texture2D(depthtex0,texcoord.st).r;\n"+ +// " gl_FragColor = texture2D(depthtex0,texcoord.st);\n"+ +// "}\n" +// ; +// +// private static int setupProgramCopyDepth() { +// int program = glCreateProgramObjectARB(); +// if (program !=0) { +// int vShader = createVertShaderFromCode(shaderCodeCopyDepthV); +// int fShader = createFragShaderFromCode(shaderCodeCopyDepthF); +// if (vShader != 0 || fShader != 0) { +// if (vShader != 0) { +// glAttachObjectARB(program, vShader); +// } +// if (fShader != 0) { +// glAttachObjectARB(program, fShader); +// } +// glLinkProgramARB(program); +// if (vShader != 0) { +// glDetachObjectARB(program, vShader); +// glDeleteObjectARB(vShader); +// } +// if (fShader != 0) { +// glDetachObjectARB(program, fShader); +// glDeleteObjectARB(fShader); +// } +// int valid = glGetProgrami(program, GL_VALIDATE_STATUS); // glGetProgrami in LWJGL 3.0+ +// if (valid == GL_TRUE) { +// System.out.println("Program copydepth created"); +// } else { +// printChatAndLogError("[Shaders] Error : Invalid program copydepth"); +// glDeleteObjectARB(program); +// program = 0; +// } +// } else { +// glDeleteObjectARB(program); +// program = 0; +// } +// } +// return program; +// } +// +// +// private static int createVertShaderFromCode(String code) { +// int vertShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); +// if (vertShader == 0) { +// return 0; +// } +// glShaderSourceARB(vertShader, code); +// glCompileShaderARB(vertShader); +// printLogInfo(vertShader,"copydepth vert"); +// return vertShader; +// } +// +// +// private static int createFragShaderFromCode(String code) { +// int fragShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); +// if (fragShader == 0) { +// return 0; +// } +// glShaderSourceARB(fragShader, code); +// glCompileShaderARB(fragShader); +// printLogInfo(fragShader,"copydepth frag"); +// return fragShader; +// } + + + private static int setupProgram(int program, String vShaderPath, String fShaderPath) { + checkGLError("pre setupProgram"); + int programid = glCreateProgramObjectARB(); + checkGLError("create"); + if (programid != 0) { + progUseEntityAttrib = false; + progUseMidTexCoordAttrib = false; + int vShader = createVertShader(vShaderPath); + int fShader = createFragShader(fShaderPath); + checkGLError("create"); + if (vShader != 0 || fShader != 0) { + if (vShader != 0) { + glAttachObjectARB(programid, vShader); + checkGLError("attach"); + } + if (fShader != 0) { + glAttachObjectARB(programid, fShader); + checkGLError("attach"); + } + if (progUseEntityAttrib) { + glBindAttribLocationARB(programid, entityAttrib, "mc_Entity"); + checkGLError("mc_Entity"); + } + if (progUseMidTexCoordAttrib) { + glBindAttribLocationARB(programid, midTexCoordAttrib, "mc_midTexCoord"); + checkGLError("mc_midTexCoord"); + } + glLinkProgramARB(programid); + if (vShader != 0) { + glDetachObjectARB(programid, vShader); + glDeleteObjectARB(vShader); + } + if (fShader != 0) { + glDetachObjectARB(programid, fShader); + glDeleteObjectARB(fShader); + } + programsID[program] = programid; + useProgram(program); + glValidateProgramARB(programid); + useProgram(ProgramNone); + printLogInfo(programid, vShaderPath+","+fShaderPath); + int valid = glGetProgrami(programid, GL_VALIDATE_STATUS); + if (valid == GL_TRUE) { + System.out.println("Program "+programNames[program]+" loaded"); + } else { + printChatAndLogError("[Shaders] Error : Invalid program " + programNames[program]); + glDeleteObjectARB(programid); + programid = 0; + } + } else { + glDeleteObjectARB(programid); + programid = 0; + } + } + return programid; + } + + + private static int createVertShader(String filename) { + int vertShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); + if (vertShader == 0) { + return 0; + } + String vertexCode = ""; + String line; + + BufferedReader reader = null; + try { + reader = new BufferedReader(new InputStreamReader(shaderPack.getResourceAsStream(filename))); + } catch (Exception e) { + try { + reader = new BufferedReader(new FileReader(new File(filename))); + } catch (Exception e2) { + //System.out.println("Couldn't open " + filename); + glDeleteObjectARB(vertShader); + return 0; + } + } + + if (reader != null) + try { + while ((line = reader.readLine()) != null) { + vertexCode += line + "\n"; + if (line.matches("attribute [_a-zA-Z0-9]+ mc_Entity.*")) { + useEntityAttrib = true; + progUseEntityAttrib = true; + } + else if (line.matches("attribute [_a-zA-Z0-9]+ mc_midTexCoord.*")) { + useMidTexCoordAttrib = true; + progUseMidTexCoordAttrib = true; + } + else if (line.matches(".*gl_MultiTexCoord3.*")) { + useMultiTexCoord3Attrib = true; + } + } + } catch (Exception e) { + System.out.println("Couldn't read " + filename + "!"); + e.printStackTrace(); + glDeleteObjectARB(vertShader); + return 0; + } + + if (reader != null) + try { + reader.close(); + } catch (Exception e) { + System.out.println("Couldn't close " + filename + "!"); + } + + glShaderSourceARB(vertShader, vertexCode); + glCompileShaderARB(vertShader); + printLogInfo(vertShader,filename); + return vertShader; + } + + private static Pattern gbufferFormatPattern = Pattern.compile("[ \t]*const[ \t]*int[ \t]*(\\w+)Format[ \t]*=[ \t]*([RGBA81632F]*)[ \t]*;.*"); + private static Pattern gbufferMipmapEnabledPattern = Pattern.compile("[ \t]*const[ \t]*bool[ \t]*(\\w+)MipmapEnabled[ \t]*=[ \t]*true[ \t]*;.*"); + + private static int createFragShader(String filename) { + int fragShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); + if (fragShader == 0) { + return 0; + } + StringBuilder fragCode = new StringBuilder(1048576); + String line; + + BufferedReader reader = null; + try { + reader = new BufferedReader(new InputStreamReader(shaderPack.getResourceAsStream(filename))); + } catch (Exception e) { + try { + reader = new BufferedReader(new FileReader(new File(filename))); + } catch (Exception e2) { + //System.out.println("Couldn't open " + filename); + glDeleteObjectARB(fragShader); + return 0; + } + } + + if (reader != null) + try { + while ((line = reader.readLine()) != null) { + fragCode.append(line).append('\n'); + if (line.matches("#version .*")) { + + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadow;.*")) { + if (usedShadowDepthBuffers < 1) + usedShadowDepthBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ watershadow;.*")) { + waterShadowEnabled = true; + if (usedShadowDepthBuffers < 2) + usedShadowDepthBuffers = 2; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowtex0;.*")) { + if (usedShadowDepthBuffers < 1) + usedShadowDepthBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowtex1;.*")) { + if (usedShadowDepthBuffers < 2) + usedShadowDepthBuffers = 2; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowcolor;.*")) { + if (usedShadowColorBuffers < 1) + usedShadowColorBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowcolor0;.*")) { + if (usedShadowColorBuffers < 1) + usedShadowColorBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowcolor1;.*")) { + if (usedShadowColorBuffers < 2) + usedShadowColorBuffers = 2; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ depthtex0;.*")) { + if (usedDepthBuffers < 1) + usedDepthBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ depthtex1;.*")) { + if (usedDepthBuffers < 2) + usedDepthBuffers = 2; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ depthtex2;.*")) { + if (usedDepthBuffers < 3) + usedDepthBuffers = 3; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ gdepth;.*")) { + if (gbuffersFormat[1] == GL_RGBA) + gbuffersFormat[1] = GL_RGBA32F; + } else if (usedColorBuffers < 5 && line.matches("uniform [ _a-zA-Z0-9]+ gaux1;.*")) { + usedColorBuffers = 5; + } else if (usedColorBuffers < 6 && line.matches("uniform [ _a-zA-Z0-9]+ gaux2;.*")) { + usedColorBuffers = 6; + } else if (usedColorBuffers < 7 && line.matches("uniform [ _a-zA-Z0-9]+ gaux3;.*")) { + usedColorBuffers = 7; + } else if (usedColorBuffers < 8 && line.matches("uniform [ _a-zA-Z0-9]+ gaux4;.*")) { + usedColorBuffers = 8; + } else if (usedColorBuffers < 5 && line.matches("uniform [ _a-zA-Z0-9]+ colortex4;.*")) { + usedColorBuffers = 5; + } else if (usedColorBuffers < 6 && line.matches("uniform [ _a-zA-Z0-9]+ colortex5;.*")) { + usedColorBuffers = 6; + } else if (usedColorBuffers < 7 && line.matches("uniform [ _a-zA-Z0-9]+ colortex6;.*")) { + usedColorBuffers = 7; + } else if (usedColorBuffers < 8 && line.matches("uniform [ _a-zA-Z0-9]+ colortex7;.*")) { + usedColorBuffers = 8; + + } else if (usedColorBuffers < 8 && line.matches("uniform [ _a-zA-Z0-9]+ centerDepthSmooth;.*")) { + centerDepthSmoothEnabled = true; + + //Shadow resolution + } else if (line.matches("/\\* SHADOWRES:[0-9]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Shadow map resolution: " + parts[2]); + spShadowMapWidth = spShadowMapHeight = Integer.parseInt(parts[2]); + shadowMapWidth = shadowMapHeight = Math.round(spShadowMapWidth * configShadowResMul); + + } else if (line.matches("[ \t]*const[ \t]*int[ \t]*shadowMapResolution[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Shadow map resolution: " + parts[1]); + spShadowMapWidth = spShadowMapHeight = Integer.parseInt(parts[1]); + shadowMapWidth = shadowMapHeight = Math.round(spShadowMapWidth * configShadowResMul); + + } else if (line.matches("/\\* SHADOWFOV:[0-9\\.]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Shadow map field of view: " + parts[2]); + shadowMapFOV = Float.parseFloat(parts[2]); + shadowMapIsOrtho = false; + + + //Shadow distance + } else if (line.matches("/\\* SHADOWHPL:[0-9\\.]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Shadow map half-plane: " + parts[2]); + shadowMapHalfPlane = Float.parseFloat(parts[2]); + shadowMapIsOrtho = true; + + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*shadowDistance[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Shadow map distance: " + parts[1]); + shadowMapHalfPlane = Float.parseFloat(parts[1]); + shadowMapIsOrtho = true; + + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*shadowIntervalSize[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Shadow map interval size: " + parts[1]); + shadowIntervalSize = Float.parseFloat(parts[1]); + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*generateShadowMipmap[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("Generate shadow mipmap"); + Arrays.fill(shadowMipmapEnabled, true); + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*generateShadowColorMipmap[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("Generate shadow color mipmap"); + Arrays.fill(shadowColorMipmapEnabled, true); + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*shadowHardwareFiltering[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("Hardware shadow filtering enabled."); + Arrays.fill(shadowHardwareFilteringEnabled, true); + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*shadowHardwareFiltering0[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowHardwareFiltering0"); + shadowHardwareFilteringEnabled[0] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*shadowHardwareFiltering1[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowHardwareFiltering1"); + shadowHardwareFilteringEnabled[1] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowtex0Mipmap|shadowtexMipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowtex0Mipmap"); + shadowMipmapEnabled[0] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowtex1Mipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowtex1Mipmap"); + shadowMipmapEnabled[1] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowcolor0Mipmap|shadowColor0Mipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowcolor0Mipmap"); + shadowColorMipmapEnabled[0] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowcolor1Mipmap|shadowColor1Mipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowcolor1Mipmap"); + shadowColorMipmapEnabled[1] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowtex0Nearest|shadowtexNearest|shadow0MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowtex0Nearest"); + shadowFilterNearest[0] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowtex1Nearest|shadow1MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowtex1Nearest"); + shadowFilterNearest[1] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowcolor0Nearest|shadowColor0Nearest|shadowColor0MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowcolor0Nearest"); + shadowColorFilterNearest[0] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowcolor1Nearest|shadowColor1Nearest|shadowColor1MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowcolor1Nearest"); + shadowColorFilterNearest[1] = true; + + //Wetness half life + } else if (line.matches("/\\* WETNESSHL:[0-9\\.]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Wetness halflife: " + parts[2]); + wetnessHalfLife = Float.parseFloat(parts[2]); + + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*wetnessHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Wetness halflife: " + parts[1]); + wetnessHalfLife = Float.parseFloat(parts[1]); + + + //Dryness halflife + } else if (line.matches("/\\* DRYNESSHL:[0-9\\.]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Dryness halflife: " + parts[2]); + drynessHalfLife = Float.parseFloat(parts[2]); + + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*drynessHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Dryness halflife: " + parts[1]); + drynessHalfLife = Float.parseFloat(parts[1]); + + + //Eye brightness halflife + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*eyeBrightnessHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Eye brightness halflife: " + parts[1]); + eyeBrightnessHalflife = Float.parseFloat(parts[1]); + + + //Center depth halflife + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*centerDepthHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Center depth halflife: " + parts[1]); + centerDepthSmoothHalflife = Float.parseFloat(parts[1]); + + + //Sun path rotation + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*sunPathRotation[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Sun path rotation: " + parts[1]); + sunPathRotation = Float.parseFloat(parts[1]); + + + //Ambient occlusion level + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*ambientOcclusionLevel[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("AO Level: " + parts[1]); + aoLevel = Float.parseFloat(parts[1]); + blockAoLight = 1.0f - aoLevel; + + + //super sampling + } else if (line.matches("[ \t]*const[ \t]*int[ \t]*superSamplingLevel[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + int ssaa = Integer.parseInt(parts[1]); + if (ssaa > 1) { + System.out.println("Super sampling level: " + ssaa + "x"); + superSamplingLevel = ssaa; + } else { + superSamplingLevel = 1; + } + + + //noise texture + } else if (line.matches("[ \t]*const[ \t]*int[ \t]*noiseTextureResolution[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Noise texture enabled"); + System.out.println("Noise texture resolution: " + parts[1]); + noiseTextureResolution = Integer.parseInt(parts[1]); + noiseTextureEnabled = true; + + } else if (line.matches("[ \t]*const[ \t]*int[ \t]*\\w+Format[ \t]*=[ \t]*[RGBA81632F]*[ \t]*;.*")) { + Matcher m = gbufferFormatPattern.matcher(line); + m.matches(); + String name = m.group(1); + String value =m.group(2); + int bufferindex = getBufferIndexFromString(name); + int format = getTextureFormatFromString(value); + if (bufferindex >= 0 && format != 0) + { + gbuffersFormat[bufferindex] = format; + System.out.format("%s format: %s\n", name, value); + } + //gaux4 + } else if (line.matches("/\\* GAUX4FORMAT:RGBA32F \\*/.*")) { + System.out.println("gaux4 format : RGB32AF"); + gbuffersFormat[7] = GL_RGBA32F; + } else if (line.matches("/\\* GAUX4FORMAT:RGB32F \\*/.*")) { + System.out.println("gaux4 format : RGB32F"); + gbuffersFormat[7] = GL_RGB32F; + } else if (line.matches("/\\* GAUX4FORMAT:RGB16 \\*/.*")) { + System.out.println("gaux4 format : RGB16"); + gbuffersFormat[7] = GL_RGB16; + + //Mipmap stuff + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*\\w+MipmapEnabled[ \t]*=[ \t]*true[ \t]*;.*")) { + if (filename.matches(".*composite[0-9]?.fsh") || filename.matches(".*final.fsh")) { + Matcher m = gbufferMipmapEnabledPattern.matcher(line); + m.matches(); + String name = m.group(1); + //String value =m.group(2); + int bufferindex = getBufferIndexFromString(name); + if (bufferindex >= 0) { + newCompositeMipmapSetting |= (1< 1) { + ByteBuffer infoLog = BufferUtils.createByteBuffer(length); + iVal.flip(); + glGetInfoLogARB(obj, iVal, infoLog); + byte[] infoBytes = new byte[length]; + infoLog.get(infoBytes); + if (infoBytes[length-1] == 0) infoBytes[length-1] = 10; + String out = new String(infoBytes); + System.out.println("Info log: " + name + "\n" + out); + return false; + } + return true; + } + + + public static void setDrawBuffers(IntBuffer drawBuffers) + { + if (activeDrawBuffers != drawBuffers) + { + //printIntBuffer("setDrawBuffers", drawBuffers); + activeDrawBuffers = drawBuffers; + glDrawBuffers(drawBuffers); + } else { + //printIntBuffer("setDrawBf skip", drawBuffers); + } + } + + public static void useProgram(int program) { + //System.out.println((new StringBuilder(32)).append("useProgram ").append(programNames[program])); + Shaders.checkGLError("pre-useProgram"); + if (isShadowPass) { + program = ProgramShadow; + if (programsID[ProgramShadow]==0) { + normalMapEnabled = false; + return; + } + } + if (activeProgram == program) { + return; + } + activeProgram = program; + glUseProgramObjectARB(programsID[program]); + if (programsID[program] == 0) { + normalMapEnabled = false; + return; + } + if (checkGLError("useProgram ",programNames[program]) != 0) + { + programsID[program] = 0; + } + IntBuffer drawBuffers = programsDrawBuffers[program]; + if (isRenderingDfb) { + setDrawBuffers(drawBuffers); + checkGLError(programNames[program], " draw buffers = ", programsDrawBufSettings[program]); + //SMCLog.info("%s",programNames[program] + " draw buffers = " + programsDrawBufSettings[program]); + } + activeCompositeMipmapSetting = programsCompositeMipmapSetting[program]; + uniformEntityHurt = glGetUniformLocationARB(programsID[activeProgram], "entityHurt"); + uniformEntityFlash = glGetUniformLocationARB(programsID[activeProgram], "entityFlash"); + switch (program) { + case ProgramBasic: + case ProgramTextured: + case ProgramTexturedLit: + case ProgramSkyBasic: + case ProgramSkyTextured: + case ProgramTerrain: + case ProgramWater: + case ProgramEntities: + case ProgramHand: + case ProgramWeather: + normalMapEnabled = true; + setProgramUniform1i("texture", 0); + setProgramUniform1i("lightmap", 1); + setProgramUniform1i("normals", 2); + setProgramUniform1i("specular", 3); + setProgramUniform1i("shadow", waterShadowEnabled?5:4); + setProgramUniform1i("watershadow",4); + setProgramUniform1i("shadowtex0", 4); + setProgramUniform1i("shadowtex1", 5); + setProgramUniform1i("depthtex0", 6); + setProgramUniform1i("depthtex1", 12); + setProgramUniform1i("shadowcolor",13); + setProgramUniform1i("shadowcolor0",13); + setProgramUniform1i("shadowcolor1",14); + setProgramUniform1i("noisetex",15); + break; + case ProgramComposite: + case ProgramComposite1: + case ProgramComposite2: + case ProgramComposite3: + case ProgramComposite4: + case ProgramComposite5: + case ProgramComposite6: + case ProgramComposite7: + case ProgramFinal: + normalMapEnabled = false; + setProgramUniform1i("gcolor", 0); + setProgramUniform1i("gdepth", 1); + setProgramUniform1i("gnormal", 2); + setProgramUniform1i("composite", 3); + setProgramUniform1i("gaux1", 7); + setProgramUniform1i("gaux2", 8); + setProgramUniform1i("gaux3", 9); + setProgramUniform1i("gaux4", 10); + setProgramUniform1i("colortex0", 0); + setProgramUniform1i("colortex1", 1); + setProgramUniform1i("colortex2", 2); + setProgramUniform1i("colortex3", 3); + setProgramUniform1i("colortex4", 7); + setProgramUniform1i("colortex5", 8); + setProgramUniform1i("colortex6", 9); + setProgramUniform1i("colortex7", 10); + setProgramUniform1i("shadow", waterShadowEnabled?5:4); + setProgramUniform1i("watershadow",4); + setProgramUniform1i("shadowtex0", 4); + setProgramUniform1i("shadowtex1", 5); + setProgramUniform1i("gdepthtex", 6); + setProgramUniform1i("depthtex0", 6); + setProgramUniform1i("depthtex1", 11); + setProgramUniform1i("depthtex2", 12); + setProgramUniform1i("shadowcolor",13); + setProgramUniform1i("shadowcolor0",13); + setProgramUniform1i("shadowcolor1",14); + setProgramUniform1i("noisetex",15); + break; + case ProgramShadow: + setProgramUniform1i("tex", 0); + setProgramUniform1i("texture", 0); + setProgramUniform1i("lightmap", 1); + setProgramUniform1i("normals", 2); + setProgramUniform1i("specular", 3); + setProgramUniform1i("shadow", waterShadowEnabled?5:4); + setProgramUniform1i("watershadow",4); + setProgramUniform1i("shadowtex0", 4); + setProgramUniform1i("shadowtex1", 5); + setProgramUniform1i("shadowcolor",13); + setProgramUniform1i("shadowcolor0",13); + setProgramUniform1i("shadowcolor1",14); + setProgramUniform1i("noisetex",15); + break; + default: + normalMapEnabled = false; + break; + } + ItemStack stack = mc.thePlayer.getCurrentEquippedItem(); + Item item = (stack!=null)? stack.getItem(): null; + int itemID; + Block block; + if (item!=null) { + itemID = Item.itemRegistry.getIDForObject(item); + block = (Block) Block.blockRegistry.getObjectById(itemID); + } else { + itemID = -1; + block = null; + } + setProgramUniform1i("heldItemId", (itemID)); + setProgramUniform1i("heldBlockLightValue", (block!=null)?block.getLightValue():0); + setProgramUniform1i("fogMode", (fogEnabled ? fogMode : 0)); + setProgramUniform3f("fogColor", fogColorR, fogColorG, fogColorB); + setProgramUniform3f("skyColor", skyColorR, skyColorG, skyColorB); + setProgramUniform1i("worldTime", (int)worldTime%24000); + setProgramUniform1i("moonPhase", moonPhase); + setProgramUniform1f("frameTimeCounter", frameTimeCounter); + setProgramUniform1f("sunAngle", sunAngle); + setProgramUniform1f("shadowAngle", shadowAngle); + setProgramUniform1f("rainStrength", rainStrength); + setProgramUniform1f("aspectRatio", (float)renderWidth / (float)renderHeight); + setProgramUniform1f("viewWidth", (float)renderWidth); + setProgramUniform1f("viewHeight", (float)renderHeight); + setProgramUniform1f("near", 0.05F); + setProgramUniform1f("far", mc.gameSettings.renderDistanceChunks * 16); + setProgramUniform3f("sunPosition", sunPosition[0], sunPosition[1], sunPosition[2]); + setProgramUniform3f("moonPosition", moonPosition[0], moonPosition[1], moonPosition[2]); + setProgramUniform3f("upPosition", upPosition[0], upPosition[1], upPosition[2]); + setProgramUniform3f("previousCameraPosition", (float)previousCameraPosition[0], (float)previousCameraPosition[1], (float)previousCameraPosition[2]); + setProgramUniform3f("cameraPosition", (float)cameraPosition[0], (float)cameraPosition[1], (float)cameraPosition[2]); + setProgramUniformMatrix4ARB("gbufferModelView", false, modelView); + setProgramUniformMatrix4ARB("gbufferModelViewInverse", false, modelViewInverse); + setProgramUniformMatrix4ARB("gbufferPreviousProjection", false, previousProjection); + setProgramUniformMatrix4ARB("gbufferProjection", false, projection); + setProgramUniformMatrix4ARB("gbufferProjectionInverse", false, projectionInverse); + setProgramUniformMatrix4ARB("gbufferPreviousModelView", false, previousModelView); + if (usedShadowDepthBuffers > 0) { + setProgramUniformMatrix4ARB("shadowProjection", false, shadowProjection); + setProgramUniformMatrix4ARB("shadowProjectionInverse", false, shadowProjectionInverse); + setProgramUniformMatrix4ARB("shadowModelView", false, shadowModelView); + setProgramUniformMatrix4ARB("shadowModelViewInverse", false, shadowModelViewInverse); + } + setProgramUniform1f("wetness", wetness); + setProgramUniform1f("eyeAltitude", eyePosY); + // .x = block brightness .y = sky brightness + // value : 0,16,32,64,96,112,128,160,192,208,224,240 for light level 0 to 15 + setProgramUniform2i("eyeBrightness", (eyeBrightness & 0xffff), (eyeBrightness>>16)); + setProgramUniform2i("eyeBrightnessSmooth", Math.round(eyeBrightnessFadeX), Math.round(eyeBrightnessFadeY)); + setProgramUniform2i("terrainTextureSize", terrainTextureSize[0], terrainTextureSize[1]); + setProgramUniform1i("terrainIconSize", terrainIconSize); + setProgramUniform1i("isEyeInWater", isEyeInWater); + setProgramUniform1i("hideGUI", mc.gameSettings.hideGUI?1:0); + setProgramUniform1f("centerDepthSmooth", centerDepthSmooth); + setProgramUniform2i("atlasSize", atlasSizeX, atlasSizeY); + Shaders.checkGLError("useProgram ",programNames[program]); + } + + + public static void setProgramUniform1i(String name, int x) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE) { + int uniform = glGetUniformLocationARB(gp, name); + glUniform1iARB(uniform, x); + if(enableShadersDebug) checkGLError(programNames[activeProgram],name); + } + } + + + public static void setProgramUniform2i(String name, int x, int y) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE) { + int uniform = glGetUniformLocationARB(gp, name); + glUniform2iARB(uniform, x, y); + if(enableShadersDebug) checkGLError(programNames[activeProgram],name); + } + } + + + public static void setProgramUniform1f(String name, float x) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE) { + int uniform = glGetUniformLocationARB(gp, name); + glUniform1fARB(uniform, x); + if(enableShadersDebug) checkGLError(programNames[activeProgram],name); + } + } + + + public static void setProgramUniform3f(String name, float x, float y, float z) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE) { + int uniform = glGetUniformLocationARB(gp, name); + glUniform3fARB(uniform, x, y, z); + if(enableShadersDebug) checkGLError(programNames[activeProgram],name); + } + } + + + public static void setProgramUniformMatrix4ARB(String name, boolean transpose, FloatBuffer matrix) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE && matrix != null) { + int uniform = glGetUniformLocationARB(gp, name); + glUniformMatrix4ARB(uniform, transpose, matrix); + if(enableShadersDebug) checkGLError(programNames[activeProgram],name); + } + } + + private static int getBufferIndexFromString(String name) + { + if (name.equals("colortex0")||name.equals("gcolor" )) return 0; + else if (name.equals("colortex1")||name.equals("gdepth" )) return 1; + else if (name.equals("colortex2")||name.equals("gnormal" )) return 2; + else if (name.equals("colortex3")||name.equals("composite")) return 3; + else if (name.equals("colortex4")||name.equals("gaux1" )) return 4; + else if (name.equals("colortex5")||name.equals("gaux2" )) return 5; + else if (name.equals("colortex6")||name.equals("gaux3" )) return 6; + else if (name.equals("colortex7")||name.equals("gaux4" )) return 7; + else return -1; + } + + private static int getTextureFormatFromString(String par) + { + if (par.matches("[ \t]*R8[ \t]*")) + return GL_R8; + + else if (par.matches("[ \t]*RG8[ \t]*")) + return GL_RG8; + + else if (par.matches("[ \t]*RGB8[ \t]*")) + return GL_RGB8; + + else if (par.matches("[ \t]*RGBA8[ \t]*")) + return GL_RGBA8; + + else if (par.matches("[ \t]*R16[ \t]*")) + return GL_R16; + + else if (par.matches("[ \t]*RG16[ \t]*")) + return GL_RG16; + + else if (par.matches("[ \t]*RGB16[ \t]*")) + return GL_RGB16; + + else if (par.matches("[ \t]*RGBA16[ \t]*")) + return GL_RGBA16; + + else if (par.matches("[ \t]*R32F[ \t]*")) + return GL_R32F; + + else if (par.matches("[ \t]*RG32F[ \t]*")) + return GL_RG32F; + + else if (par.matches("[ \t]*RGB32F[ \t]*")) + return GL_RGB32F; + + else if (par.matches("[ \t]*RGBA32F[ \t]*")) + return GL_RGBA32F; + + else + return 0; + } + + + private static void setupNoiseTexture() + { + if (noiseTexture == null) + noiseTexture = new HFNoiseTexture(noiseTextureResolution, noiseTextureResolution); + } + + private static IntBuffer fillIntBufferZero(IntBuffer buf) + { + int limit = buf.limit(); + for (int i=buf.position(); i> 16 )*(1-temp2); + } + + isEyeInWater = (mc.gameSettings.thirdPersonView == 0 + && !mc.renderViewEntity.isPlayerSleeping() + && mc.thePlayer.isInsideOfMaterial(Material.water)) ? + 1: 0; + + { + Vec3 skyColorV = mc.theWorld.getSkyColor(mc.renderViewEntity, f); + skyColorR = (float) skyColorV.xCoord; + skyColorG = (float) skyColorV.yCoord; + skyColorB = (float) skyColorV.zCoord; + } + + //Determine average color +// { +// int searchWidth = renderWidth / 2; +// int searchHeight = renderHeight / 2; +// +// ByteBuffer colorByteBuffer = ByteBuffer.allocateDirect(searchWidth * searchHeight * 4 * 3); +// glReadPixels((renderWidth / 2) - (searchWidth / 2), (renderHeight / 2) - (searchHeight / 2), searchWidth, searchHeight, GL11.GL_RGB, GL11.GL_FLOAT, colorByteBuffer); +// +// colorByteBuffer.order(ByteOrder.LITTLE_ENDIAN); +// +// +// float averageColor = 0.0f; +// for (int i = 0; i < searchWidth; i++) { +// for (int j = 0; j < searchHeight; j++) { +// averageColor += colorByteBuffer.getFloat(i * 4 + (searchWidth * 4 * 3 * j)); +// } +// } +// +// System.out.println("Color: " + averageColor / (searchWidth * searchHeight)); +// +// } + + isRenderingWorld = true; + isCompositeRendered = false; + isHandRendered = false; + + if (usedShadowDepthBuffers >= 1) { + glActiveTexture(GL_TEXTURE4); + glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(0)); + if (usedShadowDepthBuffers >= 2) { + glActiveTexture(GL_TEXTURE5); + glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(1)); + } + } + + for (int i = 0; i < 4 && 4+i < usedColorBuffers; ++i) + { + glActiveTexture(GL_TEXTURE7+i); + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(4+i)); + } + + glActiveTexture(GL_TEXTURE6); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(0)); + + if (usedDepthBuffers >= 2) { + glActiveTexture(GL_TEXTURE11); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(1)); + + if (usedDepthBuffers >= 3) { + glActiveTexture(GL_TEXTURE12); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(2)); + } + } + + for (int i = 0; i < usedShadowColorBuffers; ++i) + { + glActiveTexture(GL_TEXTURE13+i); + glBindTexture(GL_TEXTURE_2D, sfbColorTextures.get(i)); + } + + if (noiseTextureEnabled) { + glActiveTexture(GL_TEXTURE0 + noiseTexture.textureUnit); + glBindTexture(GL_TEXTURE_2D, noiseTexture.getID()); + 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); + 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); + } + + glActiveTexture(GL_TEXTURE0); + + previousCameraPosition[0] = cameraPosition[0]; + previousCameraPosition[1] = cameraPosition[1]; + previousCameraPosition[2] = cameraPosition[2]; + + previousProjection.position(0); projection.position(0); + previousProjection.put(projection); + previousProjection.position(0); projection.position(0); + previousModelView.position(0); modelView.position(0); + previousModelView.put(modelView); + previousModelView.position(0); modelView.position(0); + + EntityRenderer.anaglyphField = 0; + + if (usedShadowDepthBuffers > 0 && --shadowPassCounter <= 0) { + // do shadow pass + //System.out.println("shadow pass start"); + mc.mcProfiler.endStartSection("shadow pass"); + preShadowPassThirdPersonView = mc.gameSettings.thirdPersonView; + boolean preShadowPassAdvancedOpengl = mc.gameSettings.advancedOpengl; + mc.gameSettings.advancedOpengl = false; + + // moved to setCamera + //mc.gameSettings.thirdPersonView = 1; + + isShadowPass = true; + shadowPassCounter = shadowPassInterval; + + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sfb); + glDrawBuffers(programsDrawBuffers[ProgramShadow]); + + useProgram(ProgramShadow); + + mc.entityRenderer.renderWorld(f, l); + + glFlush(); + + isShadowPass = false; + + mc.gameSettings.advancedOpengl = preShadowPassAdvancedOpengl; + mc.gameSettings.thirdPersonView = preShadowPassThirdPersonView; + + if (hasGlGenMipmap) { + if (usedShadowDepthBuffers >= 1) { + if (shadowMipmapEnabled[0]) { + glActiveTexture(GL_TEXTURE4); + glGenerateMipmap(GL_TEXTURE_2D); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, shadowFilterNearest[0]? GL_NEAREST_MIPMAP_NEAREST: GL_LINEAR_MIPMAP_LINEAR); + } + if (usedShadowDepthBuffers >= 2) { + if (shadowMipmapEnabled[1]) { + glActiveTexture(GL_TEXTURE5); + glGenerateMipmap(GL_TEXTURE_2D); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, shadowFilterNearest[1]? GL_NEAREST_MIPMAP_NEAREST: GL_LINEAR_MIPMAP_LINEAR); + } + } + glActiveTexture(GL_TEXTURE0); + } + if (usedShadowColorBuffers >= 1) { + if (shadowColorMipmapEnabled[0]) { + glActiveTexture(GL_TEXTURE13); + glGenerateMipmap(GL_TEXTURE_2D); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, shadowColorFilterNearest[0]? GL_NEAREST_MIPMAP_NEAREST: GL_LINEAR_MIPMAP_LINEAR); + } + if (usedShadowColorBuffers >= 2) { + if (shadowColorMipmapEnabled[1]) { + glActiveTexture(GL_TEXTURE14); + glGenerateMipmap(GL_TEXTURE_2D); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, shadowColorFilterNearest[1]? GL_NEAREST_MIPMAP_NEAREST: GL_LINEAR_MIPMAP_LINEAR); + } + } + glActiveTexture(GL_TEXTURE0); + } + } + + //System.out.println("shadow pass end"); + } + mc.mcProfiler.endSection(); + + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dfb); + GL11.glViewport(0, 0, Shaders.renderWidth, Shaders.renderHeight); + activeDrawBuffers = null; + ShadersTex.bindNSTextures(defaultTexture.getMultiTexID()); + useProgram(ProgramTextured); + + checkGLError("end beginRender"); + } + + + public static void setViewport(int vx, int vy, int vw, int vh) { + GL11.glColorMask(true, true, true, true); + if (isShadowPass) { + GL11.glViewport(0, 0, shadowMapWidth, shadowMapHeight); + } else { + GL11.glViewport(0, 0, Shaders.renderWidth, Shaders.renderHeight); + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dfb); + isRenderingDfb = true; + GL11.glEnable(GL11.GL_CULL_FACE); + GL11.glEnable(GL11.GL_DEPTH_TEST); + setDrawBuffers(drawBuffersNone); + useProgram(ProgramTextured); + checkGLError("beginRenderPass"); + } + } + + + public static int setFogMode(int val) + { + return fogMode = val; + } + + + public static void setFogColor(float r, float g, float b) + { + fogColorR = r; + fogColorG = g; + fogColorB = b; + } + + public static void setClearColor(float red, float green, float blue, float alpha) + { + GL11.glClearColor(red, green, blue, alpha); + clearColorR = red; + clearColorG = green; + clearColorB = blue; + } + + public static void clearRenderBuffer() { + //clearColorR = fogColorR; + //clearColorG = fogColorG; + //clearColorB = fogColorB; + + if (isShadowPass) { + // No need to clear shadow depth 1. It will be overwritten. + //if (waterShadowEnabled) { + // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, sfbDepthTextures.get(1), 0); + // glClear(GL_DEPTH_BUFFER_BIT); + //} + checkGLError("shadow clear pre"); + glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, sfbDepthTextures.get(0), 0); + glClearColor(1.0f, 1.0f, 1.0f, 1.0f); + //printIntBuffer(programsDrawBuffers[ProgramShadow]); + glDrawBuffers(programsDrawBuffers[ProgramShadow]); + checkFramebufferStatus("shadow clear"); + glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); + checkGLError("shadow clear"); + return; + } + checkGLError("clear pre"); + + /* + glDrawBuffers(dfbDrawBuffers); + glClearColor(0.0f, 0.0f, 0.0f, 0.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + */ + + glDrawBuffers(GL_COLOR_ATTACHMENT0_EXT); + //glClearColor(clearColorR, clearColorG, clearColorB, 1.0f); + //glClearColor(1f, 0f, 0f, 1.0f); // for debug + glClear(GL_COLOR_BUFFER_BIT); + + glDrawBuffers(GL_COLOR_ATTACHMENT1_EXT); + glClearColor(1.0f, 1.0f, 1.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + + for (int i=2; i 0.0f ? (angle % shadowAngleInterval - (shadowAngleInterval * 0.5f)) : 0.0f; + if (sunAngle <= 0.5) { + // day time + glRotatef(angle - angleInterval, 0.0f, 0.0f, 1.0f); + glRotatef(sunPathRotation, 1.0f, 0.0f, 0.0f); //rotate + shadowAngle = sunAngle; + } else { + // night time + glRotatef(angle + 180.0f - angleInterval, 0.0f, 0.0f, 1.0f); + glRotatef(sunPathRotation, 1.0f, 0.0f, 0.0f); //rotate + shadowAngle = sunAngle - 0.5f; + } + if (shadowMapIsOrtho) { + // reduces jitter + float trans = shadowIntervalSize; + float trans2 = trans / 2.0f; + glTranslatef((float)x % trans - trans2, (float)y % trans - trans2, (float)z % trans - trans2); + } + + glGetFloat(GL_PROJECTION_MATRIX, (FloatBuffer)shadowProjection.position(0)); + invertMat4x((FloatBuffer)shadowProjection.position(0), (FloatBuffer)shadowProjectionInverse.position(0)); + shadowProjection.position(0); shadowProjectionInverse.position(0); + + glGetFloat(GL_MODELVIEW_MATRIX, (FloatBuffer)shadowModelView.position(0)); + invertMat4x((FloatBuffer)shadowModelView.position(0), (FloatBuffer)shadowModelViewInverse.position(0)); + shadowModelView.position(0); shadowModelViewInverse.position(0); + + setProgramUniformMatrix4ARB("gbufferProjection", false, projection); + setProgramUniformMatrix4ARB("gbufferProjectionInverse", false, projectionInverse); + setProgramUniformMatrix4ARB("gbufferPreviousProjection", false, previousProjection); + setProgramUniformMatrix4ARB("gbufferModelView", false, modelView); + setProgramUniformMatrix4ARB("gbufferModelViewInverse", false, modelViewInverse); + setProgramUniformMatrix4ARB("gbufferPreviousModelView", false, previousModelView); + setProgramUniformMatrix4ARB("shadowProjection", false, shadowProjection); + setProgramUniformMatrix4ARB("shadowProjectionInverse", false, shadowProjectionInverse); + setProgramUniformMatrix4ARB("shadowModelView", false, shadowModelView); + setProgramUniformMatrix4ARB("shadowModelViewInverse", false, shadowModelViewInverse); + + // Also render player shadow + mc.gameSettings.thirdPersonView = 1; + checkGLError("setCamera"); + return; + } + checkGLError("setCamera"); + } + + public static void preCelestialRotate() { + Shaders.setUpPosition(); + GL11.glRotatef(Shaders.sunPathRotation * 1.0f, 0.0f, 0.0f, 1.0f); + checkGLError("preCelestialRotate"); + } + + public static void postCelestialRotate() { + // This is called when the current matrix is the modelview matrix based on the celestial angle. + // The sun is at (0, 100, 0), and the moon is at (0, -100, 0). + FloatBuffer modelView = tempMatrixDirectBuffer; + modelView.clear(); + glGetFloat(GL_MODELVIEW_MATRIX, modelView); + modelView.get(tempMat, 0, 16); + multiplyMat4xVec4(tempMat, sunPosModelView, sunPosition); + multiplyMat4xVec4(tempMat, moonPosModelView, moonPosition); + checkGLError("postCelestialRotate"); + } + + public static void setUpPosition() { + // Up direction in model view while rendering sky. + FloatBuffer modelView = tempMatrixDirectBuffer; + modelView.clear(); + glGetFloat(GL_MODELVIEW_MATRIX, modelView); + modelView.get(tempMat, 0, 16); + multiplyMat4xVec4(tempMat, upPosModelView, upPosition); + } + + private static float[] multiplyMat4xVec4(float[] matA, float[] vecB, float[] vecOut) { + vecOut[0] = matA[0] * vecB[0] + matA[4] * vecB[1] + matA[8] * vecB[2] + matA[12] * vecB[3]; + vecOut[1] = matA[1] * vecB[0] + matA[5] * vecB[1] + matA[9] * vecB[2] + matA[13] * vecB[3]; + vecOut[2] = matA[2] * vecB[0] + matA[6] * vecB[1] + matA[10] * vecB[2] + matA[14] * vecB[3]; + vecOut[3] = matA[3] * vecB[0] + matA[7] * vecB[1] + matA[11] * vecB[2] + matA[15] * vecB[3]; + return vecOut; + } + + static float[] invertMat4x_m = new float[16]; + static float[] invertMat4x_inv = new float[16]; + + private static FloatBuffer invertMat4x(FloatBuffer matIn, FloatBuffer invMatOut) { + float[] m = invertMat4x_m; + float[] inv = invertMat4x_inv; + float det; + int i; + + matIn.get(m); + + inv[0] = m[5]*m[10]*m[15] - m[5]*m[11]*m[14] - m[9]*m[6]*m[15] + m[9]*m[7]*m[14] + m[13]*m[6]*m[11] - m[13]*m[7]*m[10]; + inv[4] = -m[4]*m[10]*m[15] + m[4]*m[11]*m[14] + m[8]*m[6]*m[15] - m[8]*m[7]*m[14] - m[12]*m[6]*m[11] + m[12]*m[7]*m[10]; + inv[8] = m[4]*m[9]*m[15] - m[4]*m[11]*m[13] - m[8]*m[5]*m[15] + m[8]*m[7]*m[13] + m[12]*m[5]*m[11] - m[12]*m[7]*m[9]; + inv[12] = -m[4]*m[9]*m[14] + m[4]*m[10]*m[13] + m[8]*m[5]*m[14] - m[8]*m[6]*m[13] - m[12]*m[5]*m[10] + m[12]*m[6]*m[9]; + inv[1] = -m[1]*m[10]*m[15] + m[1]*m[11]*m[14] + m[9]*m[2]*m[15] - m[9]*m[3]*m[14] - m[13]*m[2]*m[11] + m[13]*m[3]*m[10]; + inv[5] = m[0]*m[10]*m[15] - m[0]*m[11]*m[14] - m[8]*m[2]*m[15] + m[8]*m[3]*m[14] + m[12]*m[2]*m[11] - m[12]*m[3]*m[10]; + inv[9] = -m[0]*m[9]*m[15] + m[0]*m[11]*m[13] + m[8]*m[1]*m[15] - m[8]*m[3]*m[13] - m[12]*m[1]*m[11] + m[12]*m[3]*m[9]; + inv[13] = m[0]*m[9]*m[14] - m[0]*m[10]*m[13] - m[8]*m[1]*m[14] + m[8]*m[2]*m[13] + m[12]*m[1]*m[10] - m[12]*m[2]*m[9]; + inv[2] = m[1]*m[6]*m[15] - m[1]*m[7]*m[14] - m[5]*m[2]*m[15] + m[5]*m[3]*m[14] + m[13]*m[2]*m[7] - m[13]*m[3]*m[6]; + inv[6] = -m[0]*m[6]*m[15] + m[0]*m[7]*m[14] + m[4]*m[2]*m[15] - m[4]*m[3]*m[14] - m[12]*m[2]*m[7] + m[12]*m[3]*m[6]; + inv[10] = m[0]*m[5]*m[15] - m[0]*m[7]*m[13] - m[4]*m[1]*m[15] + m[4]*m[3]*m[13] + m[12]*m[1]*m[7] - m[12]*m[3]*m[5]; + inv[14] = -m[0]*m[5]*m[14] + m[0]*m[6]*m[13] + m[4]*m[1]*m[14] - m[4]*m[2]*m[13] - m[12]*m[1]*m[6] + m[12]*m[2]*m[5]; + inv[3] = -m[1]*m[6]*m[11] + m[1]*m[7]*m[10] + m[5]*m[2]*m[11] - m[5]*m[3]*m[10] - m[9]*m[2]*m[7] + m[9]*m[3]*m[6]; + inv[7] = m[0]*m[6]*m[11] - m[0]*m[7]*m[10] - m[4]*m[2]*m[11] + m[4]*m[3]*m[10] + m[8]*m[2]*m[7] - m[8]*m[3]*m[6]; + inv[11] = -m[0]*m[5]*m[11] + m[0]*m[7]*m[9] + m[4]*m[1]*m[11] - m[4]*m[3]*m[9] - m[8]*m[1]*m[7] + m[8]*m[3]*m[5]; + inv[15] = m[0]*m[5]*m[10] - m[0]*m[6]*m[9] - m[4]*m[1]*m[10] + m[4]*m[2]*m[9] + m[8]*m[1]*m[6] - m[8]*m[2]*m[5]; + + det = m[0]*inv[0] + m[1]*inv[4] + m[2]*inv[8] + m[3]*inv[12]; + + if (det != 0.0) { + for (i = 0; i < 16; ++i) + inv[i] /= det; + } else { + // no inverse + Arrays.fill(inv, 0); + } + + invMatOut.put(inv); + + return invMatOut; + } + + public static void genCompositeMipmap() + { + if (hasGlGenMipmap) { + if ((activeCompositeMipmapSetting & (1<<0)) != 0) { + glActiveTexture(GL_TEXTURE0); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glGenerateMipmap(GL_TEXTURE_2D); + } + + if ((activeCompositeMipmapSetting & (1<<1)) != 0) { + glActiveTexture(GL_TEXTURE1); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glGenerateMipmap(GL_TEXTURE_2D); + } + + if ((activeCompositeMipmapSetting & (1<<2)) != 0) { + glActiveTexture(GL_TEXTURE2); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glGenerateMipmap(GL_TEXTURE_2D); + } + + if ((activeCompositeMipmapSetting & (1<<3)) != 0) { + glActiveTexture(GL_TEXTURE3); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glGenerateMipmap(GL_TEXTURE_2D); + } + + for (int i = 0; i < 4 && 4+i < usedColorBuffers; ++i) + { + if ((activeCompositeMipmapSetting & ((1<<4)<= 1) { + glActiveTexture(GL_TEXTURE4); + glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(0)); + if (usedShadowDepthBuffers >= 2) { + glActiveTexture(GL_TEXTURE5); + glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(1)); + } + } + + for (int i = 0; i < 4 && 4+i < usedColorBuffers; ++i) + { + glActiveTexture(GL_TEXTURE7+i); + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(4+i)); + } + + glActiveTexture(GL_TEXTURE6); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(0)); + + if (usedDepthBuffers >= 2) { + glActiveTexture(GL_TEXTURE11); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(1)); + + if (usedDepthBuffers >= 3) { + glActiveTexture(GL_TEXTURE12); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(2)); + } + } + + for (int i = 0; i < usedShadowColorBuffers; ++i) + { + glActiveTexture(GL_TEXTURE13+i); + glBindTexture(GL_TEXTURE_2D, sfbColorTextures.get(i)); + } + + if (noiseTextureEnabled) { + glActiveTexture(GL_TEXTURE0 + noiseTexture.textureUnit); + glBindTexture(GL_TEXTURE_2D, noiseTexture.getID()); + 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); + 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); + } + + glActiveTexture(GL_TEXTURE0); + + // set depth buffer + glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTextures.get(0), 0); + // detach depth buffer + //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, 0, 0); + + // composite + glDrawBuffers(dfbDrawBuffers); + checkGLError("pre-composite"); + + for (int i=0; i>24); + checkGLError("setEntityHurtFlash"); + } + } + + public static void resetEntityHurtFlash() { + setEntityHurtFlash(0,0); + } + + public static void beginLivingDamage() { + if (isRenderingWorld) + { + ShadersTex.bindTexture(defaultTexture); + if (!isShadowPass) { + //useProgram(ProgramBasic); + setDrawBuffers(drawBuffersColorAtt0); + } + } + } + + public static void endLivingDamage() { + if (isRenderingWorld) + { + if (!isShadowPass) { + //useProgram(ProgramEntities); + setDrawBuffers(programsDrawBuffers[ProgramEntities]); + } + } + } + + public static void beginLitParticles() { + //GL11.glDepthMask(false); + Tessellator.instance.setNormal(0f,0f,0f); + useProgram(ProgramTexturedLit); + } + + public static void beginParticles() { + //GL11.glDepthMask(false); + Tessellator.instance.setNormal(0f,0f,0f); + useProgram(ProgramTextured); + } + + public static void endParticles() { + Tessellator.instance.setNormal(0f,0f,0f); + useProgram(ProgramTexturedLit); + } + + public static void preWater() { + if (isShadowPass) { + if (usedShadowDepthBuffers >= 2) { + // copy depth buffer to shadowtex1 + glActiveTexture(GL_TEXTURE5); + checkGLError("pre copy shadow depth"); + glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, shadowMapWidth, shadowMapHeight); + checkGLError("copy shadow depth"); + glActiveTexture(GL_TEXTURE0); + } + } else { + if (usedDepthBuffers >= 2) { + // copy depth buffer to depthtex1 + glActiveTexture(GL_TEXTURE11); + checkGLError("pre copy depth"); + glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, renderWidth, renderHeight); + checkGLError("copy depth"); + glActiveTexture(GL_TEXTURE0); + } + ShadersTex.bindNSTextures(defaultTexture.getMultiTexID()); // flat + } + } + +// public static void beginWaterFancy() { +// if (isRenderingWorld) +// { +// if (!isShadowPass) { +// // program water +// useProgram(Shaders.ProgramWater); +// GL11.glEnable(GL11.GL_BLEND); +// //setDrawBuffers(drawBuffersNone); +// } +// } +// } +// +// public static void midWaterFancy() { +// if (isRenderingWorld) +// { +// if (!isShadowPass) { +// setDrawBuffers(programsDrawBuffers[Shaders.ProgramWater]); +// } +// } +// } + + public static void beginWater() { + if (isRenderingWorld) + { + if (!isShadowPass) { + // program water + useProgram(Shaders.ProgramWater); + GL11.glEnable(GL11.GL_BLEND); + GL11.glDepthMask(true); + } else { + GL11.glDepthMask(true); + } + } + } + + public static void endWater() { + if (isRenderingWorld) + { + if (isShadowPass) { + //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, sfbDepthTexture, 0); + } else { + //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTexture, 0); + } + useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + } + } + + public static void readCenterDepth() { + if (!isShadowPass) { + //Read depth buffer at center of screen for DOF + if (centerDepthSmoothEnabled) + { + tempDirectFloatBuffer.clear(); + glReadPixels(renderWidth / 2, renderHeight / 2, 1, 1, GL11.GL_DEPTH_COMPONENT, GL11.GL_FLOAT, tempDirectFloatBuffer); + centerDepth = tempDirectFloatBuffer.get(0); + + //Smooth depth value + float fadeScalar = diffSystemTime * 0.01f; + float fadeFactor = (float)Math.exp(Math.log(0.5)*fadeScalar / centerDepthSmoothHalflife); + centerDepthSmooth = centerDepthSmooth*(fadeFactor) + centerDepth*(1-fadeFactor); + } + } + } + + public static void beginWeather() { + if(!isShadowPass) + { + if (usedDepthBuffers >= 3) { + // copy depth buffer to depthtex2 + glActiveTexture(GL_TEXTURE12); + glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, renderWidth, renderHeight); + glActiveTexture(GL_TEXTURE0); + } + //GL11.glDepthMask(false); + glEnable(GL_DEPTH_TEST); + glEnable(GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + glEnable(GL_ALPHA_TEST); + useProgram(Shaders.ProgramWeather); + //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbWaterDepthTexture, 0); + } + + //if (isShadowPass) { + // glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // will be set to sbf in endHand() + //} + } + + public static void endWeather() { + //GL11.glDepthMask(true); + glDisable(GL_BLEND); + useProgram(ProgramTexturedLit); + //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTexture, 0); + + //if (isShadowPass) { + // glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sfb); // was set to 0 in beginWeather() + //} + } + + public static void beginProjectRedHalo() { + useProgram(ProgramBasic); + } + public static void endProjectRedHalo() { + useProgram(ProgramTexturedLit); + } + + public static void applyHandDepth() + { + if (Shaders.configHandDepthMul != 1.0) + { + GL11.glScaled(1.0, 1.0, Shaders.configHandDepthMul); + } + } + + public static void beginHand() { + //glEnable(GL_BLEND); + //glDisable(GL_BLEND); + glMatrixMode(GL_MODELVIEW); + glPushMatrix(); + glMatrixMode(GL_PROJECTION); + glPushMatrix(); + glMatrixMode(GL_MODELVIEW); + useProgram(Shaders.ProgramHand); + checkGLError("beginHand"); + checkFramebufferStatus("beginHand"); + } + + public static void endHand() { + //glDisable(GL_BLEND); + checkGLError("pre endHand"); + checkFramebufferStatus("pre endHand"); + glMatrixMode(GL_PROJECTION); + glPopMatrix(); + glMatrixMode(GL_MODELVIEW); + glPopMatrix(); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + //useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + checkGLError("endHand"); + } + + public static void beginFPOverlay() { + //GL11.glDisable(GL11.GL_BLEND); + //GL11.glEnable(GL11.GL_BLEND); + //GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + } + + public static void endFPOverlay() { + //GL11.glDisable(GL11.GL_BLEND); + } + + // ---------------------------------------- + + public static void glEnableWrapper(int cap) { + glEnable(cap); + if (cap == GL_TEXTURE_2D) + enableTexture2D(); + else if (cap == GL_FOG) + enableFog(); + } + + public static void glDisableWrapper(int cap) { + glDisable(cap); + if (cap == GL_TEXTURE_2D) + disableTexture2D(); + else if (cap == GL_FOG) + disableFog(); + } + + public static void sglEnableT2D(int cap) + { + glEnable(cap); //GL_TEXTURE_2D + enableTexture2D(); + } + public static void sglDisableT2D(int cap) + { + glDisable(cap); //GL_TEXTURE_2D + disableTexture2D(); + } + + public static void sglEnableFog(int cap) + { + glEnable(cap); //GL_FOG + enableFog(); + } + public static void sglDisableFog(int cap) + { + glDisable(cap); //GL_FOG + disableFog(); + } + + public static void enableTexture2D() + { + if (isRenderingSky) { + useProgram(ProgramSkyTextured); + } else if (activeProgram == ProgramBasic) { + useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + } + } + public static void disableTexture2D() + { + if (isRenderingSky) { + useProgram(ProgramSkyBasic); + } else if (activeProgram == ProgramTextured || activeProgram == ProgramTexturedLit) { + useProgram(ProgramBasic); + } + } + + public static void enableFog() + { + fogEnabled = true; + setProgramUniform1i("fogMode", fogMode); + } + public static void disableFog() + { + fogEnabled = false; + setProgramUniform1i("fogMode", 0); + } + + public static void sglFogi(int pname, int param) + { + GL11.glFogi(pname, param); + if (pname == GL11.GL_FOG_MODE) { + fogMode = param; + if (fogEnabled) + setProgramUniform1i("fogMode", fogMode); + } + } + + + public static void enableLightmap() { + lightmapEnabled = true; + if (activeProgram == ProgramTextured) { + useProgram(ProgramTexturedLit); + } + } + + public static void disableLightmap() { + lightmapEnabled = false; + if (activeProgram == ProgramTexturedLit) { + useProgram(ProgramTextured); + } + } + + public static int entityData[] = new int[32]; + public static int entityDataIndex = 0; + + public static int getEntityData() + { + return entityData[entityDataIndex*2]; + } + + public static int getEntityData2() { + return entityData[entityDataIndex*2+1]; + } + + public static int setEntityData1(int data1) + { + entityData[entityDataIndex*2 ] = (entityData[entityDataIndex*2 ] & 0xFFFF) | (data1<<16); + return data1; + } + + public static int setEntityData2(int data2) + { + entityData[entityDataIndex*2+1] = (entityData[entityDataIndex*2+1] & 0xFFFF0000) | (data2 & 0xFFFF); + return data2; + } + + public static void pushEntity(int data0, int data1) + { + entityDataIndex++; + entityData[entityDataIndex*2 ] = (data0 & 0xFFFF) | (data1<<16); + entityData[entityDataIndex*2+1] = 0; + } + + public static void pushEntity(int data0) + { + entityDataIndex++; + entityData[entityDataIndex*2 ] = (data0 & 0xFFFF); + entityData[entityDataIndex*2+1] = 0; + } + + public static void pushEntity(Block block) + { + entityDataIndex++; + entityData[entityDataIndex*2 ] = (block.blockRegistry.getIDForObject(block) & 0xFFFF) | (block.getRenderType() << 16); + entityData[entityDataIndex*2+1] = 0; + } + + public static void pushEntity(RenderBlocks rb, Block block, int x, int y, int z) + { + entityDataIndex++; + entityData[entityDataIndex*2 ] = (block.blockRegistry.getIDForObject(block) & 0xFFFF) | (block.getRenderType() << 16); + entityData[entityDataIndex*2+1] = rb.blockAccess.getBlockMetadata(x, y, z); + } + + public static void popEntity() + { + entityData[entityDataIndex*2 ] = 0; + entityData[entityDataIndex*2+1] = 0; + entityDataIndex--; + } + + // ---------------------------------------- + +} diff --git a/java/shadersmodcore/client/ShadersRender.java b/java/shadersmodcore/client/ShadersRender.java new file mode 100644 index 000000000..d0693aec1 --- /dev/null +++ b/java/shadersmodcore/client/ShadersRender.java @@ -0,0 +1,105 @@ +package shadersmodcore.client; + +import static org.objectweb.asm.Opcodes.INVOKESTATIC; + +import java.nio.IntBuffer; + +import org.lwjgl.opengl.GL11; +import shadersmodcore.transform.Names; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockIce; +import net.minecraft.client.renderer.EntityRenderer; +import net.minecraft.client.renderer.ItemRenderer; +import net.minecraft.client.renderer.RenderGlobal; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.WorldRenderer; +import net.minecraft.client.renderer.culling.Frustrum; +import net.minecraft.item.Item; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemCloth; + +public class ShadersRender { + + public static void setFrustrumPosition(Frustrum frustrum, double x, double y, double z) + { + frustrum.setPosition(x, y, z); + } + + public static void clipRenderersByFrustrum(RenderGlobal renderGlobal, Frustrum frustrum, float par2) + { + Shaders.checkGLError("pre clip"); + if (!Shaders.isShadowPass) { + WorldRenderer[] worldRenderers = renderGlobal.worldRenderers; + for (int i = 0; i < worldRenderers.length; ++i) + { + if (!worldRenderers[i].skipAllRenderPasses()) + { + worldRenderers[i].updateInFrustum(frustrum); + } + } + } else { + WorldRenderer[] worldRenderers = renderGlobal.worldRenderers; + for (int i = 0; i < worldRenderers.length; ++i) + { + if (!worldRenderers[i].skipAllRenderPasses()) + { + worldRenderers[i].isInFrustum = true; + } + } + } + } + + public static void renderHand0(EntityRenderer er, float par1, int par2) { + if (!Shaders.isShadowPass) + { + Item item = (Shaders.itemToRender!=null)? Shaders.itemToRender.getItem(): null; + Block block = (item instanceof ItemBlock)? ((ItemBlock)item).field_150939_a: null; + // ItemCloth is for semitransparent block : stained glass, wool + if (!(item instanceof ItemBlock) && !(block instanceof BlockIce)) + { + Shaders.readCenterDepth(); + Shaders.beginHand(); + er.renderHand(par1, par2); + Shaders.endHand(); + Shaders.isHandRendered = true; + } + } + } + + public static void renderHand1(EntityRenderer er, float par1, int par2) { + if (!Shaders.isShadowPass) + { + if (!Shaders.isHandRendered) { + Shaders.readCenterDepth(); + GL11.glEnable(GL11.GL_BLEND); + Shaders.beginHand(); + er.renderHand(par1, par2); + Shaders.endHand(); + Shaders.isHandRendered = true; + } + } + } + + public static void renderItemFP(ItemRenderer itemRenderer, float par1) { + // clear depth buffer locally + GL11.glDepthFunc(GL11.GL_GEQUAL); + GL11.glPushMatrix(); + IntBuffer drawBuffers = Shaders.activeDrawBuffers; + Shaders.setDrawBuffers(Shaders.drawBuffersNone); + itemRenderer.renderItemInFirstPerson(par1); + Shaders.setDrawBuffers(drawBuffers); + GL11.glPopMatrix(); + GL11.glDepthFunc(GL11.GL_LEQUAL); + // really render item or hand + itemRenderer.renderItemInFirstPerson(par1); + } + + public static void renderFPOverlay(EntityRenderer er, float par1, int par2) { + Shaders.beginFPOverlay(); + er.renderHand(par1, par2); + Shaders.endFPOverlay(); + } + +} + diff --git a/java/shadersmodcore/client/ShadersTess.java b/java/shadersmodcore/client/ShadersTess.java new file mode 100644 index 000000000..acb2b2993 --- /dev/null +++ b/java/shadersmodcore/client/ShadersTess.java @@ -0,0 +1,279 @@ +package shadersmodcore.client; + +import static org.lwjgl.opengl.ARBVertexShader.glDisableVertexAttribArrayARB; +import static org.lwjgl.opengl.ARBVertexShader.glEnableVertexAttribArrayARB; +import static org.lwjgl.opengl.ARBVertexShader.glVertexAttribPointerARB; + +import java.nio.FloatBuffer; +import java.nio.ShortBuffer; +import java.util.Arrays; + +import org.lwjgl.opengl.ARBVertexBufferObject; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL13; + +import shadersmodcore.transform.SMCLog; + +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.Tessellator; + +public class ShadersTess { + + public static final int vertexStride = 16; + + public static int draw(Tessellator tess) { + if (!tess.isDrawing) + { + throw new IllegalStateException("Not tesselating!"); + } + else + { + tess.isDrawing = false; + if (tess.drawMode == GL11.GL_QUADS && tess.vertexCount % 4 != 0) { + SMCLog.warning("%s", "bad vertexCount"); + } + int voffset = 0; + int realDrawMode = tess.drawMode; + while (voffset < tess.vertexCount) + { + int vcount; + vcount = Math.min(tess.vertexCount - voffset, tess.byteBuffer.capacity() / (vertexStride*4)); + if (realDrawMode == GL11.GL_QUADS) + vcount = vcount /4 *4; + tess.floatBuffer.clear(); + tess.shortBuffer.clear(); + tess.intBuffer.clear(); + tess.intBuffer.put(tess.rawBuffer, voffset * vertexStride, vcount * vertexStride); + tess.byteBuffer.position(0); + tess.byteBuffer.limit(vcount * (vertexStride * 4)); + voffset += vcount; + + if (tess.hasTexture) + { + tess.floatBuffer.position(3); + GL11.glTexCoordPointer(2, (vertexStride * 4), tess.floatBuffer); + GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + } + if (tess.hasBrightness) + { + OpenGlHelper.setClientActiveTexture(OpenGlHelper.lightmapTexUnit); + tess.shortBuffer.position(6*2); + GL11.glTexCoordPointer(2, (vertexStride * 4), tess.shortBuffer); + GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + OpenGlHelper.setClientActiveTexture(OpenGlHelper.defaultTexUnit); + } + if (tess.hasColor) + { + tess.byteBuffer.position(5*4); + GL11.glColorPointer(4, true, (vertexStride * 4), tess.byteBuffer); + GL11.glEnableClientState(GL11.GL_COLOR_ARRAY); + } + if (tess.hasNormals) + { + tess.floatBuffer.position(9); + GL11.glNormalPointer((vertexStride * 4), tess.floatBuffer); + GL11.glEnableClientState(GL11.GL_NORMAL_ARRAY); + } + tess.floatBuffer.position(0); + GL11.glVertexPointer(3, (vertexStride * 4), tess.floatBuffer); + ShadersTess.preDrawArray(tess); + + GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY); + GL11.glDrawArrays(realDrawMode, 0, vcount); + } + // end loop + + GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY); + ShadersTess.postDrawArray(tess); + if (tess.hasTexture) + { + GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + } + if (tess.hasBrightness) + { + OpenGlHelper.setClientActiveTexture(OpenGlHelper.lightmapTexUnit); + GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + OpenGlHelper.setClientActiveTexture(OpenGlHelper.defaultTexUnit); + } + if (tess.hasColor) + { + GL11.glDisableClientState(GL11.GL_COLOR_ARRAY); + } + if (tess.hasNormals) + { + GL11.glDisableClientState(GL11.GL_NORMAL_ARRAY); + } + + int n = tess.rawBufferIndex * 4; + tess.reset(); + return n; + } + } + + public static void preDrawArray(Tessellator tess) + { + //Shaders.checkGLError("preDrawArray"); + if (Shaders.useMultiTexCoord3Attrib && tess.hasTexture) + { + GL13.glClientActiveTexture(GL13.GL_TEXTURE3); + GL11.glTexCoordPointer(2, (vertexStride * 4), (FloatBuffer)tess.floatBuffer.position(12)); + GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + GL13.glClientActiveTexture(GL13.GL_TEXTURE0); + } + if (Shaders.useMidTexCoordAttrib && tess.hasTexture) + { + glVertexAttribPointerARB(Shaders.midTexCoordAttrib, 2, false, vertexStride*4, (FloatBuffer)tess.floatBuffer.position(12)); + glEnableVertexAttribArrayARB(Shaders.midTexCoordAttrib); + } + if (Shaders.useEntityAttrib) + { + glVertexAttribPointerARB(Shaders.entityAttrib, 3, false, false, vertexStride*4, (ShortBuffer)tess.shortBuffer.position(7*2)); + glEnableVertexAttribArrayARB(Shaders.entityAttrib); + } + //Shaders.checkGLError("preDrawArray"); + } + public static void preDrawArrayVBO(Tessellator tess) + { + //Shaders.checkGLError("preDrawArray"); + if (Shaders.useMultiTexCoord3Attrib && tess.hasTexture) + { + GL13.glClientActiveTexture(GL13.GL_TEXTURE3); + GL11.glTexCoordPointer(2, GL11.GL_FLOAT, (vertexStride * 4), 12*4L); + GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + GL13.glClientActiveTexture(GL13.GL_TEXTURE0); + } + if (Shaders.useMidTexCoordAttrib && tess.hasTexture) + { + glVertexAttribPointerARB(Shaders.midTexCoordAttrib, 2, GL11.GL_FLOAT, false, vertexStride*4, 12*4L); + glEnableVertexAttribArrayARB(Shaders.midTexCoordAttrib); + } + if (Shaders.useEntityAttrib) + { + glVertexAttribPointerARB(Shaders.entityAttrib, 3, GL11.GL_SHORT, false, vertexStride*4, 7*4L); + glEnableVertexAttribArrayARB(Shaders.entityAttrib); + } + //Shaders.checkGLError("preDrawArray"); + } + + public static void postDrawArray(Tessellator tess) + { + //Shaders.checkGLError("postDrawArray"); + if (Shaders.useEntityAttrib) + { + glDisableVertexAttribArrayARB(Shaders.entityAttrib); + } + if (Shaders.useMidTexCoordAttrib && tess.hasTexture) + { + glDisableVertexAttribArrayARB(Shaders.midTexCoordAttrib); + } + if (Shaders.useMultiTexCoord3Attrib && tess.hasTexture) + { + GL13.glClientActiveTexture(GL13.GL_TEXTURE3); + GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + GL13.glClientActiveTexture(GL13.GL_TEXTURE0); + } + //Shaders.checkGLError("postDrawArray"); + } + + public static void addVertex(Tessellator tess, double parx, double pary, double parz) { + int[] rawBuffer = tess.rawBuffer; + int rbi = tess.rawBufferIndex; + float fx = (float) (parx + tess.xOffset); + float fy = (float) (pary + tess.yOffset); + float fz = (float) (parz + tess.zOffset); + // Check if buffer is nearly full + if (rbi >= tess.bufferSize - vertexStride*4) + { + if (tess.bufferSize >= 0x1000000) { + // Max size reached. Just draw. + if (tess.addedVertices % 4 == 0) + { + tess.draw(); + tess.isDrawing = true; + } + } else if (tess.bufferSize > 0) { + // Expand + tess.bufferSize *= 2; + tess.rawBuffer = rawBuffer = Arrays.copyOf(tess.rawBuffer, tess.bufferSize); + System.out.format("Expand tesselator buffer %d\n",tess.bufferSize); + } else { + // Initialize + tess.bufferSize = 0x10000; + tess.rawBuffer = rawBuffer = new int[tess.bufferSize]; + } + } + + // shaders mod calculate normal and mid UV + if (tess.drawMode == 7) + { + int i = tess.addedVertices % 4; + float[] vertexPos = tess.vertexPos; + vertexPos[i*4+0] = fx; + vertexPos[i*4+1] = fy; + vertexPos[i*4+2] = fz; + if (i==3) + { + // calculate normal + float x1 = vertexPos[ 8+0] - vertexPos[ +0]; + float y1 = vertexPos[ 8+1] - vertexPos[ +1]; + float z1 = vertexPos[ 8+2] - vertexPos[ +2]; + float x2 = vertexPos[12+0] - vertexPos[ 4+0]; + float y2 = vertexPos[12+1] - vertexPos[ 4+1]; + float z2 = vertexPos[12+2] - vertexPos[ 4+2]; + float vnx = y1*z2-y2*z1; + float vny = z1*x2-z2*x1; + float vnz = x1*y2-x2*y1; + float lensq = vnx*vnx+vny*vny+vnz*vnz; + float mult = (lensq!=0.0)? (float)(1f/Math.sqrt(lensq)): 1f; + rawBuffer[rbi+( 9-vertexStride*3)] = + rawBuffer[rbi+( 9-vertexStride*2)] = + rawBuffer[rbi+( 9-vertexStride*1)] = Float.floatToRawIntBits(tess.normalX = vnx*mult); + rawBuffer[rbi+(10-vertexStride*3)] = + rawBuffer[rbi+(10-vertexStride*2)] = + rawBuffer[rbi+(10-vertexStride*1)] = Float.floatToRawIntBits(tess.normalY = vny*mult); + rawBuffer[rbi+(11-vertexStride*3)] = + rawBuffer[rbi+(11-vertexStride*2)] = + rawBuffer[rbi+(11-vertexStride*1)] = Float.floatToRawIntBits(tess.normalZ = vnz*mult); + tess.hasNormals = true; + // mid UV + tess.midTextureU = ( + Float.intBitsToFloat(rawBuffer[rbi+(3-vertexStride*3)])+ + Float.intBitsToFloat(rawBuffer[rbi+(3-vertexStride*2)])+ + Float.intBitsToFloat(rawBuffer[rbi+(3-vertexStride*1)])+ + (float)tess.textureU )/4; + tess.midTextureV = ( + Float.intBitsToFloat(rawBuffer[rbi+(4-vertexStride*3)])+ + Float.intBitsToFloat(rawBuffer[rbi+(4-vertexStride*2)])+ + Float.intBitsToFloat(rawBuffer[rbi+(4-vertexStride*1)])+ + (float)tess.textureV )/4; + rawBuffer[rbi+(12-vertexStride*3)] = + rawBuffer[rbi+(12-vertexStride*2)] = + rawBuffer[rbi+(12-vertexStride*1)] = Float.floatToRawIntBits(tess.midTextureU); + rawBuffer[rbi+(13-vertexStride*3)] = + rawBuffer[rbi+(13-vertexStride*2)] = + rawBuffer[rbi+(13-vertexStride*1)] = Float.floatToRawIntBits(tess.midTextureV); + } + } + // end normal and mid UV calculation + + ++tess.addedVertices; + rawBuffer[rbi + 0] = Float.floatToRawIntBits((float)fx); + rawBuffer[rbi + 1] = Float.floatToRawIntBits((float)fy); + rawBuffer[rbi + 2] = Float.floatToRawIntBits((float)fz); + rawBuffer[rbi + 3] = Float.floatToRawIntBits((float)tess.textureU); + rawBuffer[rbi + 4] = Float.floatToRawIntBits((float)tess.textureV); + rawBuffer[rbi + 5] = tess.color; + rawBuffer[rbi + 6] = tess.brightness; + rawBuffer[rbi + 7] = Shaders.getEntityData(); + rawBuffer[rbi + 8] = Shaders.getEntityData2(); + rawBuffer[rbi + 9] = Float.floatToRawIntBits((float)tess.normalX); + rawBuffer[rbi +10] = Float.floatToRawIntBits((float)tess.normalY); + rawBuffer[rbi +11] = Float.floatToRawIntBits((float)tess.normalZ); + rawBuffer[rbi +12] = Float.floatToRawIntBits((float)tess.midTextureU); + rawBuffer[rbi +13] = Float.floatToRawIntBits((float)tess.midTextureV); + + tess.rawBufferIndex = rbi += vertexStride; + ++tess.vertexCount; + } +} + diff --git a/java/shadersmodcore/client/ShadersTex.java b/java/shadersmodcore/client/ShadersTex.java new file mode 100644 index 000000000..f764116c1 --- /dev/null +++ b/java/shadersmodcore/client/ShadersTex.java @@ -0,0 +1,969 @@ +package shadersmodcore.client; + +import java.awt.image.BufferedImage; +import java.awt.image.ImageObserver; +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.IntBuffer; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import javax.imageio.ImageIO; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.GLAllocation; +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.texture.AbstractTexture; +import net.minecraft.client.renderer.texture.DynamicTexture; +import net.minecraft.client.renderer.texture.ITextureObject; +import net.minecraft.client.renderer.texture.LayeredTexture; +import net.minecraft.client.renderer.texture.Stitcher; +import net.minecraft.client.renderer.texture.TextureManager; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.client.renderer.texture.TextureUtil; +import net.minecraft.util.ResourceLocation; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.resources.IResource; +import net.minecraft.client.resources.IResourceManager; + +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.ARBTextureStorage; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; +import org.lwjgl.opengl.GL13; +import org.lwjgl.opengl.GL14; +import org.lwjgl.opengl.GL20; +import org.lwjgl.opengl.GL30; +import org.lwjgl.opengl.GL30.*; + +public class ShadersTex { + public static final int initialBufferSize = 1048576; + public static ByteBuffer byteBuffer = BufferUtils.createByteBuffer(initialBufferSize*4); + public static IntBuffer intBuffer = byteBuffer.asIntBuffer(); + public static int[] intArray = new int[initialBufferSize]; + public static final int defBaseTexColor = 0x00000000; + public static final int defNormTexColor = 0xFF7F7FFF; + public static final int defSpecTexColor = 0x00000000; + public static Map multiTexMap = new HashMap(); + public static TextureMap updatingTextureMap = null; + public static TextureAtlasSprite updatingSprite = null; + public static MultiTexID updatingTex = null; + public static MultiTexID boundTex = null; + public static int updatingPage = 0; + public static String iconName = null; + + public static IntBuffer getIntBuffer(int size) + { + if (intBuffer.capacity() < size) + { + int bufferSize = roundUpPOT(size); + byteBuffer = BufferUtils.createByteBuffer(bufferSize*4); + intBuffer = byteBuffer.asIntBuffer(); + } + return intBuffer; + } + + public static int[] getIntArray(int size) + { + if (intArray.length < size) + { + intArray = null; + intArray = new int[roundUpPOT(size)]; + } + return intArray; + } + + public static int roundUpPOT(int x) + { + int i = x-1; + i |= (i>>1); + i |= (i>>2); + i |= (i>>4); + i |= (i>>8); + i |= (i>>16); + return i+1; + } + + public static IntBuffer fillIntBuffer(int size, int value) + { + int[] aint = getIntArray(size); + IntBuffer intBuf = getIntBuffer(size); + Arrays.fill(intArray, 0, size, value); + intBuffer.put(intArray, 0, size); + return intBuffer; + } + + public static int[] createAIntImage(int size) + { + int[] aint = new int[size*3]; + Arrays.fill(aint, 0, size, defBaseTexColor); + Arrays.fill(aint, size, size*2, defNormTexColor); + Arrays.fill(aint, size*2, size*3, defSpecTexColor); + return aint; + } + + public static int[] createAIntImage(int size, int color) + { + int[] aint = new int[size*3]; + Arrays.fill(aint, 0, size, color); + Arrays.fill(aint, size, size*2, defNormTexColor); + Arrays.fill(aint, size*2, size*3, defSpecTexColor); + return aint; + } + + public static MultiTexID getMultiTexID(AbstractTexture tex) + { + MultiTexID multiTex = tex.multiTex; + if (multiTex==null) + { + int baseTex = tex.getGlTextureId(); + multiTex = multiTexMap.get(Integer.valueOf(baseTex)); + if (multiTex == null) + { + multiTex = new MultiTexID(baseTex, GL11.glGenTextures(), GL11.glGenTextures()); + multiTexMap.put(baseTex, multiTex); + } + tex.multiTex = multiTex; + } + return multiTex; + } + + public static void deleteTextures(AbstractTexture atex) + { + int texid = atex.glTextureId; + if (texid != -1) + { + GL11.glDeleteTextures(texid); + atex.glTextureId = -1; + } + MultiTexID multiTex = atex.multiTex; + if (multiTex != null) + { + atex.multiTex = null; + multiTexMap.remove(Integer.valueOf(multiTex.base)); + GL11.glDeleteTextures(multiTex.norm); + GL11.glDeleteTextures(multiTex.spec); + if (multiTex.base != texid) + { + System.err.println("Error : MultiTexID.base mismatch."); + GL11.glDeleteTextures(multiTex.base); + } + } + } + + /** Remove MultiTexID object reference and delete textures */ + public static int deleteMultiTex(ITextureObject tex) + { + if (tex instanceof AbstractTexture) { + deleteTextures((AbstractTexture)tex); + } else { + GL11.glDeleteTextures(tex.getGlTextureId()); + } + return 0; + } + + public static void bindNSTextures(int normTex, int specTex) + { + //Shaders.checkGLError("pre bindNSTextures"); + if (Shaders.isRenderingWorld && Shaders.activeTexUnit == GL13.GL_TEXTURE0) + { + GL13.glActiveTexture(GL13.GL_TEXTURE2); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, normTex); + GL13.glActiveTexture(GL13.GL_TEXTURE3); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, specTex); + GL13.glActiveTexture(GL13.GL_TEXTURE0); + } + //Shaders.checkGLError("bindNSTextures"); + } + + public static void bindNSTextures(MultiTexID multiTex) + { + bindNSTextures(multiTex.norm, multiTex.spec); + } + + public static void bindTextures(int baseTex, int normTex, int specTex) + { + //Shaders.checkGLError("pre bindTextures"); + if (Shaders.isRenderingWorld && Shaders.activeTexUnit == GL13.GL_TEXTURE0) + { + GL13.glActiveTexture(GL13.GL_TEXTURE2); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, normTex); + GL13.glActiveTexture(GL13.GL_TEXTURE3); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, specTex); + GL13.glActiveTexture(GL13.GL_TEXTURE0); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, baseTex); + //Shaders.checkGLError("bindTextures"); + } + + public static void bindTextures(MultiTexID multiTex) + { + boundTex = multiTex; + if (Shaders.isRenderingWorld && Shaders.activeTexUnit == GL13.GL_TEXTURE0) + { + if (Shaders.configNormalMap) { + GL13.glActiveTexture(GL13.GL_TEXTURE2); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + } + if (Shaders.configSpecularMap) { + GL13.glActiveTexture(GL13.GL_TEXTURE3); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + } + GL13.glActiveTexture(GL13.GL_TEXTURE0); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + } + + public static void bindTexture(ITextureObject tex) + { + if (tex instanceof TextureMap) { + Shaders.atlasSizeX = ((TextureMap)tex).atlasWidth; + Shaders.atlasSizeY = ((TextureMap)tex).atlasHeight; + } else { + Shaders.atlasSizeX = 0; + Shaders.atlasSizeY = 0; + } + bindTextures(tex.getMultiTexID()); + } + + /** not used */ + public static void bindTextures(int baseTex) + { + MultiTexID multiTex = multiTexMap.get(Integer.valueOf(baseTex)); + bindTextures(multiTex); + } + + public static void allocTexStorage(int width, int height, int maxLevel) + { + Shaders.checkGLError("pre allocTexStorage"); + int level; + for (level=0; (width>>level)>0 && (height>>level)>0 /*&& level<=maxLevel*/; ++level) { + GL11.glTexImage2D(GL11.GL_TEXTURE_2D, level, GL11.GL_RGBA, (width>>level), (height>>level), 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, (IntBuffer)null); + } + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, level-1); + Shaders.checkGLError("allocTexStorage"); + //clear unused level otherwise glTexSubImage2D will crash on AMD when reallocation texture of different size. + //for ( ; level < 16 ; ++level) { + // GL11.glTexImage2D(GL11.GL_TEXTURE_2D, level, GL11.GL_RGBA, 0, 0, 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, (IntBuffer)null); + //} + GL11.glGetError(); // It usually returns error 0x0501 Invalid value for width 0 height 0. Ignore it. + } + + // for Dynamic Texture + public static void initDynamicTexture(int texID, int width, int height, DynamicTexture tex) + { + MultiTexID multiTex = tex.getMultiTexID(); + int[] aint = tex.getTextureData(); + int size = width * height; + Arrays.fill(aint, size, size*2, defNormTexColor); + Arrays.fill(aint, size*2, size*3, defSpecTexColor); + // base texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + allocTexStorage(width,height,0); + 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); + 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); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0); + + // norm texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + allocTexStorage(width,height,0); + 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); + 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); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0); + + // spec texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + allocTexStorage(width,height,0); + 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); + 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); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0); + + // base texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + } + + public static ITextureObject createDefaultTexture() + { + DynamicTexture tex = new DynamicTexture(1,1); + tex.getTextureData()[0] = 0xffffffff; + tex.updateDynamicTexture(); + return tex; + } + + // for TextureMap + public static void allocateTextureMap(int texID, int mipmapLevels, int width, int height, float anisotropy, Stitcher stitcher, TextureMap tex) + { + System.out.println("allocateTextureMap "+tex.getTextureType()+" "+mipmapLevels+" "+width+" "+height+" "+anisotropy+" "); + updatingTextureMap = tex; + tex.atlasWidth = width; + tex.atlasHeight = height; + MultiTexID multiTex = getMultiTexID(tex); + updatingTex = multiTex; + TextureUtil.allocateTextureImpl(multiTex.base, mipmapLevels, width, height, anisotropy); + if (Shaders.configNormalMap ) + TextureUtil.allocateTextureImpl(multiTex.norm, mipmapLevels, width, height, anisotropy); + if (Shaders.configSpecularMap) + TextureUtil.allocateTextureImpl(multiTex.spec, mipmapLevels, width, height, anisotropy); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, texID); + } + + public static TextureAtlasSprite setSprite(TextureAtlasSprite tas) + { + return updatingSprite = tas; + } + + public static String setIconName(String name) + { + return iconName = name; + } + + public static void uploadTexSubForLoadAtlas(int[][] data, int width, int height, int xoffset, int yoffset, boolean linear, boolean clamp) + { + TextureUtil.uploadTextureMipmap(data, width, height, xoffset, yoffset, linear, clamp); + boolean border = updatingSprite.useAnisotropicFiltering; + int[][] aaint; + // + if (Shaders.configNormalMap ) { + aaint = readImageAndMipmaps(iconName+"_n", width, height, data.length, border, defNormTexColor); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.norm); + TextureUtil.uploadTextureMipmap(aaint, width, height, xoffset, yoffset, linear, clamp); + } + // + if (Shaders.configSpecularMap) { + aaint = readImageAndMipmaps(iconName+"_s", width, height, data.length, border, defSpecTexColor); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.spec); + TextureUtil.uploadTextureMipmap(aaint, width, height, xoffset, yoffset, linear, clamp); + } + // + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.base); + } + + public static int[][] readImageAndMipmaps(String name, int width, int height, int numLevels, boolean border, int defColor) + { + int[][] aaint = new int[numLevels][]; + int[] aint; + aaint[0] = aint = new int[width*height]; + boolean goodImage = false; + BufferedImage image = readImage(updatingTextureMap.completeResourceLocation(new ResourceLocation(name), 0)); + if (image != null) { + int imageWidth = image.getWidth(); + int imageHeight = image.getHeight(); + if (imageWidth + (border? 16: 0) == width) + { + goodImage = true; + image.getRGB(0, 0, imageWidth, imageWidth, aint, 0, imageWidth); + if (border) + TextureUtil.prepareAnisotropicData(aint, imageWidth, imageWidth, 8); + } + } + if (!goodImage) { + Arrays.fill(aint, defColor); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.spec); + aaint = genMipmapsSimple(aaint.length-1, width, aaint); + return aaint; + } + + public static BufferedImage readImage(ResourceLocation resLoc) + { + BufferedImage image = null; + InputStream istr = null; + try { + istr = resManager.getResource(resLoc).getInputStream(); + image = ImageIO.read(istr); + } catch (IOException e) { + } + if (istr != null) { + try { + istr.close(); + } catch (IOException e) { + } + istr = null; + } + return image; + } + + public static int[][] genMipmapsSimple(int maxLevel, int width, int[][]data) + { + int level; + for (level=1; level<=maxLevel; ++level) + { + if (data[level]==null) + { + int cw = width>>level; + int pw = cw*2; + int[] aintp = data[level-1]; + int[] aintc = data[level] = new int[cw*cw]; + int x,y; + for (y=0; y>> 24) & 255; + int a1 = (c1 >>> 24) & 255; + int a2 = (c2 >>> 24) & 255; + int a3 = (c3 >>> 24) & 255; + int as = a0+a1+a2+a3; + int an = (as+2)/4; + //int an = Math.min(Math.min(Math.min(a0,a1),a2),a3); + int dv; + if (as != 0) { + dv = as; + } else { + dv=4; a3=a2=a1=a0=1; + } + int frac = (dv+1)/2; + //return (((Math.min(Math.min(Math.min(a0,a1),a2),a3)/ 4) << 24) | + int color = (an << 24) | + (((((c0>>>16)&255)*a0 + ((c1>>>16)&255)*a1 + ((c2>>>16)&255)*a2 + ((c3>>>16)&255)*a3 + frac)/dv) << 16) | + (((((c0>>> 8)&255)*a0 + ((c1>>> 8)&255)*a1 + ((c2>>> 8)&255)*a2 + ((c3>>> 8)&255)*a3 + frac)/dv) << 8) | + (((((c0>>> 0)&255)*a0 + ((c1>>> 0)&255)*a1 + ((c2>>> 0)&255)*a2 + ((c3>>> 0)&255)*a3 + frac)/dv) << 0) ; + return color; + } + + public static int blend4Simple(int c0, int c1, int c2, int c3) + { + int color = + (((((c0>>>24)&255) + ((c1>>>24)&255) + ((c2>>>24)&255) + ((c3>>>24)&255) + 2)/4) << 24) | + (((((c0>>>16)&255) + ((c1>>>16)&255) + ((c2>>>16)&255) + ((c3>>>16)&255) + 2)/4) << 16) | + (((((c0>>> 8)&255) + ((c1>>> 8)&255) + ((c2>>> 8)&255) + ((c3>>> 8)&255) + 2)/4) << 8) | + (((((c0>>> 0)&255) + ((c1>>> 0)&255) + ((c2>>> 0)&255) + ((c3>>> 0)&255) + 2)/4) << 0) ; + return color; + } + + + public static void genMipmapAlpha(int[] aint, int offset, int width, int height) + { + int minwh = Math.min(width, height); + int level; + int w1, w2, h1, h2, o1, o2; + w1 = w2 = width; + h1 = h2 = height; + o1 = o2 = offset; + // generate mipmap from big to small + o2 = offset; w2 = width; h2 = height; + o1 = 0; w1 = 0; h1 = 0; + for (level=0; w2>1 && h2>1; ++level,w2=w1,h2=h1,o2=o1) { + o1 = o2 + w2*h2; + w1 = w2/2; h1 = h2/2; + for (int y=0; y0) + { + --level; + w2 = width>>level; + h2 = height>>level; + o2 = o1 - w2*h2; + int p2 = o2; + for (int y=0; y1 && h2>1; ++level,w2=w1,h2=h1,o2=o1) { + o1 = o2 + w2*h2; + w1 = w2/2; h1 = h2/2; + for (int y=0; y0) + { + --level; + w2 = width>>level; + h2 = height>>level; + o2 = o1 - w2*h2; + int p2 = o2; + for (int y=0; y>> 24 == 255 && aint[size-1] == 0) + return true; + for (int i=0; i>> 24; + if (alpha!=0 && alpha!=255) + return true; + } + return false; + } + + public static void updateSubImage1(int[] src, int width, int height, int posX, int posY, int page, int color) + { + int size = width * height; + IntBuffer intBuf = getIntBuffer(size); + int[] aint = getIntArray((size*4+2)/3); + if (src.length >= size*(page+1)) + { + System.arraycopy(src, size*page, aint, 0, size); + } + else + { + Arrays.fill(aint, color); + } + // +// if (page == 0) + genMipmapAlpha(aint,0,width,height); +// else +// genMipmapSimple(aint,0,width,height); + // + for (int level=0, offset=0, lw=width, lh=height, px=posX, py=posY; + lw>0 && lh>0; + ++level) + { + int lsize = lw*lh; + intBuf.clear(); + intBuf.put(aint, offset, lsize).position(0).limit(lsize); + GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, level, px, py, lw, lh, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); + offset += lsize; lw/=2; lh/=2; px/=2; py/=2; + } + intBuf.clear(); + } + + public static void updateSubTex1(int[] src, int width, int height, int posX, int posY) + { + int level; + int cw; + int ch; + int cx; + int cy; + for (level = 0, cw=width, ch=height, cx=posX, cy=posY; + cw>0 && ch>0; + ++level, cw/=2, ch/=2, cx/=2, cy/=2) + { + GL11.glCopyTexSubImage2D(GL11.GL_TEXTURE_2D, level, cx, cy, 0, 0, cw, ch); + } + } + + /* updateSubImage for single Texture with mipmap */ + public static void updateSubImage1(int[][] src, int width, int height, int posX, int posY, int page, int color) + { + int size = width * height; + IntBuffer intBuf = getIntBuffer(size); + int numLevel = src.length; + for (int level=0, //offset=0, + lw=width, lh=height, px=posX, py=posY; + lw>0 && lh>0 && level iterator; + MultiTexID multiTex = tex.getMultiTexID(); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + for (iterator = tasList.iterator(); iterator.hasNext(); ) + { + TextureAtlasSprite tas = iterator.next(); + tas.updateAnimation(); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + for (iterator = tasList.iterator(); iterator.hasNext(); ) + { + TextureAtlasSprite tas = iterator.next(); + tas.updateAnimation(); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + for (iterator = tasList.iterator(); iterator.hasNext(); ) + { + TextureAtlasSprite tas = iterator.next(); + tas.updateAnimation(); + } + } + + public static void setupTexture(MultiTexID multiTex, int[] src, int width, int height, boolean linear, boolean clamp) + { + int mmfilter = linear? GL11.GL_LINEAR: GL11.GL_NEAREST; + int wraptype = clamp? GL11.GL_CLAMP: GL11.GL_REPEAT; + int size = width * height; + IntBuffer intBuf = getIntBuffer(size); + // + intBuf.clear(); + intBuf.put(src, 0, size).position(0).limit(size); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, wraptype); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, wraptype); + // + intBuf.put(src, size, size).position(0).limit(size); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, wraptype); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, wraptype); + // + intBuf.put(src, size*2, size).position(0).limit(size); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, wraptype); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, wraptype); + // + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + } + + /* currently not used */ + public static void updateSubImage(MultiTexID multiTex, int[] src, int width, int height, int posX, int posY, boolean linear, boolean clamp) + { + int size = width * height; + IntBuffer intBuf = getIntBuffer(size); + // + intBuf.clear(); + intBuf.put(src, 0, size); + intBuf.position(0).limit(size); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + 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); + 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); + GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, posX, posY, width, height, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); + if (src.length == size*3) + { + intBuf.clear(); + intBuf.put(src, size, size).position(0); + intBuf.position(0).limit(size); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + 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); + 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); + GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, posX, posY, width, height, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); + if (src.length == size*3) + { + intBuf.clear(); + intBuf.put(src, size*2, size); + intBuf.position(0).limit(size); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + 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); + 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); + GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, posX, posY, width, height, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); + GL13.glActiveTexture(GL13.GL_TEXTURE0); + } + + public static ResourceLocation getNSMapLocation(ResourceLocation location, String mapName) + { + String basename = location.getResourcePath(); + String[] basenameParts = basename.split(".png"); + String basenameNoFileType = basenameParts[0]; + return new ResourceLocation(location.getResourceDomain(),basenameNoFileType+"_"+mapName+".png"); + } + + public static void loadNSMap(IResourceManager manager, ResourceLocation location, int width, int height, int[] aint) + { + if (Shaders.configNormalMap) + ShadersTex.loadNSMap1(manager, getNSMapLocation(location,"n"), width, height, aint, width*height , defNormTexColor); + if (Shaders.configSpecularMap) + ShadersTex.loadNSMap1(manager, getNSMapLocation(location,"s"), width, height, aint, width*height*2, defSpecTexColor); + } + + public static void loadNSMap1(IResourceManager manager, ResourceLocation location, int width, int height, int[] aint, int offset, int defaultColor) + { + boolean good = false; + try + { + IResource res = manager.getResource(location); + BufferedImage bufferedimage = ImageIO.read(res.getInputStream()); + if (bufferedimage.getWidth()==width && bufferedimage.getHeight()==height) + { + bufferedimage.getRGB(0, 0, width, height, aint, offset, width); + good = true; + } + } + catch (IOException ex) + { + } + if (!good) + { + java.util.Arrays.fill(aint,offset,offset+width*height,defaultColor); + } + } + + /** init and upload from BufferedImage */ + /* Replacement for TextureUtil.func_110989_a call in SimpleTexture.func_110551_a. + Keep par0...par5 the same as func_110989_a for easy patching. + More parameters added for reading N-S-Map. */ + public static int loadSimpleTexture(int textureID, + BufferedImage bufferedimage, boolean linear, boolean clamp, + IResourceManager resourceManager, ResourceLocation location, MultiTexID multiTex) + { + int width = bufferedimage.getWidth(); + int height = bufferedimage.getHeight(); + int size = width*height; + int[] aint = getIntArray(size*3); + bufferedimage.getRGB(0, 0, width, height, aint, 0, width); + loadNSMap(resourceManager, location, width, height, aint); + setupTexture(multiTex, aint, width, height, linear, clamp); + return textureID; + } + + public static void mergeImage(int[] aint, int dstoff, int srcoff, int size) + { + + } + + public static int blendColor(int color1, int color2, int factor1) + { + int factor2 = 255-factor1; + return + (( (((color1>>>24)&255)*factor1 + ((color2>>>24)&255)*factor2) /255 ) << 24) | + (( (((color1>>>16)&255)*factor1 + ((color2>>>16)&255)*factor2) /255 ) << 16) | + (( (((color1>>> 8)&255)*factor1 + ((color2>>> 8)&255)*factor2) /255 ) << 8) | + (( (((color1>>> 0)&255)*factor1 + ((color2>>> 0)&255)*factor2) /255 ) << 0); + } + + public static void loadLayeredTexture(LayeredTexture tex, IResourceManager manager, List list) + { + int width = 0; + int height = 0; + int size = 0; + int[] image = null; + Iterator iterator; + for (iterator = list.iterator(); iterator.hasNext(); ) + { + String s = iterator.next(); + if (s != null) + { + try + { + ResourceLocation location = new ResourceLocation(s); + InputStream inputstream = manager.getResource(location).getInputStream(); + BufferedImage bufimg = ImageIO.read(inputstream); + + if (size == 0) + { + width = bufimg.getWidth(); + height = bufimg.getHeight(); + size = width*height; + image = createAIntImage(size,0x00000000); + } + int[] aint = getIntArray(size * 3); + bufimg.getRGB(0, 0, width, height, aint, 0, width); + loadNSMap(manager, location, width, height, aint); + // merge + for (int i = 0; i < size; ++i) + { + int alpha = (aint[i] >>> 24) & 255; + image[size*0+i] = blendColor(aint[size*0+i], image[size*0+i], alpha); + image[size*1+i] = blendColor(aint[size*1+i], image[size*1+i], alpha); + image[size*2+i] = blendColor(aint[size*2+i], image[size*2+i], alpha); + } + } + catch (IOException ex) + { + ex.printStackTrace(); + } + } + } + // init and upload + setupTexture(tex.getMultiTexID(), image, width, height, false, false); + } + + /* update block texture filter +/- items texture */ + static void updateTextureMinMagFilter() + { + TextureManager texman = Minecraft.getMinecraft().getTextureManager(); + ITextureObject texObj = texman.getTexture(TextureMap.locationBlocksTexture); + if (texObj != null) + { + MultiTexID multiTex = texObj.getMultiTexID(); + // base texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, Shaders.texMinFilValue[Shaders.configTexMinFilB]); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, Shaders.texMagFilValue[Shaders.configTexMagFilB]); + // norm texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, Shaders.texMinFilValue[Shaders.configTexMinFilN]); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, Shaders.texMagFilValue[Shaders.configTexMagFilN]); + + // spec texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, Shaders.texMinFilValue[Shaders.configTexMinFilS]); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, Shaders.texMagFilValue[Shaders.configTexMagFilS]); + + GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0); + } + } + + + static IResourceManager resManager = null; + static ResourceLocation resLocation = null; + static int imageSize = 0; + + public static IResource loadResource(IResourceManager manager, ResourceLocation location) throws IOException + { + resManager = manager; + resLocation = location; + return manager.getResource(location); + } + + public static int[] loadAtlasSprite(BufferedImage bufferedimage, int startX, int startY, int w, int h, int[] aint, int offset, int scansize) + { + imageSize = w*h; + bufferedimage.getRGB(startX, startY, w, h, aint, offset, scansize); + loadNSMap(resManager, resLocation, w, h, aint); + return aint; + } + + public static int[] extractFrame(int[] src, int width, int height, int frameIndex) + { + int srcSize = imageSize; + int frameSize = width * height; + int[] dst = new int[frameSize * 3]; + int srcPos = frameSize * frameIndex; + int dstPos = 0; + System.arraycopy(src, srcPos, dst, dstPos, frameSize); + srcPos += srcSize; dstPos += frameSize; + System.arraycopy(src, srcPos, dst, dstPos, frameSize); + srcPos += srcSize; dstPos += frameSize; + System.arraycopy(src, srcPos, dst, dstPos, frameSize); + return dst; + } + + public static void fixTransparentColor(TextureAtlasSprite tas, int[] aint) { + } +} diff --git a/java/shadersmodcore/loading/SMCTweaker.java b/java/shadersmodcore/loading/SMCTweaker.java new file mode 100644 index 000000000..1f05d7435 --- /dev/null +++ b/java/shadersmodcore/loading/SMCTweaker.java @@ -0,0 +1,57 @@ +package shadersmodcore.loading; + +import java.io.File; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import net.minecraft.launchwrapper.ITweaker; +import net.minecraft.launchwrapper.Launch; +import net.minecraft.launchwrapper.LaunchClassLoader; + +public class SMCTweaker implements ITweaker { + public List args; + public File gameDir; + public File assetsDir; + public String version; + + @Override + public void acceptOptions(List args, File gameDir, File assetsDir, String version) { + this.args = args; + this.gameDir = gameDir; + this.assetsDir = assetsDir; + this.version = version; + } + + @Override + public void injectIntoClassLoader(LaunchClassLoader launchClassLoader) { + launchClassLoader.addTransformerExclusion("shadersmodcore.loading."); + launchClassLoader.addTransformerExclusion("shadersmodcore.transform."); + launchClassLoader.registerTransformer("shadersmodcore.transform.SMCClassTransformer"); + } + + @Override + public String[] getLaunchArguments() { + ArrayList argumentList = (ArrayList)Launch.blackboard.get("ArgumentList"); + if (argumentList.isEmpty()) { + List argsList = new ArrayList(); + if (gameDir != null) { + argumentList.add("--gameDir"); + argumentList.add(gameDir.getPath()); + } + if (assetsDir != null) { + argumentList.add("--assetsDir"); + argumentList.add(assetsDir.getPath()); + } + argumentList.add("--version"); + argumentList.add(version); + argumentList.addAll(args); + } + return new String[0]; + } + + @Override + public String getLaunchTarget() { + return "net.minecraft.client.main.Main"; + } +} diff --git a/java/shadersmodcore/transform/InitNames.java b/java/shadersmodcore/transform/InitNames.java new file mode 100644 index 000000000..8506d328b --- /dev/null +++ b/java/shadersmodcore/transform/InitNames.java @@ -0,0 +1,8 @@ +package shadersmodcore.transform; + +public class InitNames { + public static void init() + { + new NamerSrg().setNames(); + } +} diff --git a/java/shadersmodcore/transform/Namer.java b/java/shadersmodcore/transform/Namer.java new file mode 100644 index 000000000..047b4a12e --- /dev/null +++ b/java/shadersmodcore/transform/Namer.java @@ -0,0 +1,43 @@ +package shadersmodcore.transform; + +import java.util.ArrayList; + +import shadersmodcore.transform.Names.Clas; +import shadersmodcore.transform.Names.Fiel; +import shadersmodcore.transform.Names.Meth; + +public class Namer { + + ArrayList ac = new ArrayList(); + ArrayList af = new ArrayList(); + ArrayList am = new ArrayList(); + + Clas c(String name) { + Clas x = new Clas(name); + if (ac!=null) ac.add(x); + return x; + } + Fiel f(Clas clas, String name, String desc) { + Fiel x = new Fiel(clas, name, desc); + if (af!=null) af.add(x); + return x; + } + Fiel f(Clas clas, Fiel fiel) { + Fiel x = new Fiel(clas, fiel.name, fiel.desc); + if (af!=null) af.add(x); + return x; + } + Meth m(Clas clas, String name, String desc) { + Meth x = new Meth(clas, name, desc); + if (am!=null) am.add(x); + return x; + } + Meth m(Clas clas, Meth meth) { + Meth x = new Meth(clas, meth.name, meth.desc); + if (am!=null) am.add(x); + return x; + } + + public void setNames() { + } +} diff --git a/java/shadersmodcore/transform/NamerSrg.java b/java/shadersmodcore/transform/NamerSrg.java new file mode 100644 index 000000000..db2da825d --- /dev/null +++ b/java/shadersmodcore/transform/NamerSrg.java @@ -0,0 +1,205 @@ +package shadersmodcore.transform; + +import static shadersmodcore.transform.Names.*; + +public class NamerSrg extends Namer { + + public void setNames() { + setNamesSrg(); + } + public void setNamesSrg() { + block_ = c("net/minecraft/block/Block"); + blockFlowerPot_ = c("net/minecraft/block/BlockFlowerPot"); + minecraft_ = c("net/minecraft/client/Minecraft"); + guiButton_ = c("net/minecraft/client/gui/GuiButton"); + guiOptions_ = c("net/minecraft/client/gui/GuiOptions"); + guiScreen_ = c("net/minecraft/client/gui/GuiScreen"); + modelRenderer_ = c("net/minecraft/client/model/ModelRenderer"); + worldClient_ = c("net/minecraft/client/multiplayer/WorldClient"); + effectRenderer_ = c("net/minecraft/client/particle/EffectRenderer"); + entityRenderer_ = c("net/minecraft/client/renderer/EntityRenderer"); + glAllocation_ = c("net/minecraft/client/renderer/GLAllocation"); + itemRenderer_ = c("net/minecraft/client/renderer/ItemRenderer"); + openGlHelper_ = c("net/minecraft/client/renderer/OpenGlHelper"); + renderBlocks_ = c("net/minecraft/client/renderer/RenderBlocks"); + renderGlobal_ = c("net/minecraft/client/renderer/RenderGlobal"); + tessellator_ = c("net/minecraft/client/renderer/Tessellator"); + worldRenderer_ = c("net/minecraft/client/renderer/WorldRenderer"); + frustrum_ = c("net/minecraft/client/renderer/culling/Frustrum"); + iCamera_ = c("net/minecraft/client/renderer/culling/ICamera"); + render_ = c("net/minecraft/client/renderer/entity/Render"); + renderDragon_ = c("net/minecraft/client/renderer/entity/RenderDragon"); + renderEnderman_ = c("net/minecraft/client/renderer/entity/RenderEnderman"); + renderSpider_ = c("net/minecraft/client/renderer/entity/RenderSpider"); + renderManager_ = c("net/minecraft/client/renderer/entity/RenderManager"); + rendererLivingE_ = c("net/minecraft/client/renderer/entity/RendererLivingEntity"); + abstractTexture_ = c("net/minecraft/client/renderer/texture/AbstractTexture"); + dynamicTexture_ = c("net/minecraft/client/renderer/texture/DynamicTexture"); + iTextureObject_ = c("net/minecraft/client/renderer/texture/ITextureObject"); + layeredTexture_ = c("net/minecraft/client/renderer/texture/LayeredTexture"); + simpleTexture_ = c("net/minecraft/client/renderer/texture/SimpleTexture"); + stitcher_ = c("net/minecraft/client/renderer/texture/Stitcher"); + textureAtlasSpri_ = c("net/minecraft/client/renderer/texture/TextureAtlasSprite"); + textureClock_ = c("net/minecraft/client/renderer/texture/TextureClock"); + textureCompass_ = c("net/minecraft/client/renderer/texture/TextureCompass"); + textureManager_ = c("net/minecraft/client/renderer/texture/TextureManager"); + textureMap_ = c("net/minecraft/client/renderer/texture/TextureMap"); + textureUtil_ = c("net/minecraft/client/renderer/texture/TextureUtil"); + textureDownload_ = c("net/minecraft/client/renderer/ThreadDownloadImageData"); + iResource_ = c("net/minecraft/client/resources/IResource"); + iResourceManager_ = c("net/minecraft/client/resources/IResourceManager"); + gameSettings_ = c("net/minecraft/client/settings/GameSettings"); + tessVertexState_ = c("net/minecraft/client/shader/TesselatorVertexState"); + entity_ = c("net/minecraft/entity/Entity"); + entityLivingBase_ = c("net/minecraft/entity/EntityLivingBase"); + entityDragon_ = c("net/minecraft/entity/boss/EntityDragon"); + entityEnderman_ = c("net/minecraft/entity/monster/EntityEnderman"); + entitySpider_ = c("net/minecraft/entity/monster/EntitySpider"); + entityPlayer_ = c("net/minecraft/entity/player/EntityPlayer"); + item_ = c("net/minecraft/item/Item"); + itemBlock_ = c("net/minecraft/item/ItemBlock"); + itemStack_ = c("net/minecraft/item/ItemStack"); + movingObjectPos_ = c("net/minecraft/util/MovingObjectPosition"); + resourceLocation_ = c("net/minecraft/util/ResourceLocation"); + vec3_ = c("net/minecraft/util/Vec3"); + iBlockAccess_ = c("net/minecraft/world/IBlockAccess"); + world_ = c("net/minecraft/world/World"); + + entityLivingBase_deathTime = f(entityLivingBase_,"field_70725_aQ","I"); + entityLivingBase_hurtTime = f(entityLivingBase_,"field_70737_aN","I"); + entityRenderer_cameraZoom = f(entityRenderer_ ,"field_78503_V" ,"D"); + entityRenderer_mc = f(entityRenderer_ ,"field_78531_r" ,minecraft_.desc); + gameSettings_renderDistance = f(gameSettings_ ,"field_151451_c","I"); + guiButton_id = f(guiButton_ ,"field_146127_k","I"); + guiScreen_buttonList = f(guiScreen_ ,"field_146292_n","Ljava/util/List;"); + guiScreen_width = f(guiScreen_ ,"field_146294_l","I"); + guiScreen_height = f(guiScreen_ ,"field_146295_m","I"); + guiScreen_mc = f(guiScreen_ ,"field_146297_k",minecraft_.desc); + guiOptions_options = f(guiOptions_ ,"field_146443_h",gameSettings_.desc); + itemBlock_block = f(itemBlock_ ,"field_150939_a",block_.desc); + itemRenderer_itemToRender = f(itemRenderer_ ,"field_78453_b",itemStack_.desc); + layeredTexture_layeredTextureNames = f(layeredTexture_,"field_110567_b","Ljava/util/List;"); + minecraft_renderGlobal = f(minecraft_ ,"field_71438_f" ,renderGlobal_.desc); + minecraft_gameSettings = f(minecraft_ ,"field_71474_y" ,gameSettings_.desc); + modelRenderer_displayList = f(modelRenderer_ ,"field_78811_r" ,"I"); + modelRenderer_compiled = f(modelRenderer_ ,"field_78812_q" ,"Z"); + renderGlobal_glSkyList = f(renderGlobal_ ,"field_72771_w" ,"I"); + renderGlobal_worldRenderers = f(renderGlobal_ ,"field_72765_l" ,"["+worldRenderer_.desc); + rendererLivingE_mainModel = f(rendererLivingE_ ,"field_77045_g" ,null); + rendererLivingE_renderPassModel = f(rendererLivingE_,"field_77046_h",null); + renderManager_entityRenderMap = f(renderManager_ ,"field_78729_o" ,"Ljava/util/Map;"); + renderManager_instance = f(renderManager_ ,"field_78727_a" ,renderManager_.desc); + simpleTexture_textureLocation = f(simpleTexture_ ,"field_110568_b",resourceLocation_.desc); + tessellator_floatBuffer = f(tessellator_ ,"field_147566_d","Ljava/nio/FloatBuffer;"); + tessellator_shortBuffer = f(tessellator_ ,"field_147567_e","Ljava/nio/ShortBuffer;"); + tessellator_intBuffer = f(tessellator_ ,"field_147568_c","Ljava/nio/IntBuffer;"); + tessellator_byteBuffer = f(tessellator_ ,"field_78394_d" ,"Ljava/nio/ByteBuffer;"); + tessellator_rawBuffer = f(tessellator_ ,"field_78405_h" ,"[I"); + tessellator_vertexCount = f(tessellator_ ,"field_78406_i" ,"I"); + tessellator_hasNormals = f(tessellator_ ,"field_78413_q" ,"Z"); + textureAtlasSpri_width = f(textureAtlasSpri_,"field_130223_c",null); + textureAtlasSpri_height = f(textureAtlasSpri_,"field_130224_d",null); + textureAtlasSpri_border = f(textureAtlasSpri_,"field_147966_k",null); + textureMap_anisotropic = f(textureMap_ ,"field_147637_k",null); + textureDownload_textureUploaded = f(textureDownload_,"field_110559_g","Z"); + vec3_xCoord = f(vec3_ ,"field_72450_a" ,"D"); + + abstractTexture_deleteGlTexture = m(abstractTexture_,"func_147631_c","()V"); + block_getAoLight = m(block_ ,"func_149685_I","()F"); + block_getBlockFromItem = m(block_ ,"func_149634_a","("+item_.desc+")"+block_.desc); + dynamicTexture_updateDynamicTexture= m(dynamicTexture_ ,"func_110564_a","()V"); + effectRenderer_renderLitParticles = m(effectRenderer_ ,"func_78872_b" ,"("+entity_.desc+"F)V"); + effectRenderer_renderParticles = m(effectRenderer_ ,"func_78874_a" ,"("+entity_.desc+"F)V"); + entity_getBrightness = m(entity_ ,"func_70013_c" ,"(F)F"); + entityRenderer_enableLightmap = m(entityRenderer_ ,"func_78463_b" ,"(D)V"); + entityRenderer_updateFogColor = m(entityRenderer_ ,"func_78466_h" ,"(F)V"); + entityRenderer_setupFog = m(entityRenderer_ ,"func_78468_a" ,"(IF)V"); + entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"func_78469_a" ,"(FFFF)Ljava/nio/FloatBuffer;"); + entityRenderer_renderWorld = m(entityRenderer_ ,"func_78471_a" ,"(FJ)V"); + entityRenderer_renderRainSnow = m(entityRenderer_ ,"func_78474_d" ,"(F)V"); + entityRenderer_renderHand = m(entityRenderer_ ,"func_78476_b" ,"(FI)V"); + entityRenderer_setupCameraTransform= m(entityRenderer_ ,"func_78479_a" ,"(FI)V"); + entityRenderer_disableLightmap = m(entityRenderer_ ,"func_78483_a" ,"(D)V"); + entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"func_82829_a" ,"("+renderGlobal_.desc+"F)V"); + gameSettings_saveOptions = m(gameSettings_ ,"func_74303_b" ,"()V"); + gameSettings_shouldRenderClouds = m(gameSettings_ ,"func_74309_c" ,"()Z"); + glAllocation_createDirectByteBuffer= m(glAllocation_ ,"func_74524_c" ,"(I)Ljava/nio/ByteBuffer;"); + glAllocation_createDirectIntBuffer = m(glAllocation_ ,"func_74527_f" ,"(I)Ljava/nio/IntBuffer;"); + glAllocation_deleteDisplayLists = m(glAllocation_ ,"func_74523_b" ,"(I)V"); + guiOptions_actionPerformed = m(guiOptions_ ,"func_146284_a","("+guiButton_.desc+")V"); + guiOptions_initGui = m(guiOptions_ ,"func_73866_w_","()V"); + iCamera_setPosition = m(iCamera_ ,"func_78547_a" ,"(DDD)V"); + iResourceManager_getResource = m(iResourceManager_,"func_110536_a","("+resourceLocation_.desc+")"+iResource_.desc); + itemRenderer_renderItem = m(itemRenderer_ ,"func_78443_a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); + itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"func_78440_a" ,"(F)V"); + itemRenderer_renderOverlays = m(itemRenderer_ ,"func_78447_b" ,"(F)V"); + itemRenderer_updateEquipped = m(itemRenderer_ ,"func_78441_a" ,"()V"); + iTextureObject_loadTexture = m(iTextureObject_ ,"func_110551_a","("+iResourceManager_.desc+")V"); + iTextureObject_getGlTextureId = m(iTextureObject_ ,"func_110552_b","()I"); + minecraft_displayGuiScreen = m(minecraft_ ,"func_147108_a","("+guiScreen_.desc+")V"); + minecraft_startGame = m(minecraft_ ,"func_71384_a" ,"()V"); + openGlHelper_setActiveTexture = m(openGlHelper_ ,"func_77473_a" ,"(I)V"); + render_renderShadow = m(render_ ,"func_76975_c" ,"("+entity_.desc+"DDDFF)V"); + renderBlocks_renderBlockFluids = m(renderBlocks_ ,"func_147721_p","("+block_.desc+"III)Z"); + renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"func_147736_d","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockSandFalling= m(renderBlocks_ ,"func_147749_a","("+block_.desc+world_.desc+"IIII)V"); + renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"func_147751_a","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"func_147754_e","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockDoor = m(renderBlocks_ ,"func_147760_u","("+block_.desc+"III)Z"); + renderBlocks_renderBlockBed = m(renderBlocks_ ,"func_147773_v","("+block_.desc+"III)Z"); + renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"func_147805_b","("+block_.desc+"III)Z"); + renderBlocks_renderBlockFlowerPot = m(renderBlocks_ ,"func_147752_a","("+blockFlowerPot_.desc+"III)Z"); + renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"func_147808_b","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderPistonExtension = m(renderBlocks_ ,"func_147809_c","("+block_.desc+"IIIZ)Z"); + renderDragon_shouldRenderPass = m(renderDragon_ ,"func_77032_a" , "("+entityDragon_.desc+"IF)I"); + renderEnderman_shouldRenderPass = m(renderEnderman_ ,"func_77032_a" , "("+entityEnderman_.desc+"IF)I"); + renderSpider_shouldRenderPass = m(renderSpider_ ,"func_77032_a" , "("+entitySpider_.desc+"IF)I"); + rendererLivingE_doRender = m(rendererLivingE_,"func_76986_a" ,"("+entityLivingBase_.desc+"DDDFF)V"); + rendererLivingE_renderEquippedItems= m(rendererLivingE_,"func_77029_c" ,"("+entityLivingBase_.desc+"F)V"); + rendererLivingE_getColorMultiplier = m(rendererLivingE_,"func_77030_a" ,"("+entityLivingBase_.desc+"FF)I"); + rendererLivingE_renderLabel = m(rendererLivingE_,"func_96449_a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); + renderGlobal_renderEntities = m(renderGlobal_ ,"func_147589_a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); + renderGlobal_renderSky = m(renderGlobal_ ,"func_72714_a" ,"(F)V"); + renderGlobal_drawBlockDamageTexture= m(renderGlobal_ ,"func_72717_a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); + renderGlobal_renderClouds = m(renderGlobal_ ,"func_72718_b" ,"(F)V"); + renderGlobal_sortAndRender = m(renderGlobal_ ,"func_72719_a" ,"("+entityLivingBase_.desc+"ID)I"); + renderGlobal_clipRenderersByFrustum= m(renderGlobal_ ,"func_72729_a" ,"("+iCamera_.desc+"F)V"); + renderGlobal_drawSelectionBox = m(renderGlobal_ ,"func_72731_b" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); + renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"func_72733_a" ,"(ID)V"); + stitcher_getCurrentWidth = m(stitcher_ ,"func_110935_a","()I"); + tessellator_sortQuad = m(tessellator_ ,"func_147564_a","(FFF)"+tessVertexState_.desc); + tessellator_addTranslation = m(tessellator_ ,"func_78372_c" ,"(FFF)V"); + tessellator_setNormal = m(tessellator_ ,"func_78375_b" ,"(FFF)V"); + tessellator_addVertex = m(tessellator_ ,"func_78377_a" ,"(DDD)V"); + tessellator_reset = m(tessellator_ ,"func_78379_d" ,"()V"); + tessellator_draw = m(tessellator_ ,"func_78381_a" ,"()I"); + textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"func_130100_a","("+iResource_.desc+")V"); + textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"func_147965_a","(I)[[I"); + textureAtlasSpri_getIconName = m(textureAtlasSpri_,"func_94215_i","()Ljava/lang/String;"); + textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"func_94219_l","()V"); + textureCompass_updateCompass = m(textureCompass_ ,"func_94241_a" ,"("+world_.desc+"DDDZZ)V"); + textureManager_onResourceManagerReload = m(textureManager_,"func_110549_a","("+iResourceManager_.desc+")V"); + textureManager_bindTexture = m(textureManager_ ,"func_110577_a","("+resourceLocation_.desc+")V"); + textureMap_loadTextureAtlas = m(textureMap_ ,"func_110571_b","("+iResourceManager_.desc+")V"); + textureMap_getIconResLoc = m(textureMap_ ,"func_147634_a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); + textureMap_updateAnimations = m(textureMap_ ,"func_94248_c" ,"()V"); + textureUtil_uploadTexture = m(textureUtil_ ,"func_110988_a","(I[III)V"); + textureUtil_uploadTextureImageAllocate = m(textureUtil_,"func_110989_a","(ILjava/awt/image/BufferedImage;ZZ)I"); + textureUtil_allocateTexture = m(textureUtil_ ,"func_110991_a","(III)V"); + textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"func_147946_a","(IIIIF)V"); + textureUtil_uploadTexSub = m(textureUtil_ ,"func_147955_a","([[IIIIIZZ)V"); + textureUtil_bindTexture = m(textureUtil_ ,"func_94277_a" ,"(I)V"); + world_getCelestialAngle = m(world_ ,"func_72826_c" ,"(F)F"); + world_getRainStrength = m(world_ ,"func_72867_j" ,"(F)F"); + modelRenderer_render = m(modelRenderer_ ,"func_78785_a" ,"(F)V"); + modelRenderer_renderWithRotation = m(modelRenderer_ ,"func_78791_b" ,"(F)V"); + + guiOptions_buttonList = f(guiOptions_,guiScreen_buttonList); + guiOptions_width = f(guiOptions_,guiScreen_width); + guiOptions_height = f(guiOptions_,guiScreen_height); + guiOptions_mc = f(guiOptions_,guiScreen_mc); + frustrum_setPosition = m(frustrum_,iCamera_setPosition); + worldClient_getCelestialAngle = m(worldClient_,world_getCelestialAngle); + worldClient_getRainStrength = m(worldClient_,world_getRainStrength); + } +} diff --git a/java/shadersmodcore/transform/Names.java b/java/shadersmodcore/transform/Names.java new file mode 100644 index 000000000..7efc50281 --- /dev/null +++ b/java/shadersmodcore/transform/Names.java @@ -0,0 +1,256 @@ +package shadersmodcore.transform; + +public class Names { + + public static class Name { + String clas; + String name; + String desc; + public Name(String clas, String name, String desc) { + this.clas = clas; + this.name = name; + this.desc = desc; + } + public Name set(String clas, String name, String desc) { + this.clas = clas; + this.name = name; + this.desc = desc; + return this; + } + public boolean equals(String clas, String name, String desc) { + return this.clas.equals(clas) && this.name.equals(name) && this.desc.equals(desc); + } + } + + public static class Type extends Name { + public Type(String desc) { + super("","",desc); + } + public Type(String name, String desc) { + super(name,name,desc); + } + } + public static class Clas extends Type { + public Clas(String name) { + super(name,"L"+name+";"); + } + public boolean equals(String clas) { + return this.clas.equals(clas); + } + } + public static class Fiel extends Name { + public Fiel(Clas clas, String name, String desc) { + super(clas.clas,name,desc); + } + public boolean equals(String clas, String name) { + return this.clas.equals(clas) && this.name.equals(name); + } + } + public static class Meth extends Name { + public Meth(Clas clas, String name, String desc) { + super(clas.clas,name,desc); + } + public boolean equalsNameDesc(String name, String desc) { + return this.name.equals(name) && this.desc.equals(desc); + } + } + + static Clas block_; + static Clas blockFlowerPot_; + static Clas minecraft_; + static Clas guiButton_; + static Clas guiOptions_; + static Clas guiScreen_; + static Clas modelRenderer_; + static Clas worldClient_; + static Clas effectRenderer_; + static Clas entityRenderer_; + static Clas glAllocation_; + static Clas itemRenderer_; + static Clas openGlHelper_; + static Clas renderBlocks_; + static Clas renderGlobal_; + static Clas tessellator_; + static Clas worldRenderer_; + static Clas frustrum_; + static Clas iCamera_; + static Clas render_; + static Clas renderDragon_; + static Clas renderEnderman_; + static Clas renderSpider_; + static Clas renderManager_; + static Clas rendererLivingE_; + static Clas abstractTexture_; + static Clas dynamicTexture_; + static Clas iTextureObject_; + static Clas layeredTexture_; + static Clas simpleTexture_; + static Clas stitcher_; + static Clas textureAtlasSpri_; + static Clas textureClock_; + static Clas textureCompass_; + static Clas textureManager_; + static Clas textureMap_; + static Clas textureUtil_; + static Clas textureDownload_; + static Clas iResource_; + static Clas iResourceManager_; + static Clas gameSettings_; + static Clas tessVertexState_; + static Clas entity_; + static Clas entityLivingBase_; + static Clas entityDragon_; + static Clas entityEnderman_; + static Clas entitySpider_; + static Clas entityPlayer_; + static Clas item_; + static Clas itemBlock_; + static Clas itemStack_; + static Clas movingObjectPos_; + static Clas resourceLocation_; + static Clas vec3_; + static Clas iBlockAccess_; + static Clas world_; + + static Fiel entityLivingBase_deathTime; + static Fiel entityLivingBase_hurtTime; + static Fiel entityRenderer_cameraZoom; + static Fiel entityRenderer_mc; + static Fiel gameSettings_renderDistance; + static Fiel guiButton_id; + static Fiel guiScreen_buttonList; + static Fiel guiScreen_width; + static Fiel guiScreen_height; + static Fiel guiScreen_mc; + static Fiel guiOptions_options; + static Fiel itemBlock_block; + static Fiel itemRenderer_itemToRender; + static Fiel layeredTexture_layeredTextureNames; + static Fiel minecraft_renderGlobal; + static Fiel minecraft_gameSettings; + static Fiel modelRenderer_displayList; + static Fiel modelRenderer_compiled; + static Fiel renderGlobal_glSkyList; + static Fiel renderGlobal_worldRenderers; + static Fiel rendererLivingE_mainModel; + static Fiel rendererLivingE_renderPassModel; + static Fiel renderManager_entityRenderMap; + static Fiel renderManager_instance; + static Fiel simpleTexture_textureLocation; + static Fiel tessellator_floatBuffer; + static Fiel tessellator_shortBuffer; + static Fiel tessellator_intBuffer; + static Fiel tessellator_byteBuffer; + static Fiel tessellator_rawBuffer; + static Fiel tessellator_vertexCount; + static Fiel tessellator_hasNormals; + static Fiel textureAtlasSpri_width; + static Fiel textureAtlasSpri_height; + static Fiel textureAtlasSpri_border; + static Fiel textureMap_anisotropic; + static Fiel textureDownload_textureUploaded; + static Fiel vec3_xCoord; + + static Fiel guiOptions_buttonList; + static Fiel guiOptions_width; + static Fiel guiOptions_height; + static Fiel guiOptions_mc; + + static Meth abstractTexture_deleteGlTexture; + static Meth block_getAoLight; + static Meth block_getBlockFromItem; + static Meth dynamicTexture_updateDynamicTexture; + static Meth effectRenderer_renderLitParticles; + static Meth effectRenderer_renderParticles; + static Meth entity_getBrightness; + static Meth entityRenderer_enableLightmap; + static Meth entityRenderer_updateFogColor; + static Meth entityRenderer_setupFog; + static Meth entityRenderer_setFogColorBuffer; + static Meth entityRenderer_renderWorld; + static Meth entityRenderer_renderRainSnow; + static Meth entityRenderer_renderHand; + static Meth entityRenderer_setupCameraTransform; + static Meth entityRenderer_disableLightmap; + static Meth entityRenderer_renderCloudsCheck; + static Meth gameSettings_saveOptions; + static Meth gameSettings_shouldRenderClouds; + static Meth glAllocation_createDirectByteBuffer; + static Meth glAllocation_createDirectIntBuffer; + static Meth glAllocation_deleteDisplayLists; + static Meth guiOptions_actionPerformed; + static Meth guiOptions_initGui; + static Meth iCamera_setPosition; + static Meth iResourceManager_getResource; + static Meth itemRenderer_renderItem; + static Meth itemRenderer_renderItemInFirstPerson; + static Meth itemRenderer_renderOverlays; + static Meth itemRenderer_updateEquipped; + static Meth iTextureObject_loadTexture; + static Meth iTextureObject_getGlTextureId; + static Meth minecraft_displayGuiScreen; + static Meth minecraft_startGame; + static Meth openGlHelper_setActiveTexture; + static Meth render_renderShadow; + static Meth renderBlocks_renderBlockFluids; + static Meth renderBlocks_renderStdBlockWithCM; + static Meth renderBlocks_renderBlockSandFalling; + static Meth renderBlocks_renderStdBlockWithAO; + static Meth renderBlocks_renderBlockCactusImpl; + static Meth renderBlocks_renderBlockDoor; + static Meth renderBlocks_renderBlockBed; + static Meth renderBlocks_renderBlockByRenderType; + static Meth renderBlocks_renderBlockFlowerPot; + static Meth renderBlocks_renderStdBlockWithAOP; + static Meth renderBlocks_renderPistonExtension; + static Meth renderDragon_shouldRenderPass; + static Meth renderEnderman_shouldRenderPass; + static Meth renderSpider_shouldRenderPass; + static Meth rendererLivingE_doRender; + static Meth rendererLivingE_renderEquippedItems; + static Meth rendererLivingE_getColorMultiplier; + static Meth rendererLivingE_renderLabel; + static Meth renderGlobal_renderEntities; + static Meth renderGlobal_renderSky; + static Meth renderGlobal_drawBlockDamageTexture; + static Meth renderGlobal_renderClouds; + static Meth renderGlobal_sortAndRender; + static Meth renderGlobal_clipRenderersByFrustum; + static Meth renderGlobal_drawSelectionBox; + static Meth renderGlobal_renderAllRenderLists; + static Meth stitcher_getCurrentWidth; + static Meth tessellator_sortQuad; + static Meth tessellator_addTranslation; + static Meth tessellator_setNormal; + static Meth tessellator_addVertex; + static Meth tessellator_reset; + static Meth tessellator_draw; + static Meth textureAtlasSpri_loadSprite; + static Meth textureAtlasSpri_getFrameTextureData; + static Meth textureAtlasSpri_getIconName; + static Meth textureAtlasSpri_updateAnimation; + static Meth textureCompass_updateCompass; + static Meth textureManager_onResourceManagerReload; + static Meth textureManager_bindTexture; + static Meth textureMap_loadTextureAtlas; + static Meth textureMap_getIconResLoc; + static Meth textureMap_updateAnimations; + static Meth textureUtil_uploadTexture; + static Meth textureUtil_uploadTextureImageAllocate; + static Meth textureUtil_allocateTexture; + static Meth textureUtil_allocateTextureMipmapAniso; + static Meth textureUtil_uploadTexSub; + static Meth textureUtil_bindTexture; + static Meth world_getCelestialAngle; + static Meth world_getRainStrength; + static Meth modelRenderer_render; + static Meth modelRenderer_renderWithRotation; + + static Meth frustrum_setPosition; + static Meth worldClient_getCelestialAngle; + static Meth worldClient_getRainStrength; + + public static boolean equals(String clas1, String name1, String desc1, String clas2, String name2, String desc2) { + return clas1.equals(clas2) && name1.equals(name2) && desc1.equals(desc2); + } +} diff --git a/java/shadersmodcore/transform/SMCCTBlock.java b/java/shadersmodcore/transform/SMCCTBlock.java new file mode 100644 index 000000000..a692df7ce --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTBlock.java @@ -0,0 +1,76 @@ +package shadersmodcore.transform; + +import static org.objectweb.asm.Opcodes.*; +import net.minecraft.launchwrapper.IClassTransformer; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTBlock implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, 0); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + this.classname = name; + //SMCLog.info(" class %s",name); + super.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + if (Names.block_getAoLight.equalsNameDesc(name, desc)) + { + //SMCLog.info(" patching"); + return new MVgetAoLight(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVgetAoLight extends MethodVisitor + { + public MVgetAoLight(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof Float) + { + if (((Float)cst).floatValue() == 0.2f) + { + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "blockAoLight", "F"); + SMCLog.info(" blockAoLight"); + return; + } + } + mv.visitLdcInsn(cst); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTEntityRenderer.java b/java/shadersmodcore/transform/SMCCTEntityRenderer.java new file mode 100644 index 000000000..2b7be80ba --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTEntityRenderer.java @@ -0,0 +1,636 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; +import org.objectweb.asm.util.Textifier; +import org.objectweb.asm.util.TraceMethodVisitor; + + +import net.minecraft.launchwrapper.IClassTransformer; +import shadersmodcore.transform.SMCLog; + +/** transformer for net.minecraft.client.renderer.EntityRenderer */ +public class SMCCTEntityRenderer implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + if (Names.entityRenderer_disableLightmap.equalsNameDesc(name,desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVdisableLightmap(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.entityRenderer_enableLightmap.equalsNameDesc(name,desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVenableLightmap(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.entityRenderer_updateFogColor.equalsNameDesc(name,desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVupdateFogColor(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.entityRenderer_setFogColorBuffer.equalsNameDesc(name,desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVsetFogColorBuffer(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.entityRenderer_setupFog.equalsNameDesc(name,desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVsetupFog(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.entityRenderer_renderCloudsCheck.equalsNameDesc(name,desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVrenderCloudsCheck(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.entityRenderer_renderHand.equalsNameDesc(name,desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + return new MVrenderHand(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.entityRenderer_renderWorld.equalsNameDesc(name,desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVrenderWorld( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVdisableLightmap extends MethodVisitor + { + public MVdisableLightmap(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + @Override + public void visitInsn(int opcode) { + if (opcode==RETURN) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableLightmap", "()V"); + } + mv.visitInsn(opcode); + } + } + + private static class MVenableLightmap extends MethodVisitor + { + public MVenableLightmap(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + @Override + public void visitInsn(int opcode) { + if (opcode==RETURN) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableLightmap", "()V"); + } + mv.visitInsn(opcode); + } + } + + private static class MVupdateFogColor extends MethodVisitor + { + public MVupdateFogColor(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.equals("org/lwjgl/opengl/GL11","glClearColor","(FFFF)V",owner,name,desc)) + { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setClearColor", "(FFFF)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVsetFogColorBuffer extends MethodVisitor + { + public MVsetFogColorBuffer(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(FLOAD, 1); + mv.visitVarInsn(FLOAD, 2); + mv.visitVarInsn(FLOAD, 3); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setFogColor", "(FFF)V"); + } + } + + private static class MVsetupFog extends MethodVisitor + { + public MVsetupFog(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.equals("org/lwjgl/opengl/GL11","glFogi","(II)V",owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "sglFogi", "(II)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVrenderCloudsCheck extends MethodVisitor + { + public MVrenderCloudsCheck(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.gameSettings_shouldRenderClouds.equals(owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "shouldRenderClouds", "("+Names.gameSettings_.desc+")Z"); + return; + } else + if (Names.renderGlobal_renderClouds.equals(owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginClouds", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endClouds", "()V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVrenderHand extends MethodVisitor + { + Label la1, la2; + public MVrenderHand(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + la1 = new Label(); + la2 = new Label(); + } + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.equals("org/lwjgl/util/glu/Project","gluPerspective","(FFFF)V",owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "applyHandDepth", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } else + if (Names.equals("org/lwjgl/opengl/GL11","glPushMatrix","()V",owner,name,desc)) { + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isHandRendered", "Z"); + mv.visitJumpInsn(IFNE, la1); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } else + if (Names.equals("org/lwjgl/opengl/GL11","glPopMatrix","()V",owner,name,desc)) { + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitLabel(la1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isCompositeRendered", "Z"); + mv.visitJumpInsn(IFNE, la2); + mv.visitInsn(RETURN); + mv.visitLabel(la2); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 1); + mv.visitInsn(F2D); + mv.visitMethodInsn(INVOKEVIRTUAL, Names.entityRenderer_disableLightmap.clas, Names.entityRenderer_disableLightmap.name, Names.entityRenderer_disableLightmap.desc); + return; + } else if (Names.itemRenderer_renderItemInFirstPerson.equals(owner, name, desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "renderItemFP", "("+Names.itemRenderer_.desc+"F)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVrenderWorld extends MethodVisitor + { + public MVrenderWorld(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + private static final int stateEnd = 32; + int state = 0; + String section = ""; + Label labelAfterUpdate = null; + Label labelEndUpdate = null; + Label labelNoSky = null; + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.entityRenderer_mc.clas, Names.entityRenderer_mc.name, Names.entityRenderer_mc.desc); + mv.visitVarInsn(FLOAD, 1); + mv.visitVarInsn(LLOAD, 2); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginRender", "("+Names.minecraft_.desc+"FJ)V"); + } + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof String) { + String scst = (String)cst; + //SMCLog.finest(" %d Ldc %s", state, scst); + section = scst; + } + mv.visitLdcInsn(cst); + } + @Override + public void visitIntInsn(int opcode, int operand) { + //SMCLog.finest(" %d Int %d %d", state ,opcode, operand); + //switch (state) { + //case 23: + //case 25: + // if (opcode == SIPUSH && operand == 256) { + // state = 26; + // mv.visitInsn(ICONST_0); + // return; + // } + // break; + //} + mv.visitIntInsn(opcode, operand); + } + @Override + public void visitJumpInsn(int opcode, Label label) { + //SMCLog.finest(" %d, Jump %d", state, opcode); + switch (state) { + case 4: + if (opcode==IF_ICMPLT) { + ++state; + mv.visitInsn(POP2); + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isShadowPass", "Z"); + mv.visitJumpInsn(IFNE, label); + return; + } + break; + case 10: + if (opcode==IFNE) { + ++state; + labelAfterUpdate = label; + labelEndUpdate = new Label(); + mv.visitJumpInsn(opcode, label); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginUpdateChunks", "()V"); + return; + } + break; + case 11: + if (label==labelAfterUpdate) { + mv.visitJumpInsn(opcode, labelEndUpdate); + return; + } + break; + case 28: + if (opcode==IFNE) { + ++state; + mv.visitJumpInsn(opcode, label); + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isShadowPass", "Z"); + mv.visitJumpInsn(IFNE, label); +// mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "readCenterDepth", "()V"); +// mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginHand", "()V"); +// mv.visitVarInsn(ALOAD, 0); +// mv.visitVarInsn(FLOAD, 1); +// mv.visitVarInsn(ILOAD, 13); +// mv.visitMethodInsn(INVOKESPECIAL, Names.EntityRenderer_, Names.EntityRenderer_renderHand, Names.EntityRenderer_renderHand_desc); +// mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endHand", "()V"); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 1); + mv.visitVarInsn(ILOAD, 13); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "renderHand1", "("+Names.entityRenderer_.desc+"FI)V"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "renderCompositeFinal", "()V"); + return; + } + break; + } + mv.visitJumpInsn(opcode, label); + } + @Override + public void visitLabel(Label label) { + switch (state) { + case 11: + if (label==labelAfterUpdate) { + ++state; + mv.visitLabel(labelEndUpdate); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endUpdateChunks", "()V"); + mv.visitLabel(label); + labelAfterUpdate = labelEndUpdate = null; + return; + } + } + mv.visitLabel(label); + } + @Override + public void visitFrame(int type, int nLocal, Object[] local, + int nStack, Object[] stack) { + //SMCLog.finest(" %d, Frame",state); + switch (state) { + case 7: + { + state = 8; + mv.visitLabel(labelNoSky); labelNoSky = null; + mv.visitFrame(type, nLocal, local, nStack, stack); + return; + } + + case 31: + { + ++state; + mv.visitFrame(type, nLocal, local, nStack, stack); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endRender", "()V"); + return; + } + } + mv.visitFrame(type, nLocal, local, nStack, stack); + } + @Override + public void visitFieldInsn(int opcode, String owner, String name, + String desc) { + //SMCLog.finest(" %d F %d %s.%s %s", state, opcode, ownerM, nameM, descM); + switch (state) { + case 3: + if (Names.gameSettings_renderDistance.equals(owner,name)) { + ++state; + } + break; + case 24: + case 26: + if (Names.entityRenderer_cameraZoom.equals(owner,name)) { + state = 28; + mv.visitFieldInsn(opcode, owner, name, desc); + return; + } + break; + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + @Override + public void visitVarInsn(int opcode, int var) { + switch (state) + { + case 29: + if (opcode==ALOAD) { + ++state; + mv.visitVarInsn(opcode, var); + return; + } + break; + } + mv.visitVarInsn(opcode, var); + } + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + //SMCLog.finest(" %d M %d %s.%s%s", state, opcode, ownerM, nameM, descM); + switch (state) + { + case 0: + if (Names.equals("org/lwjgl/opengl/GL11","glViewport","(IIII)V",owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setViewport", "(IIII)V"); + return; + } + break; + case 1: + if (Names.equals("org/lwjgl/opengl/GL11","glClear","(I)V",owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "clearRenderBuffer", "()V"); + return; + } + break; + case 2: + if (Names.entityRenderer_setupCameraTransform.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitVarInsn(FLOAD, 1); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setCamera", "(F)V"); + return; + } + break; + case 3: + if (Names.equals("Config","isSkyEnabled","()Z",owner,name,desc)) { + state = 6; + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isShadowPass", "Z"); + labelNoSky = new Label(); + mv.visitJumpInsn(IFNE, labelNoSky); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case 5: + if (Names.renderGlobal_renderSky.equals(owner,name,desc)) { + state = 8; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginSky", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endSky", "()V"); + return; + } + break; + case 6: + if (Names.renderGlobal_renderSky.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginSky", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endSky", "()V"); + return; + } + break; + case 8: + if (Names.iCamera_setPosition.equals(owner,name,desc) || Names.frustrum_setPosition.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "setFrustrumPosition", "("+Names.frustrum_.desc+"DDD)V"); + return; + } + break; + case 9: + if (Names.renderGlobal_clipRenderersByFrustum.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "clipRenderersByFrustrum", "("+Names.renderGlobal_.desc+Names.frustrum_.desc+"F)V"); + return; + } + break; + case 12: + if (Names.renderGlobal_sortAndRender.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginTerrain", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endTerrain", "()V"); + return; + } + break; + case 13: + if (Names.effectRenderer_renderLitParticles.equals(owner,name,desc)) { + // vanilla or forge. not optfine + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginLitParticles", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } else + if (Names.equals("org/lwjgl/opengl/GL11","glDisable","(I)V",owner,name,desc)) { + // optifine + state = 16; + break; + } + break; + case 14: // vanilla or forge. not optfine + if (Names.effectRenderer_renderParticles.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginParticles", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endParticles", "()V"); + return; + } + break; + case 15: // vanilla or forge. not optfine + if (Names.equals("org/lwjgl/opengl/GL11","glDisable","(I)V",owner,name,desc)) { + ++state; + break; + } + break; + case 16: + if (Names.entityRenderer_renderRainSnow.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginWeather", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endWeather", "()V"); + return; + } + break; + case 17: + if (Names.equals("org/lwjgl/opengl/GL11","glDepthMask","(Z)V",owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 1); + mv.visitVarInsn(ILOAD, 13); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "renderHand0", "("+Names.entityRenderer_.desc+"FI)V"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "preWater", "()V"); + return; + } + case 18: + case 19: + case 20: + if (Names.renderGlobal_sortAndRender.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginWater", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endWater", "()V"); + return; + } else if (Names.equals(Names.renderGlobal_.clas,"renderAllSortedRenderers","(ID)I",owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginWater", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endWater", "()V"); + return; + } + break; + case 21: + if (Names.equals("org/lwjgl/opengl/GL11","glDepthMask","(Z)V",owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case 22: + if (Names.equals("org/lwjgl/opengl/GL11","glDisable","(I)V",owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case 23: + if (Names.equals("org/lwjgl/opengl/GL11","glDisable","(I)V",owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableFog", "()V"); + return; + } + break; + case 24: + if (Names.effectRenderer_renderLitParticles.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginLitParticles", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case 25: + if (Names.effectRenderer_renderParticles.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginParticles", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endParticles", "()V"); + return; + } + break; + case 30: + if (Names.entityRenderer_renderHand.equals(owner,name,desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "renderFPOverlay", "("+Names.entityRenderer_.desc+"FI)V"); + return; + } + break; + } + /* + case : + if (Namer.equals(SMCNames.,SMCNames.,SMCNames._desc,owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case : + if (Namer.equals("","","",owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + */ + mv.visitMethodInsn(opcode, owner, name, desc); + } + @Override + public void visitEnd() { + if (state!=stateEnd) + SMCLog.severe(" state %d expect %d",state,stateEnd); + mv.visitEnd(); + } + } +} diff --git a/java/shadersmodcore/transform/SMCCTGuiOptions.java b/java/shadersmodcore/transform/SMCCTGuiOptions.java new file mode 100644 index 000000000..62717b477 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTGuiOptions.java @@ -0,0 +1,169 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTGuiOptions implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + this.classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.guiOptions_initGui.equalsNameDesc(name, desc)) + { + //SMCLog.info(" patching"); + return new MVinitGui( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + if (Names.guiOptions_actionPerformed.equalsNameDesc(name, desc)) + { + //SMCLog.info(" patching"); + return new MVactionPerformed( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVinitGui extends MethodVisitor + { + int state = 0; + + public MVinitGui(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitInsn(int opcode) { + super.visitInsn(opcode); + if (opcode == Opcodes.POP){ + if (state == 1) { + state = 2; + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.guiOptions_buttonList.clas, Names.guiOptions_buttonList.name, Names.guiOptions_buttonList.desc); + mv.visitTypeInsn(NEW, Names.guiButton_.clas); + mv.visitInsn(DUP); + mv.visitIntInsn(SIPUSH, 190); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.guiOptions_width.clas, Names.guiOptions_width.name, Names.guiOptions_width.desc); + mv.visitInsn(ICONST_2); + mv.visitInsn(IDIV); + mv.visitIntInsn(SIPUSH, 155); + mv.visitInsn(ISUB); + mv.visitIntInsn(BIPUSH, 76); + mv.visitInsn(IADD); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.guiOptions_height.clas, Names.guiOptions_height.name, Names.guiOptions_height.desc); + mv.visitIntInsn(BIPUSH, 6); + mv.visitInsn(IDIV); + mv.visitIntInsn(BIPUSH, 120); + mv.visitInsn(IADD); + mv.visitIntInsn(BIPUSH, 6); + mv.visitInsn(ISUB); + mv.visitIntInsn(BIPUSH, 74); + mv.visitIntInsn(BIPUSH, 20); + mv.visitLdcInsn("Shaders..."); + mv.visitMethodInsn(INVOKESPECIAL, Names.guiButton_.clas, "", "(IIIIILjava/lang/String;)V"); + mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z"); + mv.visitInsn(POP); + SMCLog.finest(" add shaders button"); + } + } + } + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof String) + { + if (((String)cst).equals("options.language")) + { + if (state == 0) { + state = 1; + mv.visitInsn(POP); + mv.visitInsn(POP); + mv.visitIntInsn(BIPUSH, 74); + mv.visitIntInsn(BIPUSH, 20); + SMCLog.finest(" decrease language button size"); + } + } + } + super.visitLdcInsn(cst); + } + + } + + private static class MVactionPerformed extends MethodVisitor + { + public MVactionPerformed(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + super.visitCode(); + mv.visitVarInsn(ALOAD, 1); + mv.visitFieldInsn(GETFIELD, Names.guiButton_id.clas, Names.guiButton_id.name, Names.guiButton_id.desc); + mv.visitIntInsn(SIPUSH, 190); + Label l1 = new Label(); + mv.visitJumpInsn(IF_ICMPNE, l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.guiOptions_mc.clas, Names.guiOptions_mc.name, Names.guiOptions_mc.desc); + mv.visitFieldInsn(GETFIELD, Names.minecraft_gameSettings.clas, Names.minecraft_gameSettings.name, Names.minecraft_gameSettings.desc); + mv.visitMethodInsn(INVOKEVIRTUAL, Names.gameSettings_saveOptions.clas, Names.gameSettings_saveOptions.name, Names.gameSettings_saveOptions.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.guiOptions_mc.clas, Names.guiOptions_mc.name, Names.guiOptions_mc.desc); + mv.visitTypeInsn(NEW, "shadersmodcore/client/GuiShaders"); + mv.visitInsn(DUP); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.guiOptions_options.clas, Names.guiOptions_options.name, Names.guiOptions_options.desc); + mv.visitMethodInsn(INVOKESPECIAL, "shadersmodcore/client/GuiShaders", "", "("+Names.guiScreen_.desc+Names.gameSettings_.desc+")V"); + mv.visitMethodInsn(INVOKEVIRTUAL, Names.minecraft_displayGuiScreen.clas, Names.minecraft_displayGuiScreen.name, Names.minecraft_displayGuiScreen.desc); + mv.visitLabel(l1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + SMCLog.finest(" shaders button action"); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTItemBlock.java b/java/shadersmodcore/transform/SMCCTItemBlock.java new file mode 100644 index 000000000..88d198828 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTItemBlock.java @@ -0,0 +1,50 @@ +package shadersmodcore.transform; + +import static org.objectweb.asm.Opcodes.*; +import net.minecraft.launchwrapper.IClassTransformer; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTItemBlock implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + if (Names.itemBlock_block.name.equals(name)) { + access = access & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + + } +} diff --git a/java/shadersmodcore/transform/SMCCTItemRenderer.java b/java/shadersmodcore/transform/SMCCTItemRenderer.java new file mode 100644 index 000000000..8d0d14551 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTItemRenderer.java @@ -0,0 +1,118 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.lwjgl.opengl.GL11; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTItemRenderer implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + Names.Meth renderItemIrt = new Names.Meth(Names.itemRenderer_,"renderItem","("+Names.entityLivingBase_.desc+Names.itemStack_.desc+"ILnet/minecraftforge/client/IItemRenderer$ItemRenderType;)V"); + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s",classname,name,desc); + if (Names.itemRenderer_updateEquipped.equalsNameDesc(name, desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVupdate(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.itemRenderer_renderItem.equalsNameDesc(name, desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVrenderItem(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (renderItemIrt.equalsNameDesc(name, desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVrenderItem(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVupdate extends MethodVisitor + { + public MVupdate(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, String desc) { + if (opcode==PUTFIELD && Names.itemRenderer_itemToRender.equals(owner, name, desc)) { + mv.visitInsn(DUP); + mv.visitFieldInsn(PUTSTATIC, "shadersmodcore/client/Shaders", "itemToRender", Names.itemStack_.desc); + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + + } + + private static class MVrenderItem extends MethodVisitor + { + public MVrenderItem(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int state = 0; + + @Override + public void visitInsn(int opcode) { + if (state==1) { + if (opcode==ICONST_0) { + ++state; + opcode = ICONST_1; + } + } + mv.visitInsn(opcode); + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (state==0) { + if (opcode==SIPUSH && operand==GL11.GL_BLEND) { + ++state; + } + } + mv.visitIntInsn(opcode, operand); + } + } +} diff --git a/java/shadersmodcore/transform/SMCCTMinecraft.java b/java/shadersmodcore/transform/SMCCTMinecraft.java new file mode 100644 index 000000000..36e77cf63 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTMinecraft.java @@ -0,0 +1,99 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTMinecraft implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + this.classname = name; + //SMCLog.info(" class %s",name); + super.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.minecraft_startGame.equalsNameDesc(name, desc)) + { + //SMCLog.info(" patching"); + return new MVstartGame(super.visitMethod(access, name, desc, signature, exceptions)); + } + return super.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVstartGame extends MethodVisitor + { + int state = 0; + + public MVstartGame(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof String) + { + if (((String)cst).equals("Startup")) + { + if (state == 0) { + state = 1; + } + } + } + super.visitLdcInsn(cst); + } + + @Override + public void visitVarInsn(int opcode, int var) { + if (opcode == Opcodes.ALOAD) { + if (var == 0) { + if (state == 1) { + state = 2; + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "startup", "("+Names.minecraft_.desc+")V"); + //SMCLog.finest(" startup"); + } + } + } + super.visitVarInsn(opcode, var); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTModelRenderer.java b/java/shadersmodcore/transform/SMCCTModelRenderer.java new file mode 100644 index 000000000..3cf15443f --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTModelRenderer.java @@ -0,0 +1,134 @@ +package shadersmodcore.transform; + +import java.util.Iterator; +import java.util.ListIterator; + +import org.lwjgl.opengl.GL12; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.AbstractInsnNode; +import org.objectweb.asm.tree.MethodNode; +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTModelRenderer implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + +// @Override +// public FieldVisitor visitField(int access, String name, String desc, +// String signature, Object value) { +// if (Names.modelRenderer_compiled.name.equals(name) || +// Names.modelRenderer_displayList.name.equals(name)) { +// access = access & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; +// } +// return cv.visitField(access, name, desc, signature, value); +// } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); +// if (Names.modelRenderer_render.equalsNameDesc(name, desc)) +// { +// //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); +// return new MVrender( +// cv.visitMethod(access, name, desc, signature, exceptions)); +// } +// else +// if (Names.modelRenderer_renderWithRotation.equalsNameDesc(name, desc)) +// { +// //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); +// return new MVrender( +// cv.visitMethod(access, name, desc, signature, exceptions)); +// } +// else + if ("resetDisplayList".equals(name) && "()V".equals(desc) + || "getCompiled".equals(name) && "()Z".equals(desc) + || "getDisplayList".equals(name) && "()I".equals(desc) + ) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + { + mv = cv.visitMethod(ACC_PUBLIC, "getCompiled", "()Z", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.modelRenderer_compiled.clas, Names.modelRenderer_compiled.name, Names.modelRenderer_compiled.desc); + mv.visitInsn(IRETURN); + mv.visitMaxs(1, 1); + mv.visitEnd(); + } + { + mv = cv.visitMethod(ACC_PUBLIC, "getDisplayList", "()I", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.modelRenderer_displayList.clas, Names.modelRenderer_displayList.name, Names.modelRenderer_displayList.desc); + mv.visitInsn(IRETURN); + mv.visitMaxs(1, 1); + mv.visitEnd(); + } + { + mv = cv.visitMethod(ACC_PUBLIC, "resetDisplayList", "()V", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.modelRenderer_compiled.clas, Names.modelRenderer_compiled.name, Names.modelRenderer_compiled.desc); + Label l1 = new Label(); + mv.visitJumpInsn(IFEQ, l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.modelRenderer_displayList.clas, Names.modelRenderer_displayList.name, Names.modelRenderer_displayList.desc); + mv.visitMethodInsn(INVOKESTATIC, Names.glAllocation_deleteDisplayLists.clas, Names.glAllocation_deleteDisplayLists.name, Names.glAllocation_deleteDisplayLists.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + mv.visitFieldInsn(PUTFIELD, Names.modelRenderer_displayList.clas, Names.modelRenderer_displayList.name, Names.modelRenderer_displayList.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + mv.visitFieldInsn(PUTFIELD, Names.modelRenderer_compiled.clas, Names.modelRenderer_compiled.name, Names.modelRenderer_compiled.desc); + mv.visitLabel(l1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 1); + mv.visitEnd(); + } + super.visitEnd(); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTOpenGlHelper.java b/java/shadersmodcore/transform/SMCCTOpenGlHelper.java new file mode 100644 index 000000000..09de7fabb --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTOpenGlHelper.java @@ -0,0 +1,96 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTOpenGlHelper implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + //boolean has_activeTexUnit = false; + +// @Override +// public FieldVisitor visitField(int access, String name, String desc, +// String signature, Object value) { +// //if (name.equals("activeTexUnit")) { +// // has_activeTexUnit = true; +// //} +// return cv.visitField(access, name, desc, signature, value); +// } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //if (!has_activeTexUnit) { + // has_activeTexUnit = true; + // FieldVisitor fv = cv.visitField(ACC_PUBLIC + ACC_STATIC, "activeTexUnit", "I", null, null); + // fv.visitEnd(); + // SMCLog.finest(" add field activeTexUnit"); + //} + + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.openGlHelper_setActiveTexture.equalsNameDesc(name, desc)) + { + //SMCLog.info(" patching"); + return new MVsetActiveTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVsetActiveTexture extends MethodVisitor + { + public MVsetActiveTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ILOAD, 0); + mv.visitFieldInsn(PUTSTATIC, "shadersmodcore/client/Shaders", "activeTexUnit", "I"); + SMCLog.finest(" set activeTexUnit"); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTPrjRedIlluRenderHalo.java b/java/shadersmodcore/transform/SMCCTPrjRedIlluRenderHalo.java new file mode 100644 index 000000000..70fa81115 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTPrjRedIlluRenderHalo.java @@ -0,0 +1,96 @@ +package shadersmodcore.transform; + +import static org.objectweb.asm.Opcodes.INVOKESTATIC; +import net.minecraft.launchwrapper.IClassTransformer; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTPrjRedIlluRenderHalo implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, 0); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + this.classname = name; + //SMCLog.info(" class %s",name); + super.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" %s%s",name,desc); + if ("prepareRenderState".equals(name) && "()V".equals(desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVprepare(cv.visitMethod(access, name, desc, signature, exceptions)); + } + if ("restoreRenderState".equals(name) && "()V".equals(desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVrestore(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVprepare extends MethodVisitor + { + public MVprepare(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.equals("codechicken/lib/render/CCRenderState", "reset", "()V", owner, name, desc)) { + SMCLog.info(" beginHalo"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginProjectRedHalo", "()V"); + } + super.visitMethodInsn(opcode, owner, name, desc); + } + + @Override + public void visitInsn(int opcode) { + super.visitInsn(opcode); + } + } + private static class MVrestore extends MethodVisitor + { + public MVrestore(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + super.visitMethodInsn(opcode, owner, name, desc); + if (Names.equals("org/lwjgl/opengl/GL11", "glDisable", "(I)V", owner, name, desc)) { + SMCLog.info(" endHalo"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endProjectRedHalo", "()V"); + } + } + } + +} diff --git a/java/shadersmodcore/transform/SMCCTRender.java b/java/shadersmodcore/transform/SMCCTRender.java new file mode 100644 index 000000000..97e673118 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTRender.java @@ -0,0 +1,82 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTRender implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.render_renderShadow.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVrenderShadow(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVrenderShadow extends MethodVisitor + { + //protected MethodVisitor mv; + public MVrenderShadow(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + //this.mv = mv; + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "shouldSkipDefaultShadow", "Z"); + Label l1 = new Label(); + mv.visitJumpInsn(IFEQ, l1); + mv.visitInsn(RETURN); + mv.visitLabel(l1); + SMCLog.finer(" conditionally skip default shadow"); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTRenderBlocks.java b/java/shadersmodcore/transform/SMCCTRenderBlocks.java new file mode 100644 index 000000000..e1900fec3 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTRenderBlocks.java @@ -0,0 +1,388 @@ +package shadersmodcore.transform; + +import java.util.Iterator; +import java.util.ListIterator; + +import org.lwjgl.opengl.GL12; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.AbstractInsnNode; +import org.objectweb.asm.tree.InsnList; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTRenderBlocks implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.renderBlocks_renderBlockByRenderType.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkByRenType( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + else + if (Names.renderBlocks_renderBlockFlowerPot.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkFlowerPot( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + else + if (Names.renderBlocks_renderStdBlockWithAOP.equalsNameDesc(name, desc) || + Names.renderBlocks_renderStdBlockWithAO.equalsNameDesc(name, desc) + ) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkWithAO(access, name, desc, signature, exceptions, + cv.visitMethod(access, name, desc, signature, exceptions)); + } + else + if (Names.renderBlocks_renderStdBlockWithCM.equalsNameDesc(name, desc) || + Names.renderBlocks_renderBlockCactusImpl.equalsNameDesc(name, desc) || + Names.renderBlocks_renderBlockBed.equalsNameDesc(name, desc) || + Names.renderBlocks_renderBlockFluids.equalsNameDesc(name, desc) || + Names.renderBlocks_renderBlockDoor.equalsNameDesc(name, desc) || + Names.renderBlocks_renderBlockSandFalling.equalsNameDesc(name, desc) + ) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkFVar( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + else + if (Names.renderBlocks_renderPistonExtension.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkPistonExt( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVrenBlkByRenType extends MethodVisitor + { + public MVrenBlkByRenType(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + int nPatch = 0; + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ILOAD, 2); + mv.visitVarInsn(ILOAD, 3); + mv.visitVarInsn(ILOAD, 4); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "pushEntity", "("+Names.renderBlocks_.desc+Names.block_.desc+"III)V"); + //SMCLog.info(" pushEntity"); + ++nPatch; + } + + @Override + public void visitInsn(int opcode) { + if (opcode==Opcodes.IRETURN) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "popEntity", "()V"); + //SMCLog.info(" popEntity"); + ++nPatch; + } + mv.visitInsn(opcode); + } + + @Override + public void visitEnd() { + mv.visitEnd(); + //SMCLog.info(" %d", nPatch); + } + + } + + private static class MVrenBlkFlowerPot extends MethodVisitor + { + public MVrenBlkFlowerPot(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + int nPatch = 0; + int state = 0; + + @Override + public void visitVarInsn(int opcode, int var) { + super.visitVarInsn(opcode, var); + if (state==1) { + ++state; + mv.visitVarInsn(ALOAD, var); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "pushEntity", "("+Names.block_.desc+")V"); + } + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + super.visitMethodInsn(opcode, owner, name, desc); + switch (state) { + case 0: + if (Names.block_getBlockFromItem.equals(owner, name, desc)) { + ++state; + } + break; + case 2: + if (Names.tessellator_addTranslation.equals(owner, name, desc)) { + ++state; + } + break; + case 3: + if (Names.tessellator_addTranslation.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "popEntity", "()V"); + } + break; + } + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ILOAD, 2); + mv.visitVarInsn(ILOAD, 3); + mv.visitVarInsn(ILOAD, 4); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "pushEntity", "("+Names.renderBlocks_.desc+Names.block_.desc+"III)V"); + //SMCLog.info(" pushEntity"); + ++nPatch; + } + + @Override + public void visitInsn(int opcode) { + if (opcode==Opcodes.IRETURN) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "popEntity", "()V"); + //SMCLog.info(" popEntity"); + ++nPatch; + } + mv.visitInsn(opcode); + } + + @Override + public void visitEnd() { + mv.visitEnd(); + //SMCLog.info(" %d", nPatch); + } + + } + + static final String[] fieldsBlockLightLevel = {null,"blockLightLevel05","blockLightLevel06","blockLightLevel08"}; + + private static class MVrenBlkWithAO extends MethodVisitor + { + MethodVisitor mv1; + MethodNode mn; + int nPatch = 0; + public MVrenBlkWithAO(final int access, final String name, final String desc, + final String signature, final String[] exceptions, + MethodVisitor mv) { + super(Opcodes.ASM4); + super.mv = this.mn = new MethodNode(access, name, desc, signature, exceptions); + this.mv1 = mv; + } + @Override + public void visitEnd() { + mn.visitEnd(); + mn.accept(mv1); + //SMCLog.info(" %d", nPatch); + } + + @Override + public void visitLdcInsn(Object cst) { + int match1 = 0; + if (cst instanceof Float) { + float fcst = ((Float)cst).floatValue(); + if (fcst == 0.5f) match1 = 1; + else if (fcst == 0.6f) match1 = 2; + else if (fcst == 0.8f) match1 = 3; + } + if (match1 != 0) { + int match2 = 0; + InsnList insns = mn.instructions; + AbstractInsnNode insn = insns.getLast(); + if (insn!=null && insn.getOpcode()==Opcodes.FLOAD) { + insn=insn.getPrevious(); + if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { + insn=insn.getPrevious(); + if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { + insn=insn.getPrevious(); + if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { + insn=insn.getPrevious(); + if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { + match2 = match1; + } + } + } + } + } + if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { + insn=insn.getPrevious(); + if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { + insn=insn.getPrevious(); + if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { + insn=insn.getPrevious(); + if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { + match2 = match1; + } + } + } + } + if (match2 != 0) { + String fieldName = fieldsBlockLightLevel[match2]; + mn.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", fieldName, "F"); + //SMCLog.info(" %s", fieldName); + ++nPatch; + return; + } + } + mn.visitLdcInsn(cst); + } + + } + + private static class MVrenBlkFVar extends MethodVisitor + { + int nPatch = 0; + public MVrenBlkFVar(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int state = 0; + + @Override + public void visitLdcInsn(Object cst) { + int match1 = 0; + if (cst instanceof Float) { + float fcst = ((Float)cst).floatValue(); + if (fcst == 0.5f) match1 = 1; + else if (fcst == 0.6f) match1 = 2; + else if (fcst == 0.8f) match1 = 3; + } + if (match1 != 0 && state < 3) { + ++state; + String fieldName = fieldsBlockLightLevel[match1]; + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", fieldName, "F"); + //SMCLog.info(" %s", fieldName); + ++nPatch; + return; + } + mv.visitLdcInsn(cst); + } + + @Override + public void visitEnd() { + mv.visitEnd(); + //SMCLog.info(" %d", nPatch); + } + } + + private static class MVrenBlkPistonExt extends MethodVisitor + { + int nPatch = 0; + public MVrenBlkPistonExt(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + int state = 0; + + @Override + public void visitTableSwitchInsn(int min, int max, Label dflt, + Label... labels) { + state = 1; + mv.visitTableSwitchInsn(min, max, dflt, labels); + } + + @Override + public void visitLdcInsn(Object cst) { + int match1 = 0; + if (cst instanceof Float) { + float fcst = ((Float)cst).floatValue(); + if (fcst == 0.5f) match1 = 1; + else if (fcst == 0.6f) match1 = 2; + else if (fcst == 0.8f) match1 = 3; + } + if (match1 != 0 && state == 1) { + String fieldName = fieldsBlockLightLevel[match1]; + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", fieldName, "F"); + //SMCLog.info(" %s", fieldName); + ++nPatch; + return; + } + mv.visitLdcInsn(cst); + } + + @Override + public void visitEnd() { + mv.visitEnd(); + //SMCLog.info(" %d", nPatch); + } + } + +// private static class MVNTransform extends MethodVisitor +// { +// protected MethodVisitor mv; +// protected MethodNode mn; +// public MVNTransform(MethodNode mn, MethodVisitor mv) { +// super(Opcodes.ASM4); +// super.mv = this.mn = mn; +// this.mv = mv; +// } +// +// @Override +// public void visitEnd() { +// super.visitEnd(); +// Iterator it = mn.instructions.iterator(); +// while (it.hasNext()) +// { +// AbstractInsnNode node = it.next(); +// System.out.println(node.toString()); +// } +// // send to target +// mn.accept(mv); +// } +// } + +} diff --git a/java/shadersmodcore/transform/SMCCTRenderGlobal.java b/java/shadersmodcore/transform/SMCCTRenderGlobal.java new file mode 100644 index 000000000..65fc4c7db --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTRenderGlobal.java @@ -0,0 +1,354 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.lwjgl.opengl.GL11; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTRenderGlobal implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + if (Names.renderGlobal_worldRenderers.name.equals(name)) { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //String remappedName = SMCRemap.remapper.mapMethodName(classname, name, desc); + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.renderGlobal_renderEntities.equalsNameDesc(name, desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVrenderEntities(cv.visitMethod(access, name, desc, signature, exceptions)); + } + else if (Names.renderGlobal_sortAndRender.equalsNameDesc(name, desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVendisTexFog(cv.visitMethod(access, name, desc, signature, exceptions)); + } + else if (Names.renderGlobal_renderSky.equalsNameDesc(name, desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVrenderSky(cv.visitMethod(access, name, desc, signature, exceptions)); + } + else if (Names.renderGlobal_drawBlockDamageTexture.equalsNameDesc(name, desc) + || name.equals("drawBlockDamageTexture") ) // Optifine + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVdrawBlockDamageTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } + else if (Names.renderGlobal_drawSelectionBox.equalsNameDesc(name, desc)) + { + SMCLog.finer(" patch method %s.%s%s",classname,name,desc); + return new MVendisTexFog(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVrenderEntities extends MethodVisitor + { + public MVrenderEntities(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int state = 0; + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof String) { + String scst = (String)cst; + if (scst.equals("entities")) { + state = 1; + } + else if (scst.equals("blockentities")) { + state = 4; + } + } + mv.visitLdcInsn(cst); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, + String desc) { + if (state==2) { + if (Names.renderManager_instance.equals(owner, name, desc)) { + state = 3; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "nextEntity", "()V"); + } + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + mv.visitMethodInsn(opcode, owner, name, desc); + if (state == 1) { + state = 2; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginEntities", "()V"); + SMCLog.finest(" %s","beginEntities"); + } else if (state == 4) { + state = 5; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endEntities", "()V"); + SMCLog.finest(" %s","endEntities"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginBlockEntities", "()V"); + SMCLog.finest(" %s","beginTileEntities"); + } else if (state == 5) { + if (Names.entityRenderer_disableLightmap.equals(owner, name, desc)) { + state = 6; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endBlockEntities", "()V"); + SMCLog.finest(" %s","endTileEntities"); + } + } + } + + } + + /* detect glEnable or glDisable (TEXTURE_2D or FOG) */ + private static class MVendisTexFog extends MethodVisitor + { + public MVendisTexFog(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int lastInt = 0; + + @Override + public void visitIntInsn(int opcode, int operand) { + mv.visitIntInsn(opcode, operand); + if (opcode == SIPUSH && (operand==3553 || operand==2912)) { + lastInt = operand; + } + else { + lastInt = 0; + } + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + mv.visitMethodInsn(opcode, owner, name, desc); + if (owner.equals("org/lwjgl/opengl/GL11")) { + if (name.equals("glEnable")) { + if (lastInt==GL11.GL_TEXTURE_2D) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableTexture2D", "()V"); + SMCLog.finest(" %s","enableTexture2D"); + } else if (lastInt==GL11.GL_FOG) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableFog", "()V"); + SMCLog.finest(" %s","enableFog"); + } + } else if (name.equals("glDisable")) { + if (lastInt==GL11.GL_TEXTURE_2D) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableTexture2D", "()V"); + SMCLog.finest(" %s","disableTexture2D"); + } else if (lastInt==GL11.GL_FOG) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableFog", "()V"); + SMCLog.finest(" %s","disableFog"); + } + } + } + lastInt = 0; + } + } + + /* extends MVenableTF */ + private static class MVrenderSky extends MVendisTexFog + { + public MVrenderSky(MethodVisitor mv) { + super(mv); + } + + int state = 0; + boolean detectedOptifine = false; + + int lastInt = 0; + int lastVar = 0; + + @Override + public void visitIntInsn(int opcode, int operand) { + mv.visitIntInsn(opcode, operand); + if (opcode == SIPUSH) { + lastInt = operand; + } else { + lastInt = 0; + } + } + + @Override + public void visitVarInsn(int opcode, int var) { + mv.visitVarInsn(opcode, var); + if (opcode == ALOAD) { + lastVar = var; + } else { + lastVar = 0; + } + } + + + + @Override + public void visitFieldInsn(int opcode, String owner, String name, String desc) { + switch (state) + { + case 0: + if (Names.vec3_xCoord.equals(owner, name)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setSkyColor", "("+Names.vec3_.desc+")V"); + mv.visitVarInsn(ALOAD, lastVar); + break; + } + break; + case 1: + if (Names.renderGlobal_glSkyList.equals(owner, name)) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "preSkyList", "()V"); + break; + } + break; + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + //SMCLog.info(" %s.%s%s",ownerM,nameM,descM); + switch (state) { + case 0: + if (owner.equals("Config") && name.equals("isSkyEnabled")) { + detectedOptifine = true; + } + break; + case 2: + if (Names.worldClient_getRainStrength.equals(owner, name, desc)) { + ++state; + } + break; + } + // + mv.visitMethodInsn(opcode, owner, name, desc); + // + if (owner.equals("org/lwjgl/opengl/GL11")) { + if (name.equals("glEnable")) { + if (lastInt==GL11.GL_TEXTURE_2D) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableTexture2D", "()V"); + SMCLog.finest(" %s","enableTexture2D"); + } else if (lastInt==GL11.GL_FOG) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableFog", "()V"); + SMCLog.finest(" %s","enableFog"); + } + } else if (name.equals("glDisable")) { + if (lastInt==GL11.GL_TEXTURE_2D) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableTexture2D", "()V"); + SMCLog.finest(" %s","disableTexture2D"); + } else if (lastInt==GL11.GL_FOG) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableFog", "()V"); + SMCLog.finest(" %s","disableFog"); + } + } else if (name.equals("glRotatef")) { + SMCLog.finest(" *%s %d","glRotatef",state); + if (state == 3) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "preCelestialRotate", "()V"); + SMCLog.finest(" %s","preCelestialRotate"); + } else if (state == 4) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "postCelestialRotate", "()V"); + SMCLog.finest(" %s","postCelestialRotate"); + } + } + } + } + } + + private static class MVdrawBlockDamageTexture extends MethodVisitor + { + int state = 0; + + public MVdrawBlockDamageTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitIntInsn(int opcode, int operand) { + switch(state) + { + case 0: + if (opcode==SIPUSH && operand==GL11.GL_ALPHA_TEST) { + ++state; + } + break; + case 2: + if (opcode==SIPUSH && operand==GL11.GL_ALPHA_TEST) { + ++state; + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endBlockDestroyProgress", "()V"); + SMCLog.finest(" %s","endBlockDestroyProgress"); + } + break; + } + mv.visitIntInsn(opcode, operand); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + switch(state) + { + case 1: + if (owner.equals("org/lwjgl/opengl/GL11") && name.equals("glEnable")) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginBlockDestroyProgress", "()V"); + SMCLog.finest(" %s","beginBlockDestroyProgress"); + return; + } + break; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + +} diff --git a/java/shadersmodcore/transform/SMCCTRenderManager.java b/java/shadersmodcore/transform/SMCCTRenderManager.java new file mode 100644 index 000000000..a40b29b0e --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTRenderManager.java @@ -0,0 +1,60 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +/** transformer for net.minecraft.client.renderer.Tessellator */ +public class SMCCTRenderManager implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, 0); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + boolean endFields = false; + + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + if (Names.renderManager_entityRenderMap.name.equals(name)) { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + } +} diff --git a/java/shadersmodcore/transform/SMCCTRenderSpider.java b/java/shadersmodcore/transform/SMCCTRenderSpider.java new file mode 100644 index 000000000..d70ff3ac9 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTRenderSpider.java @@ -0,0 +1,87 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTRenderSpider implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.renderDragon_shouldRenderPass.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVshouldRenderPass(cv.visitMethod(access, name, desc, signature, exceptions)); + } + if (Names.renderEnderman_shouldRenderPass.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVshouldRenderPass(cv.visitMethod(access, name, desc, signature, exceptions)); + } + if (Names.renderSpider_shouldRenderPass.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVshouldRenderPass(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVshouldRenderPass extends MethodVisitor + { + public MVshouldRenderPass(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + mv.visitMethodInsn(opcode, owner, name, desc); + if (Names.equals("org/lwjgl/opengl/GL11","glColor4f","(FFFF)V",owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginSpiderEyes", "()V"); + } + } + } + +} diff --git a/java/shadersmodcore/transform/SMCCTRendererLivingEntity.java b/java/shadersmodcore/transform/SMCCTRendererLivingEntity.java new file mode 100644 index 000000000..8c2ba9649 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTRendererLivingEntity.java @@ -0,0 +1,290 @@ +package shadersmodcore.transform; + +import java.util.Iterator; +import java.util.ListIterator; + +import org.lwjgl.opengl.GL12; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.AbstractInsnNode; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTRendererLivingEntity implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + if (Names.rendererLivingE_mainModel.name.equals(name) || + Names.rendererLivingE_renderPassModel.name.equals(name)) { + access = access & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.rendererLivingE_doRender.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVdoRenderLiving( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + else + if (Names.rendererLivingE_renderLabel.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVrenderLivingLabel( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVdoRenderLiving extends MethodVisitor + { + public MVdoRenderLiving(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + //SMCLog.info(" insert code"); + mv.visitCode(); + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "useEntityHurtFlash", "Z"); + Label label1 = new Label(); + mv.visitJumpInsn(IFEQ, label1); + mv.visitVarInsn(ALOAD, 1); + mv.visitFieldInsn(GETFIELD, Names.entityLivingBase_hurtTime.clas, + Names.entityLivingBase_hurtTime.name, + Names.entityLivingBase_hurtTime.desc); + Label label2 = new Label(); + mv.visitJumpInsn(IFGT, label2); + mv.visitVarInsn(ALOAD, 1); + mv.visitFieldInsn(GETFIELD, Names.entityLivingBase_deathTime.clas, + Names.entityLivingBase_deathTime.name, + Names.entityLivingBase_deathTime.desc); + Label label3 = new Label(); + mv.visitJumpInsn(IFLE, label3); + mv.visitLabel(label2); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitIntInsn(BIPUSH, 102); + Label label4 = new Label(); + mv.visitJumpInsn(GOTO, label4); + mv.visitLabel(label3); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitInsn(ICONST_0); + mv.visitLabel(label4); + mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {Opcodes.INTEGER}); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(FLOAD, 9); + mv.visitMethodInsn(INVOKEVIRTUAL, Names.entity_getBrightness.clas, + Names.entity_getBrightness.name, + Names.entity_getBrightness.desc); + mv.visitVarInsn(FLOAD, 9); + mv.visitMethodInsn(INVOKEVIRTUAL, Names.rendererLivingE_getColorMultiplier.clas, + Names.rendererLivingE_getColorMultiplier.name, + Names.rendererLivingE_getColorMultiplier.desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setEntityHurtFlash", "(II)V"); + mv.visitLabel(label1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + //SMCLog.info(" end insert"); + } + + /** last SIPUSH operand */ + private int lastInt = 0; + /** state */ + private int state = 0; + private static final int stateEnd = 7; + /** end of vanilla hurt rendering */ + Label labelEndVH = null; + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode==SIPUSH) { + lastInt = operand; + } + mv.visitIntInsn(opcode, operand); + } + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof Integer) + { + int icst = ((Integer)cst).intValue(); + if (icst == GL12.GL_RESCALE_NORMAL) { + //SMCLog.info(" rescale_normal"); + if (labelEndVH != null) { + //SMCLog.info(" jump target"); + mv.visitLabel(labelEndVH); + labelEndVH = null; + } + } + } + mv.visitLdcInsn(cst); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + //SMCLog.info(" %s.%s%s",ownerM,nameM,descM); + if (opcode==INVOKEVIRTUAL) { + if (Names.rendererLivingE_renderEquippedItems.equals(owner, name, desc)) { + //SMCLog.info(" renderEquippedItems"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "resetEntityHurtFlash", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "useEntityHurtFlash", "Z"); + labelEndVH = new Label(); + mv.visitJumpInsn(IFNE, labelEndVH); + state = 1; + return; + } + } + // + mv.visitMethodInsn(opcode, owner, name, desc); + // + if (opcode==INVOKESTATIC) { + if (Names.equals("org/lwjgl/opengl/GL11","glDepthFunc","(I)V",owner,name,desc)) { + //SMCLog.info(" glDepthFunc"); + if (state==3) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginLivingDamage", "()V"); + ++state; + } else if (state==4) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endLivingDamage", "()V"); + ++state; + } + } else if (Names.openGlHelper_setActiveTexture.equals(owner,name,desc)) { + //SMCLog.info(" setActiveTexture"); + if (state==1) { + ++state; + } else if (state==2) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableLightmap", "()V"); + ++state; + } else if (state==5) { + ++state; + } else if (state==6) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableLightmap", "()V"); + ++state; + } + } + } + + } + + @Override + public void visitEnd() { + mv.visitEnd(); + if (state != stateEnd) { + SMCLog.severe("state %d expected %d", state, stateEnd); + } + } + } + + private static class MVrenderLivingLabel extends MethodVisitor + { + public MVrenderLivingLabel(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int pushedInt = 0; + + @Override + public void visitIntInsn(int opcode, int operand) { + mv.visitIntInsn(opcode, operand); + if (opcode == SIPUSH && operand == 3553) + pushedInt = 3553; + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (pushedInt == 3553) + { + pushedInt = 0; + if (opcode==INVOKESTATIC && owner.equals("org/lwjgl/opengl/GL11") && desc.equals("(I)V")) + { + if (name.equals("glDisable")) + { + owner = "shadersmodcore/client/Shaders"; + name = "sglDisableT2D"; + } + else + if (name.equals("glEnable")) + { + owner = "shadersmodcore/client/Shaders"; + name = "sglEnableT2D"; + } + } + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + + } + + +// private static class MVNTransform extends MethodVisitor +// { +// protected MethodVisitor mv; +// protected MethodNode mn; +// public MVNTransform(MethodNode mn, MethodVisitor mv) { +// super(Opcodes.ASM4); +// super.mv = this.mn = mn; +// this.mv = mv; +// } +// +// @Override +// public void visitEnd() { +// super.visitEnd(); +// Iterator it = mn.instructions.iterator(); +// while (it.hasNext()) +// { +// AbstractInsnNode node = it.next(); +// System.out.println(node.toString()); +// } +// // send to target +// mn.accept(mv); +// } +// } + +} diff --git a/java/shadersmodcore/transform/SMCCTSmartMoveModelRotationRenderer.java b/java/shadersmodcore/transform/SMCCTSmartMoveModelRotationRenderer.java new file mode 100644 index 000000000..01921a927 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTSmartMoveModelRotationRenderer.java @@ -0,0 +1,83 @@ +package shadersmodcore.transform; + +import java.util.Iterator; +import java.util.ListIterator; + +import org.lwjgl.opengl.GL12; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.AbstractInsnNode; +import org.objectweb.asm.tree.MethodNode; +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTSmartMoveModelRotationRenderer implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if ("resetDisplayList".equals(name) && "()V".equals(desc)) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + { + mv = cv.visitMethod(ACC_PUBLIC, "resetDisplayList", "()V", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESPECIAL, Names.modelRenderer_.clas, "resetDisplayList", "()V"); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + //mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", "compiled", "Z"); + mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", Names.modelRenderer_compiled.name, "Z"); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + //mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", "displayList", "I"); + mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", Names.modelRenderer_displayList.name, "I"); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 1); + mv.visitEnd(); + } + super.visitEnd(); + } + + } +} diff --git a/java/shadersmodcore/transform/SMCCTTessellator.java b/java/shadersmodcore/transform/SMCCTTessellator.java new file mode 100644 index 000000000..15c64c4e1 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTessellator.java @@ -0,0 +1,464 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +/** transformer for net.minecraft.client.renderer.Tessellator */ +public class SMCCTTessellator implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static boolean inputHasStaticBuffer = false; + + private static class CVTransform extends ClassVisitor + { + String classname; + boolean endFields = false; + + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + //SMCLog.fine("%x %s %s %s",access,desc,name,nameM); + if ( name.equals("vertexPos") || + name.equals("normalX") || + name.equals("normalY") || + name.equals("normalZ") || + name.equals("midTextureU") || + name.equals("midTextureV") + ) { + return null; + } else if (((access & ACC_STATIC) != 0) && ( + Names.tessellator_byteBuffer.name.equals(name) || + Names.tessellator_intBuffer.name.equals(name) || + Names.tessellator_floatBuffer.name.equals(name) || + Names.tessellator_shortBuffer.name.equals(name) || + Names.tessellator_vertexCount.name.equals(name) + //nameM.equals(Names.Tessellator_useVBO) || + //nameM.equals(Names.Tessellator_vertexBuffers) + )) { + inputHasStaticBuffer = true; + //SMCLog.finest(" input has static buffer"); + access = access & (~ACC_STATIC & ~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } else { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + if (!endFields) { + endFields = true; + FieldVisitor fv; + fv = cv.visitField(ACC_PUBLIC, "vertexPos", "[F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "normalX", "F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "normalY", "F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "normalZ", "F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "midTextureU", "F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "midTextureV", "F", null, null); + fv.visitEnd(); + } + //SMCLog.fine(" method %s.%s%s = %s",classname,name,desc,nameM); + if (name.equals("")) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVclinit(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (name.equals("") && desc.equals("()V")) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVinit(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (name.equals("") && desc.equals("(I)V")) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVinitI( + cv.visitMethod(access, name, desc, signature, exceptions) + ); + } else + if (Names.tessellator_draw.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVdraw(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.tessellator_reset.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + access = access & ~(ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; + return new MVreset(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.tessellator_addVertex.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVaddVertex(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.tessellator_setNormal.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVsetNormal( + cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.tessellator_sortQuad.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVsortQuad( + cv.visitMethod(access, name, desc, signature, exceptions)); + } else + { + access = access & ~(ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + /*private static class MVclinit extends MethodVisitor + { + public MVclinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + } + + private static class MVinit extends MethodVisitor + { + public MVinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitInsn(int opcode) { + if (opcode == RETURN) { + mv.visitVarInsn(ALOAD, 0); + mv.visitIntInsn(BIPUSH, 16); + mv.visitIntInsn(NEWARRAY, T_FLOAT); + mv.visitFieldInsn(PUTFIELD, SMCNames.Tessellator_, "vertexPos", "[F"); + } + mv.visitInsn(opcode); + } + }*/ + + private static class MVclinit extends MethodVisitor + { + public MVclinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, + String desc) { + //SMCLog.finest(" F %d %s.%s %s", opcode, ownerM, nameM, descM); + if (opcode==PUTSTATIC && ( + Names.tessellator_byteBuffer.equals(owner, name) || + Names.tessellator_intBuffer.equals(owner, name) || + Names.tessellator_floatBuffer.equals(owner, name) || + Names.tessellator_shortBuffer.equals(owner, name) || + Names.tessellator_vertexCount.equals(owner, name) + //nameM.equals(Names.Tessellator_useVBO)|| + //nameM.equals(Names.Tessellator_vertexBuffers) + )) + { + mv.visitInsn(POP); + return; + } else + if (opcode==GETSTATIC && ( + Names.tessellator_byteBuffer.equals(owner, name) + //nameM.equals(Names.Tessellator_vertexBuffers) + )) + { + mv.visitInsn(ACONST_NULL); + return; + //} else + //if (opcode==GETSTATIC && ( + // nameM.equals(Names.Tessellator_useVBO) + // )) + //{ + // mv.visitInsn(ICONST_0); + // return; + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + //SMCLog.finest(" M %d %s.%s %s", opcode, ownerM, nameM, descM); + if (Names.glAllocation_createDirectByteBuffer.equals(owner, name, desc)) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } else if (Names.glAllocation_createDirectIntBuffer.equals(owner, name, desc)) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } else if (Names.equals("java/nio/ByteBuffer","asIntBuffer","()Ljava/nio/IntBuffer;",owner,name,desc) ) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } else if (Names.equals("java/nio/ByteBuffer","asFloatBuffer","()Ljava/nio/FloatBuffer;",owner,name,desc) ) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } else if (Names.equals("java/nio/ByteBuffer","asShortBuffer","()Ljava/nio/ShortBuffer;",owner,name,desc) ) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVinit extends MethodVisitor + { + public MVinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (opcode==INVOKESPECIAL + && Names.equals("java/lang/Object","","()V",owner, name, desc) ) + { + mv.visitLdcInsn(new Integer(65536)); + mv.visitMethodInsn(INVOKESPECIAL, Names.tessellator_.clas, "", "(I)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVinitI extends MethodVisitor + { + public MVinitI(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitInsn(int opcode) { + if (opcode == RETURN) { + if (inputHasStaticBuffer) { + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitInsn(ICONST_4); + mv.visitInsn(IMUL); + mv.visitMethodInsn(INVOKESTATIC, Names.glAllocation_createDirectByteBuffer.clas, Names.glAllocation_createDirectByteBuffer.name, Names.glAllocation_createDirectByteBuffer.desc); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_byteBuffer.clas, Names.tessellator_byteBuffer.name, Names.tessellator_byteBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.tessellator_byteBuffer.clas, Names.tessellator_byteBuffer.name, Names.tessellator_byteBuffer.desc); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/nio/ByteBuffer", "asIntBuffer", "()Ljava/nio/IntBuffer;"); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_intBuffer.clas, Names.tessellator_intBuffer.name, Names.tessellator_intBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.tessellator_byteBuffer.clas, Names.tessellator_byteBuffer.name, Names.tessellator_byteBuffer.desc); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/nio/ByteBuffer", "asFloatBuffer", "()Ljava/nio/FloatBuffer;"); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_floatBuffer.clas, Names.tessellator_floatBuffer.name, Names.tessellator_floatBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.tessellator_byteBuffer.clas, Names.tessellator_byteBuffer.name, Names.tessellator_byteBuffer.desc); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/nio/ByteBuffer", "asShortBuffer", "()Ljava/nio/ShortBuffer;"); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_shortBuffer.clas, Names.tessellator_shortBuffer.name, Names.tessellator_shortBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitIntInsn(NEWARRAY, T_INT); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_rawBuffer.clas, Names.tessellator_rawBuffer.name, Names.tessellator_rawBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_vertexCount.clas, Names.tessellator_vertexCount.name, Names.tessellator_vertexCount.desc); + //mv.visitVarInsn(ALOAD, 0); + //mv.visitFieldInsn(GETSTATIC, Names.Tessellator_, Names.Tessellator_tryVBO, "Z"); + //Label l28 = new Label(); + //mv.visitJumpInsn(IFEQ, l28); + //mv.visitMethodInsn(INVOKESTATIC, "org/lwjgl/opengl/GLContext", "getCapabilities", "()Lorg/lwjgl/opengl/ContextCapabilities;"); + //mv.visitFieldInsn(GETFIELD, "org/lwjgl/opengl/ContextCapabilities", "GL_ARB_vertex_buffer_object", "Z"); + //mv.visitJumpInsn(IFEQ, l28); + //mv.visitInsn(ICONST_1); + //Label l29 = new Label(); + //mv.visitJumpInsn(GOTO, l29); + //mv.visitLabel(l28); + //mv.visitFrame(Opcodes.F_FULL, 2, new Object[] {Names.Tessellator_, Opcodes.INTEGER}, 1, new Object[] {Names.Tessellator_}); + //mv.visitInsn(ICONST_0); + //mv.visitLabel(l29); + //mv.visitFrame(Opcodes.F_FULL, 2, new Object[] {Names.Tessellator_, Opcodes.INTEGER}, 2, new Object[] {Names.Tessellator_, Opcodes.INTEGER}); + //mv.visitFieldInsn(PUTFIELD, Names.Tessellator_, Names.Tessellator_useVBO, "Z"); + //mv.visitVarInsn(ALOAD, 0); + //mv.visitFieldInsn(GETFIELD, Names.Tessellator_, Names.Tessellator_useVBO, "Z"); + //Label l31 = new Label(); + //mv.visitJumpInsn(IFEQ, l31); + //mv.visitVarInsn(ALOAD, 0); + //mv.visitVarInsn(ALOAD, 0); + //mv.visitFieldInsn(GETFIELD, Names.Tessellator_, Names.Tessellator_vboCount, "I"); + //mv.visitMethodInsn(INVOKESTATIC, Names.GLAllocation_, Names.GLAllocation_createDirectIntBuffer, Names.GLAllocation_createDirectIntBuffer_desc); + //mv.visitFieldInsn(PUTFIELD, Names.Tessellator_, Names.Tessellator_vertexBuffers, "Ljava/nio/IntBuffer;"); + //mv.visitVarInsn(ALOAD, 0); + //mv.visitFieldInsn(GETFIELD, Names.Tessellator_, Names.Tessellator_vertexBuffers, "Ljava/nio/IntBuffer;"); + //mv.visitMethodInsn(INVOKESTATIC, "org/lwjgl/opengl/ARBVertexBufferObject", "glGenBuffersARB", "(Ljava/nio/IntBuffer;)V"); + //mv.visitLabel(l31); + //mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + } + mv.visitVarInsn(ALOAD, 0); + mv.visitIntInsn(BIPUSH, 16); + mv.visitIntInsn(NEWARRAY, T_FLOAT); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "vertexPos", "[F"); + } + mv.visitInsn(opcode); + } + } + + private static class MVdraw extends MethodVisitor + { + public MVdraw(MethodVisitor mv) { + super(Opcodes.ASM4, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitLineNumber(185, l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTess", "draw", "("+Names.tessellator_.desc+")I"); + mv.visitInsn(IRETURN); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitLocalVariable("this", Names.tessellator_.desc, null, l0, l1, 0); + mv.visitMaxs(1, 1); + mv.visitEnd(); + } + } + + private static class MVreset extends MethodVisitor + { + public MVreset(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, + String desc) { + //SMCLog.finest(" F %d %s.%s %s", opcode, ownerM, nameM, descM); + if (opcode==GETSTATIC && Names.tessellator_byteBuffer.equals(owner, name)) + { + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, owner, name, desc); + return; + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + } + + private static class MVaddVertex extends MethodVisitor + { + public MVaddVertex(MethodVisitor mv) { + super(Opcodes.ASM4, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitLineNumber(466, l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(DLOAD, 1); + mv.visitVarInsn(DLOAD, 3); + mv.visitVarInsn(DLOAD, 5); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTess", "addVertex", "("+Names.tessellator_.desc+"DDD)V"); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitLineNumber(467, l1); + mv.visitInsn(RETURN); + Label l2 = new Label(); + mv.visitLabel(l2); + mv.visitLocalVariable("this", Names.tessellator_.desc, null, l0, l2, 0); + mv.visitLocalVariable("par1", "D", null, l0, l2, 1); + mv.visitLocalVariable("par3", "D", null, l0, l2, 3); + mv.visitLocalVariable("par5", "D", null, l0, l2, 5); + mv.visitMaxs(7, 7); + mv.visitEnd(); + } + } + + private static class MVsetNormal extends MethodVisitor + { + public MVsetNormal(MethodVisitor mv) { + super(Opcodes.ASM4, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_1); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_hasNormals.clas, Names.tessellator_hasNormals.name, Names.tessellator_hasNormals.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 1); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "normalX", "F"); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 2); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "normalY", "F"); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 3); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "normalZ", "F"); + mv.visitInsn(RETURN); + Label l5 = new Label(); + mv.visitLabel(l5); + mv.visitLocalVariable("this", Names.tessellator_.desc, null, l0, l5, 0); + mv.visitLocalVariable("par1", "F", null, l0, l5, 1); + mv.visitLocalVariable("par2", "F", null, l0, l5, 2); + mv.visitLocalVariable("par3", "F", null, l0, l5, 3); + mv.visitMaxs(2, 4); + mv.visitEnd(); + } + } + + private static class MVsortQuad extends MethodVisitor + { + public MVsortQuad(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode == BIPUSH && operand == 32) + { + operand = 64; + } + super.visitIntInsn(opcode, operand); + } + + } + + +} diff --git a/java/shadersmodcore/transform/SMCCTTextureAbstract.java b/java/shadersmodcore/transform/SMCCTTextureAbstract.java new file mode 100644 index 000000000..71ab1aab1 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureAbstract.java @@ -0,0 +1,107 @@ +package shadersmodcore.transform; + +import net.minecraft.launchwrapper.IClassTransformer; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +/** transformer for net.minecraft.client.renderer.texture.AbstractTexture */ +public class SMCCTTextureAbstract implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + boolean endFields = false; + + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + if (name.equals("multiTex")) { + return null; + } else { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + if (!endFields) { + endFields = true; + FieldVisitor fv; + // multiTex + fv = cv.visitField(ACC_PUBLIC, "multiTex", "Lshadersmodcore/client/MultiTexID;", null, null); + fv.visitEnd(); + } + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.abstractTexture_deleteGlTexture.equalsNameDesc(name, desc)) { + //SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + return new MVdeleteGlTexture( + cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (name.equals("getMultiTexID") && desc.equals("()Lshadersmodcore/client/MultiTexID;")) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + // getMultiTexID + mv = cv.visitMethod(ACC_PUBLIC, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "getMultiTexID", "("+Names.abstractTexture_.desc+")Lshadersmodcore/client/MultiTexID;"); + mv.visitInsn(ARETURN); + mv.visitMaxs(1, 1); + mv.visitEnd(); + // end + cv.visitEnd(); + } + } + + private static class MVdeleteGlTexture extends MethodVisitor + { + public MVdeleteGlTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "deleteTextures", "("+Names.abstractTexture_.desc+")V"); + } + + } +} diff --git a/java/shadersmodcore/transform/SMCCTTextureAtlasSprite.java b/java/shadersmodcore/transform/SMCCTTextureAtlasSprite.java new file mode 100644 index 000000000..ea2a82e7f --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureAtlasSprite.java @@ -0,0 +1,191 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +/** transformer for net.minecraft.client.renderer.texture.TextureAtlasSprite */ +public class SMCCTTextureAtlasSprite implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + //String nameM = SMCRemap.remapper.mapFieldName(classname, name, desc); + access = access & ~(ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + access = access & ~(ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; + if (Names.textureAtlasSpri_updateAnimation.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); + } + else + if (name.equals("load") && desc.equals("("+Names.iResourceManager_.desc+Names.resourceLocation_.desc+")Z")) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVload(cv.visitMethod(access, name, desc, signature, exceptions)); + } + else + if (Names.textureAtlasSpri_loadSprite.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVloadSprite(cv.visitMethod(access, name, desc, signature, exceptions)); + } + else + if (name.equals("uploadFrameTexture") && desc.equals("(III)V")) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVuploadFrameTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + // also used by clock and compass + protected static class MVanimation extends MethodVisitor + { + //protected MethodVisitor mv; + public MVanimation(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + //this.mv = mv; + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.textureUtil_uploadTexSub.equals(owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "uploadTexSub", "([[IIIIIZZ)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVload extends MethodVisitor + { + //protected MethodVisitor mv; + public MVload(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + //this.mv = mv; + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.iResourceManager_getResource.equals(owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadResource", + "("+Names.iResourceManager_.desc+Names.resourceLocation_.desc+")"+Names.iResource_.desc); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + + } + + private static class MVloadSprite extends MethodVisitor + { + //protected MethodVisitor mv; + public MVloadSprite(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + //this.mv = mv; + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode == NEWARRAY && operand == T_INT) { + mv.visitInsn(ICONST_3); + mv.visitInsn(IMUL); + } + mv.visitIntInsn(opcode, operand); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.equals("java/awt/image/BufferedImage","getRGB","(IIII[III)[I",owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadAtlasSprite", "(Ljava/awt/image/BufferedImage;IIII[III)[I"); + return; + } else + if (Names.textureAtlasSpri_getFrameTextureData.equals(owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "extractFrame", "([IIII)[I"); + return; + } else + if (Names.equals(Names.textureAtlasSpri_.clas,"fixTransparentColor","([I)V",owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "fixTransparentColor", "("+Names.textureAtlasSpri_.desc+"[I)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + + private static class MVuploadFrameTexture extends MethodVisitor + { + public MVuploadFrameTexture(MethodVisitor mv) { + super(Opcodes.ASM4, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitVarInsn(ILOAD, 2); + mv.visitVarInsn(ILOAD, 3); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "uploadFrameTexture", "("+Names.textureAtlasSpri_.desc+"III)V"); + mv.visitInsn(RETURN); + Label l2 = new Label(); + mv.visitLabel(l2); + mv.visitLocalVariable("this", Names.textureAtlasSpri_.desc, null, l0, l2, 0); + mv.visitLocalVariable("frameIndex", "I", null, l0, l2, 1); + mv.visitLocalVariable("xPos", "I", null, l0, l2, 2); + mv.visitLocalVariable("yPos", "I", null, l0, l2, 3); + mv.visitMaxs(4, 4); + mv.visitEnd(); + } + } +} diff --git a/java/shadersmodcore/transform/SMCCTTextureClock.java b/java/shadersmodcore/transform/SMCCTTextureClock.java new file mode 100644 index 000000000..c4df5c40d --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureClock.java @@ -0,0 +1,62 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTTextureClock implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.textureAtlasSpri_updateAnimation.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new SMCCTTextureAtlasSprite.MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTTextureCompass.java b/java/shadersmodcore/transform/SMCCTTextureCompass.java new file mode 100644 index 000000000..97dc520eb --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureCompass.java @@ -0,0 +1,62 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTTextureCompass implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.textureCompass_updateCompass.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new SMCCTTextureAtlasSprite.MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTTextureDownload.java b/java/shadersmodcore/transform/SMCCTTextureDownload.java new file mode 100644 index 000000000..879be08d4 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureDownload.java @@ -0,0 +1,95 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTTextureDownload implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + //SMCLog.finest(" field %s %s %s %d", classname, name, desc, access); + return super.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //String nameM = SMCRemap.remapper.mapMethodName(classname, name, desc); + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (name.equals("getMultiTexID")) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + //getMultiTexID + mv = cv.visitMethod(ACC_PUBLIC, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;", null, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.textureDownload_textureUploaded.clas, Names.textureDownload_textureUploaded.name, Names.textureDownload_textureUploaded.desc); + Label l1 = new Label(); + mv.visitJumpInsn(IFNE, l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKEVIRTUAL, Names.textureDownload_.clas, Names.iTextureObject_getGlTextureId.name, Names.iTextureObject_getGlTextureId.desc); + mv.visitInsn(POP); + mv.visitLabel(l1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESPECIAL, Names.abstractTexture_.clas, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;"); + mv.visitInsn(ARETURN); + Label l3 = new Label(); + mv.visitLabel(l3); + mv.visitLocalVariable("this", Names.textureDownload_.desc, null, l0, l3, 0); + mv.visitMaxs(1, 1); + mv.visitEnd(); + //end + cv.visitEnd(); + } + } +} diff --git a/java/shadersmodcore/transform/SMCCTTextureDynamic.java b/java/shadersmodcore/transform/SMCCTTextureDynamic.java new file mode 100644 index 000000000..3633c6948 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureDynamic.java @@ -0,0 +1,117 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTTextureDynamic implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (name.equals("") && desc.equals("(II)V")) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVinit(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.dynamicTexture_updateDynamicTexture.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVupdate(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVinit extends MethodVisitor + { + //protected MethodVisitor mv; + public MVinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + //this.mv = mv; + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode == NEWARRAY && operand == T_INT) { + mv.visitInsn(ICONST_3); + mv.visitInsn(IMUL); + } + mv.visitIntInsn(opcode, operand); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.textureUtil_allocateTexture.equals(owner, name, desc)) { + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "initDynamicTexture", "(III"+Names.dynamicTexture_.desc+")V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + + } + + private static class MVupdate extends MethodVisitor + { + //protected MethodVisitor mv; + public MVupdate(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + //this.mv = mv; + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.textureUtil_uploadTexture.equals(owner, name, desc)) { + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "updateDynamicTexture", "(I[III"+Names.dynamicTexture_.desc+")V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTTextureLayered.java b/java/shadersmodcore/transform/SMCCTTextureLayered.java new file mode 100644 index 000000000..f5188416e --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureLayered.java @@ -0,0 +1,87 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTTextureLayered implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //String descM = SMCNames.remapper.mapMethodDesc(desc); + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.iTextureObject_loadTexture.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVloadTexture( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVloadTexture extends MethodVisitor + { + //protected MethodVisitor mv; + public MVloadTexture(MethodVisitor mv) { + super(Opcodes.ASM4); + // replace method body + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.layeredTexture_layeredTextureNames.clas, Names.layeredTexture_layeredTextureNames.name, Names.layeredTexture_layeredTextureNames.desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadLayeredTexture", "("+Names.layeredTexture_.desc+Names.iResourceManager_.desc+"Ljava/util/List;)V"); + mv.visitInsn(RETURN); + Label l2 = new Label(); + mv.visitLabel(l2); + mv.visitLocalVariable("this", Names.layeredTexture_.desc, null, l0, l2, 0); + mv.visitLocalVariable("manager", Names.iResourceManager_.desc, null, l0, l2, 1); + mv.visitMaxs(3, 2); + mv.visitEnd(); + } + } + +} diff --git a/java/shadersmodcore/transform/SMCCTTextureManager.java b/java/shadersmodcore/transform/SMCCTTextureManager.java new file mode 100644 index 000000000..bd99b50a6 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureManager.java @@ -0,0 +1,104 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTTextureManager implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + if (Names.textureManager_bindTexture.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + return new MVbindTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } else + if (Names.textureManager_onResourceManagerReload.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + return new MVonReload(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVbindTexture extends MethodVisitor + { + public MVbindTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.iTextureObject_getGlTextureId.equals(owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "bindTexture", "("+Names.iTextureObject_.desc+")V"); + return; + } else + if (Names.textureUtil_bindTexture.equals(owner,name,desc)) { + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + + } + + private static class MVonReload extends MethodVisitor + { + public MVonReload(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.iTextureObject_getGlTextureId.equals(owner,name,desc)) { + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "deleteMultiTex", "("+Names.iTextureObject_.desc+")I"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } +} diff --git a/java/shadersmodcore/transform/SMCCTTextureMap.java b/java/shadersmodcore/transform/SMCCTTextureMap.java new file mode 100644 index 000000000..eb300e689 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureMap.java @@ -0,0 +1,191 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; + +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTTextureMap implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + boolean endFields = false; + + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + if (name.equals("atlasWidth")) { + return null; + } else if (name.equals("atlasHeight")) { + return null; + } else if (Names.textureMap_anisotropic.name.equals(name)) { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return super.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + if (!endFields) { + endFields = true; + FieldVisitor fv; + fv = cv.visitField(ACC_PUBLIC, "atlasWidth", "I", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "atlasHeight", "I", null, null); + fv.visitEnd(); + } + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.textureMap_getIconResLoc.equalsNameDesc(name, desc)) + { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + else + if (Names.textureMap_loadTextureAtlas.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVloadAtlas(cv.visitMethod(access, name, desc, signature, exceptions)); + } + else + if (Names.textureMap_updateAnimations.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVloadAtlas extends MethodVisitor + { + //protected MethodVisitor mv; + public MVloadAtlas(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + //this.mv = mv; + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode == NEWARRAY && operand == T_INT) { + mv.visitInsn(ICONST_3); + mv.visitInsn(IMUL); + } + mv.visitIntInsn(opcode, operand); + } + + int varStitcher = 0; + boolean isStitcher = false; + int state = 0; + + @Override + public void visitVarInsn(int opcode, int var) { + if (opcode==ASTORE) { + if (isStitcher) { + isStitcher = false; + varStitcher = var; + } + } + mv.visitVarInsn(opcode, var); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name,String desc) { + //SMCLog.finest(" %s.%s%s",ownerM,nameM,descM); + if (Names.iResourceManager_getResource.equals(owner,name,desc)) { + SMCLog.finest(" %s","loadRes"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadResource", "("+Names.iResourceManager_.desc+Names.resourceLocation_.desc+")"+Names.iResource_.desc); + return; + } + else if (opcode==INVOKESPECIAL && Names.equals(Names.stitcher_.clas,"","(IIZII)V",owner,name,desc)) { + isStitcher = true; + } + else if (Names.textureUtil_allocateTextureMipmapAniso.equals(owner,name,desc)) { + SMCLog.finest(" %s","allocateTextureMap"); + mv.visitVarInsn(ALOAD, varStitcher); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "allocateTextureMap", "(IIIIF"+Names.stitcher_.desc+Names.textureMap_.desc+")V"); + state = 1; + return; + } + else if (state==1 && + Names.textureAtlasSpri_getIconName.equals(owner,name,desc)) { + SMCLog.finest(" %s","setSprite setIconName"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "setSprite", "("+Names.textureAtlasSpri_.desc+")"+Names.textureAtlasSpri_.desc); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "setIconName", "(Ljava/lang/String;)Ljava/lang/String;"); + state = 0; + return; + } + else if (Names.textureUtil_uploadTexSub.equals(owner,name,desc)) { + SMCLog.finest(" %s","uploadTexSubForLoadAtlas"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "uploadTexSubForLoadAtlas", "([[IIIIIZZ)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + + } + + private static class MVanimation extends MethodVisitor + { + public MVanimation(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKEVIRTUAL, Names.textureMap_.clas, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;"); + mv.visitFieldInsn(PUTSTATIC, "shadersmodcore/client/ShadersTex", "updatingTex", "Lshadersmodcore/client/MultiTexID;"); + } + + @Override + public void visitInsn(int opcode) { + if (opcode==RETURN) { + mv.visitInsn(ACONST_NULL); + mv.visitFieldInsn(PUTSTATIC, "shadersmodcore/client/ShadersTex", "updatingTex", "Lshadersmodcore/client/MultiTexID;"); + } + mv.visitInsn(opcode); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTTextureObject.java b/java/shadersmodcore/transform/SMCCTTextureObject.java new file mode 100644 index 000000000..bbca308b4 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureObject.java @@ -0,0 +1,69 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTTextureObject implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, 0); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (name.equals("getMultiTexID") && desc.equals("()Lshadersmodcore/client/MultiTexID;")) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + // getMultiTexID + mv = cv.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;", null, null); + mv.visitEnd(); + // end + cv.visitEnd(); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCCTTextureSimple.java b/java/shadersmodcore/transform/SMCCTTextureSimple.java new file mode 100644 index 000000000..98771f9d8 --- /dev/null +++ b/java/shadersmodcore/transform/SMCCTTextureSimple.java @@ -0,0 +1,89 @@ +package shadersmodcore.transform; + +import java.util.Iterator; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import static org.objectweb.asm.Opcodes.*; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.tree.MethodNode; + + +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCCTTextureSimple implements IClassTransformer { + + private static final int logDetail = 0; + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s",par1,par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv,0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor + { + String classname; + public CVTransform(ClassVisitor cv) + { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit(int version, int access, String name, + String signature, String superName, String[] interfaces) { + classname = name; + //SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) + { + //SMCLog.info(" method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + if (Names.iTextureObject_loadTexture.equalsNameDesc(name, desc)) + { + //SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + return new MVloadTexture( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + } + + private static class MVloadTexture extends MethodVisitor + { + public MVloadTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (Names.textureUtil_uploadTextureImageAllocate.equals(owner,name,desc)) { + //mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.simpleTexture_textureLocation.clas, Names.simpleTexture_textureLocation.name, Names.simpleTexture_textureLocation.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKEVIRTUAL, Names.simpleTexture_.clas, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;"); + mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadSimpleTexture", "(ILjava/awt/image/BufferedImage;ZZ"+Names.iResourceManager_.desc+Names.resourceLocation_.desc+"Lshadersmodcore/client/MultiTexID;)I"); + SMCLog.finer(" loadSimpleTexture"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + + } + +} diff --git a/java/shadersmodcore/transform/SMCClassTransformer.java b/java/shadersmodcore/transform/SMCClassTransformer.java new file mode 100644 index 000000000..61ef76299 --- /dev/null +++ b/java/shadersmodcore/transform/SMCClassTransformer.java @@ -0,0 +1,84 @@ +package shadersmodcore.transform; + +import java.io.IOException; +import java.io.InputStream; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import java.util.zip.ZipEntry; +import java.util.zip.ZipException; +import java.util.zip.ZipFile; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.commons.Remapper; + +public class SMCClassTransformer implements IClassTransformer { + + Names names; + /** map of class transformer */ + protected Map ctMap; + + public void put(Names.Clas clas, IClassTransformer ct) + { + ctMap.put(clas.clas.replace('/', '.'), ct); + } + + // constructor + public SMCClassTransformer() + { + names = new Names(); + InitNames.init(); + ctMap = new HashMap(); + put(Names.block_ , new SMCCTBlock()); + put(Names.itemBlock_ , new SMCCTItemBlock()); + put(Names.minecraft_ , new SMCCTMinecraft()); + put(Names.guiOptions_ , new SMCCTGuiOptions()); + put(Names.modelRenderer_ , new SMCCTModelRenderer()); + put(Names.openGlHelper_ , new SMCCTOpenGlHelper()); + put(Names.tessellator_ , new SMCCTTessellator()); + put(Names.renderBlocks_ , new SMCCTRenderBlocks()); + put(Names.renderGlobal_ , new SMCCTRenderGlobal()); + put(Names.entityRenderer_ , new SMCCTEntityRenderer()); + put(Names.render_ , new SMCCTRender()); + put(Names.renderManager_ , new SMCCTRenderManager()); + put(Names.rendererLivingE_ , new SMCCTRendererLivingEntity()); + put(Names.renderDragon_ , new SMCCTRenderSpider()); + put(Names.renderEnderman_ , new SMCCTRenderSpider()); + put(Names.renderSpider_ , new SMCCTRenderSpider()); + put(Names.itemRenderer_ , new SMCCTItemRenderer()); + put(Names.textureDownload_ , new SMCCTTextureDownload()); + put(Names.abstractTexture_ , new SMCCTTextureAbstract()); + put(Names.iTextureObject_ , new SMCCTTextureObject()); + put(Names.simpleTexture_ , new SMCCTTextureSimple()); + put(Names.layeredTexture_ , new SMCCTTextureLayered()); + put(Names.dynamicTexture_ , new SMCCTTextureDynamic()); + put(Names.textureMap_ , new SMCCTTextureMap()); + put(Names.textureAtlasSpri_, new SMCCTTextureAtlasSprite()); + put(Names.textureClock_ , new SMCCTTextureClock()); + put(Names.textureCompass_ , new SMCCTTextureCompass()); + put(Names.textureManager_ , new SMCCTTextureManager()); + ctMap.put("mrtjp.projectred.illumination.RenderHalo$", new SMCCTPrjRedIlluRenderHalo()); + ctMap.put("net.smart.render.ModelRotationRenderer", new SMCCTSmartMoveModelRotationRenderer()); + } + + @Override + public byte[] transform(String par1, String par2, byte[] par3) + { + byte[] bytecode = par3; + //if (par2.startsWith("mrtjp")) SMCLog.info("**** [%s]", par2); + IClassTransformer ct = ctMap.get(par2); + if (ct != null) + { + bytecode = ct.transform(par1, par2, bytecode); + int len1 = par3.length; //arg2!=null?arg2.length:0; + int len2 = bytecode.length; //bytecode!=null?bytecode.length:0; + SMCLog.fine(" %d (%+d)", len2, len2-len1); + } + return bytecode; + } + +} \ No newline at end of file diff --git a/java/shadersmodcore/transform/SMCLog.java b/java/shadersmodcore/transform/SMCLog.java new file mode 100644 index 000000000..96a63b216 --- /dev/null +++ b/java/shadersmodcore/transform/SMCLog.java @@ -0,0 +1,105 @@ +package shadersmodcore.transform; + +import java.io.IOException; +import java.util.Calendar; +import java.util.logging.ConsoleHandler; +import java.util.logging.FileHandler; +import java.util.logging.Formatter; +import java.util.logging.Handler; +import java.util.logging.Level; +import java.util.logging.LogRecord; +import java.util.logging.Logger; +import java.util.logging.SimpleFormatter; + +import static java.util.logging.Level.*; + +public abstract class SMCLog { + + private static class SMCFormatter extends Formatter { + int tzOffset; + SMCFormatter() { + tzOffset = Calendar.getInstance().getTimeZone().getRawOffset(); + } + @Override + public String format(LogRecord record) { + StringBuilder sb = new StringBuilder(); + //int time = (int)((record.getMillis() + tzOffset) % (24*60*60*1000)); + sb.append("[") + //.append(time/36000000).append(time/3600000%10)//.append(":") + //.append(time/600000%6).append(time/60000%10)//.append(":") + //.append(time/10000%6).append(time/10000%10).append(".") + //.append(time/100%10).append(time/10%10).append(time%10).append(" ") + .append(record.getLoggerName()).append(" ") + .append(record.getLevel()).append("]") + .append(record.getMessage()).append("\n"); + return sb.toString(); + } + } + + private static class SMCLogger extends Logger { + SMCLogger(String name) { + super(name,null); + setUseParentHandlers(false); + Formatter formatter = new SMCFormatter(); + Handler handler = new ConsoleHandler(); + handler.setFormatter(formatter); + addHandler(handler); + try { + handler = new FileHandler("shadersmod-%u.log",8*1048576,1,false); + handler.setFormatter(formatter); + addHandler(handler); + } catch (IOException e) { + e.printStackTrace(); + } + setLevel(ALL); + } + } + + private static class SMCLevel extends Level { + private SMCLevel(String name, int value) { + super(name,value); + } + } + + public static final String smcLogName = "SMC"; + public static final Logger logger = new SMCLogger(smcLogName); + public static final Level SMCINFO = new SMCLevel("INF",850); + public static final Level SMCCONFIG = new SMCLevel("CFG",840); + public static final Level SMCFINE = new SMCLevel("FNE",830); + public static final Level SMCFINER = new SMCLevel("FNR",820); + public static final Level SMCFINEST = new SMCLevel("FNT",810); + + public static void log(Level level, String format, Object ... args) { + if (logger.isLoggable(level)) + logger.log(level,String.format(format, args)); + } + public static void severe(String format, Object ... args) { + if (logger.isLoggable(SEVERE)) + logger.log(SEVERE,String.format(format, args)); + } + public static void warning(String format, Object ... args) { + if (logger.isLoggable(WARNING)) + logger.log(WARNING,String.format(format, args)); + } + public static void info(String format, Object ... args) { + if (logger.isLoggable(SMCINFO)) + logger.log(SMCINFO,String.format(format, args)); + } + public static void config(String format, Object ... args) { + if (logger.isLoggable(SMCCONFIG)) + logger.log(SMCCONFIG,String.format(format, args)); + } + public static void fine(String format, Object ... args) { + if (logger.isLoggable(SMCFINE)) + logger.log(SMCFINE,String.format(format, args)); + } + public static void finer(String format, Object ... args) { + if (logger.isLoggable(SMCFINER)) + logger.log(SMCFINER,String.format(format, args)); + } + public static void finest(String format, Object ... args) { + if (logger.isLoggable(SMCFINEST)) + logger.log(SMCFINEST,String.format(format, args)); + } + +} diff --git a/java_dev/shadersmodcore/devel/Names.txt b/java_dev/shadersmodcore/devel/Names.txt new file mode 100644 index 000000000..49d3e7805 --- /dev/null +++ b/java_dev/shadersmodcore/devel/Names.txt @@ -0,0 +1,167 @@ +Block_ "net/minecraft/block/Block" +GuiButton_ "net/minecraft/client/gui/GuiButton" +GuiOptions_ "net/minecraft/client/gui/GuiOptions" +GuiScreen_ "net/minecraft/client/gui/GuiScreen" +Minecraft_ "net/minecraft/client/Minecraft" +ModelRenderer_ "net/minecraft/client/model/ModelRenderer" +WorldClient_ "net/minecraft/client/multiplayer/WorldClient" +EffectRenderer_ "net/minecraft/client/particle/EffectRenderer" +Frustrum_ "net/minecraft/client/renderer/culling/Frustrum" +ICamera_ "net/minecraft/client/renderer/culling/ICamera" +Render_ "net/minecraft/client/renderer/entity/Render" +RenderDragon_ "net/minecraft/client/renderer/entity/RenderDragon" +RenderEnderman_ "net/minecraft/client/renderer/entity/RenderEnderman" +RenderSpider_ "net/minecraft/client/renderer/entity/RenderSpider" +EntityRenderer_ "net/minecraft/client/renderer/EntityRenderer" +RendererLivingEntity_ "net/minecraft/client/renderer/entity/RendererLivingEntity" +GLAllocation_ "net/minecraft/client/renderer/GLAllocation" +ItemRenderer_ "net/minecraft/client/renderer/ItemRenderer" +OpenGlHelper_ "net/minecraft/client/renderer/OpenGlHelper" +RenderBlocks_ "net/minecraft/client/renderer/RenderBlocks" +RenderGlobal_ "net/minecraft/client/renderer/RenderGlobal" +Tessellator_ "net/minecraft/client/renderer/Tessellator" +TesselatorVertexState_ "net/minecraft/client/shader/TesselatorVertexState" +AbstractTexture_ "net/minecraft/client/renderer/texture/AbstractTexture" +DynamicTexure_ "net/minecraft/client/renderer/texture/DynamicTexture" +ITextureObject_ "net/minecraft/client/renderer/texture/ITextureObject" +LayeredTexture_ "net/minecraft/client/renderer/texture/LayeredTexture" +SimpleTexture_ "net/minecraft/client/renderer/texture/SimpleTexture" +Stitcher_ "net/minecraft/client/renderer/texture/Stitcher" +TextureAtlasSprite_ "net/minecraft/client/renderer/texture/TextureAtlasSprite" +TextureClock_ "net/minecraft/client/renderer/texture/TextureClock" +TextureCompass_ "net/minecraft/client/renderer/texture/TextureCompass" +TextureManager_ "net/minecraft/client/renderer/texture/TextureManager" +TextureMap_ "net/minecraft/client/renderer/texture/TextureMap" +TextureUtil_ "net/minecraft/client/renderer/texture/TextureUtil" +ThreadDownloadImageData_ "net/minecraft/client/renderer/ThreadDownloadImageData" +IResource_ "net/minecraft/client/resources/IResource" +IResourceManager_ "net/minecraft/client/resources/IResourceManager" +GameSettings_ "net/minecraft/client/settings/GameSettings" +Entity_ "net/minecraft/entity/Entity" +EntityLivingBase_ "net/minecraft/entity/EntityLivingBase" +EntityDragon_ "net/minecraft/entity/boss/EntityDragon" +EntityEnderman_ "net/minecraft/entity/monster/EntityEnderman" +EntitySpider_ "net/minecraft/entity/monster/EntitySpider" +EntityPlayer_ "net/minecraft/entity/player/EntityPlayer" +MovingObjectPosition "net/minecraft/util/MovingObjectPosition" +ResourceLocation_ "net/minecraft/util/ResourceLocation" +Vec3_ "net/minecraft/util/Vec3" +IBlockAccess_ "net/minecraft/world/IBlockAccess" +World_ "net/minecraft/world/World" + +EntityLivingBase_deathTime EntityLivingBase_ "field_70725_aQ" "I" +EntityLivingBase_hurtTime EntityLivingBase_ "field_70737_aN" "I" +EntityRenderer_cameraZoom EntityRenderer_ "field_78503_V" "D" +EntityRenderer_mc EntityRenderer_ "field_78531_r" "L"+Minecraft_.name+";" +GameSettings_renderDistance GameSettings_ "field_151451_c" "I" +GuiButton_id GuiButton_ "field_146127_k" +GuiOptions_buttonList GuiOptions_ "field_146292_n" +GuiOptions_width GuiOptions_ "field_146294_l" +GuiOptions_height GuiOptions_ "field_146295_m" +GuiOptions_mc GuiOptions_ "field_146297_k" +GuiOptions_options GuiOptions_ "field_146443_h" +LayeredTexture_layeredTextureNames LayeredTexture_ "field_110567_b" +Minecraft_renderGlobal Minecraft_ "field_71438_f" +Minecraft_gameSettings Minecraft_ "field_71474_y" +ModelRenderer_displayList ModelRenderer_ "field_78811_r" +ModelRenderer_compiled ModelRenderer_ "field_78812_q" +RendererLivingEntity_mainModel RendererLivingEntity_ "field_77045_g" +RendererLivingEntity_renderPassModel RendererLivingEntity_ "field_77046_h" +RenderGlobal_glSkyList RenderGlobal_ "field_72771_w" +SimpleTexture_textureLocation SimpleTexture_ "field_110568_b" "L"+ResourceLocation_.name+";" +Tessellator_floatBuffer Tessellator_ "field_147566_d" +Tessellator_shortBuffer Tessellator_ "field_147567_e" +Tessellator_intBuffer Tessellator_ "field_147568_c" +Tessellator_byteBuffer Tessellator_ "field_78394_d" +Tessellator_rawBuffer Tessellator_ "field_78405_h" +Tessellator_vertexCount Tessellator_ "field_78406_i" +Tessellator_hasNormals Tessellator_ "field_78413_q" "Z" +TextureAtlasSprite_width TextureAtlasSprite_ "field_130223_c" +TextureAtlasSprite_height TextureAtlasSprite_ "field_130224_d" +TextureAtlasSprite_border TextureAtlasSprite_ "field_147966_k" +TextureMap_anisotropic TextureMap_ "field_147637_k" +ThreadDownloadImageData_textureUploaded ThreadDownloadImageData_ "field_110559_g" "Z" +Vec3_xCoord Vec3_ "field_72450_a" "D" + +AbstractTexture_deleteGlTexture AbstractTexture_ "func_147631_c" "()V" +Block_getAoLight Block_ "func_149685_I" "(L"+IBlockAccess_+";III)F" +DynamicTexure_updateDynamicTexture DynamicTexure_ "func_110564_a" "()V" +EffectRenderer_renderLitParticles EffectRenderer_ "func_78872_b" "(L"+Entity_.name+";F)V" +EffectRenderer_renderParticles EffectRenderer_ "func_78874_a" "(L"+Entity_.name+";F)V" +Entity_getBrightness Entity_ "func_70013_c" "(F)F" +EntityRenderer_enableLightmap EntityRenderer_ "func_78463_b" "(D)V" +EntityRenderer_updateFogColor EntityRenderer_ "func_78466_h" "(F)V" +EntityRenderer_setupFog EntityRenderer_ "func_78468_a" "(IF)V" +EntityRenderer_setFogColorBuffer EntityRenderer_ "func_78469_a" "(FFFF)Ljava/nio/FloatBuffer;" +EntityRenderer_renderWorld EntityRenderer_ "func_78471_a" "(FJ)V" +EntityRenderer_renderRainSnow EntityRenderer_ "func_78474_d" "(F)V" +EntityRenderer_renderHand EntityRenderer_ "func_78476_b" "(FI)V" +EntityRenderer_setupCameraTransform EntityRenderer_ "func_78479_a" "(FI)V" +EntityRenderer_disableLightmap EntityRenderer_ "func_78483_a" "(D)V" +EntityRenderer_renderCloudsCheck EntityRenderer_ "func_82829_a" "(L"+RenderGlobal_.name+";F)V" +GameSettings_saveOptions GameSettings_ "func_74303_b" "()V" +GameSettings_shouldRenderClouds GameSettings_ "func_74309_c" "()Z" +GLAllocation_createDirectByteBuffer GLAllocation_ "func_74524_c" "(I)Ljava/nio/ByteBuffer;" +GLAllocation_createDirectIntBuffer GLAllocation_ "func_74527_f" "(I)Ljava/nio/IntBuffer;" +GuiOptions_actionPerformed GuiOptions_ "func_146284_a" "(L"+GuiButton_+";)V" +GuiOptions_initGui GuiOptions_ "func_73866_w_" "()V" +ICamera_setPosition ICamera_ "func_78547_a" "(DDD)V" +ItemRenderer_renderItemInFirstPerson ItemRenderer_ "func_78440_a" "(F)V" +ItemRenderer_renderOverlays ItemRenderer_ "func_78447_b" "(F)V" +Minecraft_displayGuiScreen Minecraft_ "func_147108_a" "(L"+GuiScreen_+";)V" +Minecraft_startGame Minecraft_ "func_71384_a" "()V" +OpenGlHelper_setActiveTexture OpenGlHelper_ "func_77473_a" "(I)V" +Render_renderShadow Render_ "func_76975_c" "(L"+Entity_.name+";DDDFF)V" +RenderBlocks_renderBlockFluids RenderBlocks_ "func_147721_p" "(L"+Block_+";III)Z" +RenderBlocks_renderStdBlockWithCM RenderBlocks_ "func_147736_d" "(L"+Block_+";IIIFFF)Z" +RenderBlocks_renderBlockSandFalling RenderBlocks_ "func_147749_a" "(L"+Block_+";L"+World_+";IIII)V" +RenderBlocks_renderStdBlockWithAO RenderBlocks_ "func_147751_a" "(L"+Block_+";IIIFFF)Z" +RenderBlocks_renderBlockCactusImpl RenderBlocks_ "func_147754_e" "(L"+Block_+";IIIFFF)Z" +RenderBlocks_renderBlockDoor RenderBlocks_ "func_147760_u" "(L"+Block_+";III)Z" +RenderBlocks_renderBlockBed RenderBlocks_ "func_147773_v" "(L"+Block_+";III)Z" +RenderBlocks_renderBlockByRenderType RenderBlocks_ "func_147805_b" "(L"+Block_+";III)Z" +RenderBlocks_renderStdBlockWithAOP RenderBlocks_ "func_147808_b" "(L"+Block_+";IIIFFF)Z" +RenderBlocks_renderPistonExtension RenderBlocks_ "func_147809_c" "(L"+Block_+";IIIZ)Z" +RenderDragon_shouldRenderPass RenderDragon_ "func_77032_a" "(L"+EntityDragon_+";IF)I" +RenderEnderman_shouldRenderPass RenderEnderman_ "func_77032_a" "(L"+EntityEnderman_+";IF)I" +RenderSpider_shouldRenderPass RenderSpider_ "func_77032_a" "(L"+EntitySpider_+";IF)I" +RendererLivingEntity_doRender RendererLivingEntity_ "func_76986_a" "(L"+EntityLivingBase_+";DDDFF)V" +RendererLivingEntity_renderEquippedItems RendererLivingEntity_ "func_77029_c" "(L"+EntityLivingBase_+";F)V" +RendererLivingEntity_getColorMultiplier RendererLivingEntity_ "func_77030_a" "(L"+EntityLivingBase_+";FF)I" +RendererLivingEntity_renderLabel RendererLivingEntity_ "func_96449_a" "(L"+EntityLivingBase_+";DDDLjava/lang/String;FD)V" +RenderGlobal_renderEntities RenderGlobal_ "func_147589_a" "(L"+EntityLivingBase_.name+";L"+ICamera_.name+";F)V" +RenderGlobal_renderSky RenderGlobal_ "func_72714_a" "(F)V" +RenderGlobal_drawBlockDamageTexture RenderGlobal_ "func_72717_a" "(L"+Tessellator_.name+";L"+EntityPlayer_.name+";F)V" +RenderGlobal_renderClouds RenderGlobal_ "func_72718_b" "(F)V" +RenderGlobal_sortAndRender RenderGlobal_ "func_72719_a" "(L"+EntityLivingBase_.name+";ID)I" +RenderGlobal_clipRenderersByFrustum RenderGlobal_ "func_72729_a" "(L"+ICamera_.name+";F)V" +RenderGlobal_drawSelectionBox RenderGlobal_ "func_72731_b" "(L"+EntityPlayer_.name+";L"+MovingObjectPosition_.name+";IF)V" +RenderGlobal_renderAllRenderLists RenderGlobal_ "func_72733_a" "(ID)V" +IResourceManager_getResource IResourceManager_ "func_110536_a" "(L"+ResourceLocation_.name+";)L"+IResource_.name+";" +Stitcher_getCurrentWidth Stitcher_ "func_110935_a" "()I" +Tessellator_sortQuad Tessellator_ "func_147564_a" "(FFF)L"+TesselatorVertexState_.name+";" +Tessellator_setNormal Tessellator_ "func_78375_b" "(FFF)V" +Tessellator_addVertex Tessellator_ "func_78377_a" "(DDD)V" +Tessellator_reset Tessellator_ "func_78379_d" "()V" +Tessellator_draw Tessellator_ "func_78381_a" "()I" +TextureAtlasSprite_loadSprite TextureAtlasSprite_ "func_130100_a" "(L"+IResource_.name+";)V" +TextureAtlasSprite_getFrameTextureData TextureAtlasSprite_ "func_147965_a" "(I)[[I" +TextureAtlasSprite_getIconName TextureAtlasSprite_ "func_94215_i" "()Ljava/lang/String;" +TextureAtlasSprite_updateAnimation TextureAtlasSprite_ "func_94219_l" "()V" +TextureCompass_updateCompass TextureCompass_ "func_94241_a" "(L"+World_.name+";DDDZZ)V" +TextureManager_onResourceManagerReload TextureManager_ "func_110549_a" "(L"+IResourceManager_.name+";)V" +TextureManager_bindTexture TextureManager_ "func_110577_a" "(L"+ResourceLocation_.name+";)V" +TextureMap_loadTextureAtlas TextureMap_ "func_110571_b" "(L"+IResourceManager_.name+";)V" +TextureMap_getIconResLoc TextureMap_ "func_147634_a" "(L"+ResourceLocation_.name+";I)L"+ResourceLocation_.name+";" +TextureMap_updateAnimations TextureMap_ "func_94248_c" "()V" +ITextureObject_loadTexture ITextureObject_ "func_110551_a" "(L"+IResourceManager_.name+";)V" +ITextureObject_getGlTextureId ITextureObject_ "func_110552_b" "()I" +TextureUtil_uploadTexture TextureUtil_ "func_110988_a" "(I[III)V" +TextureUtil_uploadTextureImageAllocate TextureUtil_ "func_110989_a" "(ILjava/awt/image/BufferedImage;ZZ)I" +TextureUtil_allocateTexture TextureUtil_ "func_110991_a" "(III)V" +TextureUtil_allocateTextureMipmapAniso TextureUtil_ "func_147946_a" "(IIIIF)V" +TextureUtil_uploadTexSub TextureUtil_ "func_147955_a" "([[IIIIIZZ)V" +TextureUtil_bindTexture TextureUtil_ "func_94277_a" "(I)V" +WorldClient_getCelestialAngle WorldClient_ "func_72826_c" "(F)F" +WorldClient_getRainStrength WorldClient_ "func_72867_j" "(F)F" +Frustrum_setPosition Frustrum_ ICamera_setPosition.name ICamera_setPosition.desc diff --git a/java_dev/shadersmodcore/transform/InitNames.java b/java_dev/shadersmodcore/transform/InitNames.java new file mode 100644 index 000000000..447718831 --- /dev/null +++ b/java_dev/shadersmodcore/transform/InitNames.java @@ -0,0 +1,8 @@ +package shadersmodcore.transform; + +public class InitNames { + public static void init() + { + new NamerMcp().setNames(); + } +} diff --git a/java_dev/shadersmodcore/transform/Namer1_7_10.java b/java_dev/shadersmodcore/transform/Namer1_7_10.java new file mode 100644 index 000000000..e576d8ac4 --- /dev/null +++ b/java_dev/shadersmodcore/transform/Namer1_7_10.java @@ -0,0 +1,205 @@ +package shadersmodcore.transform; + +import static shadersmodcore.transform.Names.*; + +public class Namer1_7_10 extends Namer { + + public void setNames() { + setNames1_7_10(); + } + public void setNames1_7_10() { + block_ = c("aji"); + blockFlowerPot_ = c("ald"); + minecraft_ = c("bao"); + guiButton_ = c("bcb"); + guiOptions_ = c("bdm"); + guiScreen_ = c("bdw"); + modelRenderer_ = c("bix"); + worldClient_ = c("bjf"); + effectRenderer_ = c("bkn"); + entityRenderer_ = c("blt"); + glAllocation_ = c("ban"); + itemRenderer_ = c("bly"); + openGlHelper_ = c("buu"); + renderBlocks_ = c("blm"); + renderGlobal_ = c("bma"); + tessellator_ = c("bmh"); + worldRenderer_ = c("blo"); + frustrum_ = c("bmx"); + iCamera_ = c("bmv"); + render_ = c("bno"); + renderDragon_ = c("bnl"); + renderEnderman_ = c("bnm"); + renderSpider_ = c("bov"); + renderManager_ = c("bnn"); + rendererLivingE_ = c("boh"); + abstractTexture_ = c("bpp"); + dynamicTexture_ = c("bpq"); + iTextureObject_ = c("bqh"); + layeredTexture_ = c("bpt"); + simpleTexture_ = c("bpu"); + stitcher_ = c("bpv"); + textureAtlasSpri_ = c("bqd"); + textureClock_ = c("bql"); + textureCompass_ = c("bqm"); + textureManager_ = c("bqf"); + textureMap_ = c("bpz"); + textureUtil_ = c("bqi"); + textureDownload_ = c("bpr"); + iResource_ = c("bqw"); + iResourceManager_ = c("bqy"); + gameSettings_ = c("bbj"); + tessVertexState_ = c("bmi"); + entity_ = c("sa"); + entityLivingBase_ = c("sv"); + entityDragon_ = c("xa"); + entityEnderman_ = c("ya"); + entitySpider_ = c("yn"); + entityPlayer_ = c("yz"); + item_ = c("adb"); + itemBlock_ = c("abh"); + itemStack_ = c("add"); + movingObjectPos_ = c("azu"); + resourceLocation_ = c("bqx"); + vec3_ = c("azw"); + iBlockAccess_ = c("ahl"); + world_ = c("ahb"); + + entityLivingBase_deathTime = f(entityLivingBase_,"aA","I"); + entityLivingBase_hurtTime = f(entityLivingBase_,"ax","I"); + entityRenderer_cameraZoom = f(entityRenderer_ ,"af" ,"D"); + entityRenderer_mc = f(entityRenderer_ ,"t" ,minecraft_.desc); + gameSettings_renderDistance = f(gameSettings_ ,"c","I"); + guiButton_id = f(guiButton_ ,"k","I"); + guiScreen_buttonList = f(guiScreen_ ,"n","Ljava/util/List;"); + guiScreen_width = f(guiScreen_ ,"l","I"); + guiScreen_height = f(guiScreen_ ,"m","I"); + guiScreen_mc = f(guiScreen_ ,"k",minecraft_.desc); + guiOptions_options = f(guiOptions_ ,"h",gameSettings_.desc); + itemBlock_block = f(itemBlock_ ,"a",block_.desc); + itemRenderer_itemToRender = f(itemRenderer_ ,"e",itemStack_.desc); + layeredTexture_layeredTextureNames = f(layeredTexture_,"b","Ljava/util/List;"); + minecraft_renderGlobal = f(minecraft_ ,"g" ,renderGlobal_.desc); + minecraft_gameSettings = f(minecraft_ ,"u" ,gameSettings_.desc); + modelRenderer_displayList = f(modelRenderer_ ,"u" ,"I"); + modelRenderer_compiled = f(modelRenderer_ ,"t" ,"Z"); + renderGlobal_glSkyList = f(renderGlobal_ ,"G" ,"I"); + renderGlobal_worldRenderers = f(renderGlobal_ ,"v" ,"["+worldRenderer_.desc); + rendererLivingE_mainModel = f(rendererLivingE_ ,"i" ,null); + rendererLivingE_renderPassModel = f(rendererLivingE_,"j",null); + renderManager_entityRenderMap = f(renderManager_ ,"q" ,"Ljava/util/Map;"); + renderManager_instance = f(renderManager_ ,"a" ,renderManager_.desc); + simpleTexture_textureLocation = f(simpleTexture_ ,"b",resourceLocation_.desc); + tessellator_floatBuffer = f(tessellator_ ,"d","Ljava/nio/FloatBuffer;"); + tessellator_shortBuffer = f(tessellator_ ,"e","Ljava/nio/ShortBuffer;"); + tessellator_intBuffer = f(tessellator_ ,"c","Ljava/nio/IntBuffer;"); + tessellator_byteBuffer = f(tessellator_ ,"b" ,"Ljava/nio/ByteBuffer;"); + tessellator_rawBuffer = f(tessellator_ ,"f" ,"[I"); + tessellator_vertexCount = f(tessellator_ ,"g" ,"I"); + tessellator_hasNormals = f(tessellator_ ,"o" ,"Z"); + textureAtlasSpri_width = f(textureAtlasSpri_,"e",null); + textureAtlasSpri_height = f(textureAtlasSpri_,"f",null); + textureAtlasSpri_border = f(textureAtlasSpri_,"k",null); + textureMap_anisotropic = f(textureMap_ ,"k",null); + textureDownload_textureUploaded = f(textureDownload_,"j","Z"); + vec3_xCoord = f(vec3_ ,"a" ,"D"); + + abstractTexture_deleteGlTexture = m(abstractTexture_,"c","()V"); + block_getAoLight = m(block_ ,"I","()F"); + block_getBlockFromItem = m(block_ ,"a","("+item_.desc+")"+block_.desc); + dynamicTexture_updateDynamicTexture= m(dynamicTexture_ ,"a","()V"); + effectRenderer_renderLitParticles = m(effectRenderer_ ,"b" ,"("+entity_.desc+"F)V"); + effectRenderer_renderParticles = m(effectRenderer_ ,"a" ,"("+entity_.desc+"F)V"); + entity_getBrightness = m(entity_ ,"d" ,"(F)F"); + entityRenderer_enableLightmap = m(entityRenderer_ ,"b" ,"(D)V"); + entityRenderer_updateFogColor = m(entityRenderer_ ,"j" ,"(F)V"); + entityRenderer_setupFog = m(entityRenderer_ ,"a" ,"(IF)V"); + entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"a" ,"(FFFF)Ljava/nio/FloatBuffer;"); + entityRenderer_renderWorld = m(entityRenderer_ ,"a" ,"(FJ)V"); + entityRenderer_renderRainSnow = m(entityRenderer_ ,"e" ,"(F)V"); + entityRenderer_renderHand = m(entityRenderer_ ,"b" ,"(FI)V"); + entityRenderer_setupCameraTransform = m(entityRenderer_,"a" ,"(FI)V"); + entityRenderer_disableLightmap = m(entityRenderer_ ,"a" ,"(D)V"); + entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"a" ,"("+renderGlobal_.desc+"F)V"); + gameSettings_saveOptions = m(gameSettings_ ,"b" ,"()V"); + gameSettings_shouldRenderClouds = m(gameSettings_ ,"d" ,"()Z"); + glAllocation_createDirectByteBuffer = m(glAllocation_ ,"c" ,"(I)Ljava/nio/ByteBuffer;"); + glAllocation_createDirectIntBuffer = m(glAllocation_ ,"f" ,"(I)Ljava/nio/IntBuffer;"); + glAllocation_deleteDisplayLists = m(glAllocation_ ,"b" ,"(I)V"); + guiOptions_actionPerformed = m(guiOptions_ ,"a","("+guiButton_.desc+")V"); + guiOptions_initGui = m(guiOptions_ ,"b","()V"); + iCamera_setPosition = m(iCamera_ ,"a" ,"(DDD)V"); + iResourceManager_getResource = m(iResourceManager_,"a","("+resourceLocation_.desc+")"+iResource_.desc); + itemRenderer_renderItem = m(itemRenderer_ ,"a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); + itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"a" ,"(F)V"); + itemRenderer_renderOverlays = m(itemRenderer_ ,"b" ,"(F)V"); + itemRenderer_updateEquipped = m(itemRenderer_ ,"a" ,"()V"); + iTextureObject_loadTexture = m(iTextureObject_ ,"a","("+iResourceManager_.desc+")V"); + iTextureObject_getGlTextureId = m(iTextureObject_ ,"b","()I"); + minecraft_displayGuiScreen = m(minecraft_ ,"a","("+guiScreen_.desc+")V"); + minecraft_startGame = m(minecraft_ ,"ag" ,"()V"); + openGlHelper_setActiveTexture = m(openGlHelper_ ,"j" ,"(I)V"); + render_renderShadow = m(render_ ,"c" ,"("+entity_.desc+"DDDFF)V"); + renderBlocks_renderBlockFluids = m(renderBlocks_ ,"p","("+block_.desc+"III)Z"); + renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"d","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockSandFalling = m(renderBlocks_ ,"a","("+block_.desc+world_.desc+"IIII)V"); + renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"a","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"e","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockDoor = m(renderBlocks_ ,"u","("+block_.desc+"III)Z"); + renderBlocks_renderBlockBed = m(renderBlocks_ ,"v","("+block_.desc+"III)Z"); + renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"b","("+block_.desc+"III)Z"); + renderBlocks_renderBlockFlowerPot = m(renderBlocks_ ,"a","("+blockFlowerPot_.desc+"III)Z"); + renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"b","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderPistonExtension = m(renderBlocks_ ,"c","("+block_.desc+"IIIZ)Z"); + renderDragon_shouldRenderPass = m(renderDragon_ ,"a" , "("+entityDragon_.desc+"IF)I"); + renderEnderman_shouldRenderPass = m(renderEnderman_ ,"a" , "("+entityEnderman_.desc+"IF)I"); + renderSpider_shouldRenderPass = m(renderSpider_ ,"a" , "("+entitySpider_.desc+"IF)I"); + rendererLivingE_doRender = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDFF)V"); + rendererLivingE_renderEquippedItems = m(rendererLivingE_,"c","("+entityLivingBase_.desc+"F)V"); + rendererLivingE_getColorMultiplier = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"FF)I"); + rendererLivingE_renderLabel = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); + renderGlobal_renderEntities = m(renderGlobal_ ,"a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); + renderGlobal_renderSky = m(renderGlobal_ ,"a" ,"(F)V"); + renderGlobal_drawBlockDamageTexture = m(renderGlobal_ ,"a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); + renderGlobal_renderClouds = m(renderGlobal_ ,"b" ,"(F)V"); + renderGlobal_sortAndRender = m(renderGlobal_ ,"a" ,"("+entityLivingBase_.desc+"ID)I"); + renderGlobal_clipRenderersByFrustum = m(renderGlobal_ ,"a" ,"("+iCamera_.desc+"F)V"); + renderGlobal_drawSelectionBox = m(renderGlobal_ ,"a" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); + renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"a" ,"(ID)V"); + stitcher_getCurrentWidth = m(stitcher_ ,"a","()I"); + tessellator_sortQuad = m(tessellator_ ,"a","(FFF)"+tessVertexState_.desc); + tessellator_addTranslation = m(tessellator_ ,"d" ,"(FFF)V"); + tessellator_setNormal = m(tessellator_ ,"c" ,"(FFF)V"); + tessellator_addVertex = m(tessellator_ ,"a" ,"(DDD)V"); + tessellator_reset = m(tessellator_ ,"d" ,"()V"); + tessellator_draw = m(tessellator_ ,"a" ,"()I"); + textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"-","("+iResource_.desc+")V"); + textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"a","(I)[[I"); + textureAtlasSpri_getIconName = m(textureAtlasSpri_,"g","()Ljava/lang/String;"); + textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"j","()V"); + textureCompass_updateCompass = m(textureCompass_ ,"a" ,"("+world_.desc+"DDDZZ)V"); + textureManager_onResourceManagerReload = m(textureManager_,"a","("+iResourceManager_.desc+")V"); + textureManager_bindTexture = m(textureManager_ ,"a","("+resourceLocation_.desc+")V"); + textureMap_loadTextureAtlas = m(textureMap_ ,"b","("+iResourceManager_.desc+")V"); + textureMap_getIconResLoc = m(textureMap_ ,"a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); + textureMap_updateAnimations = m(textureMap_ ,"d" ,"()V"); + textureUtil_uploadTexture = m(textureUtil_ ,"a","(I[III)V"); + textureUtil_uploadTextureImageAllocate = m(textureUtil_,"a","(ILjava/awt/image/BufferedImage;ZZ)I"); + textureUtil_allocateTexture = m(textureUtil_ ,"a","(III)V"); + textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"a","(IIIIF)V"); + textureUtil_uploadTexSub = m(textureUtil_ ,"a","([[IIIIIZZ)V"); + textureUtil_bindTexture = m(textureUtil_ ,"b" ,"(I)V"); + world_getCelestialAngle = m(world_ ,"c" ,"(F)F"); + world_getRainStrength = m(world_ ,"j" ,"(F)F"); + modelRenderer_render = m(modelRenderer_ ,"a" ,"(F)V"); + modelRenderer_renderWithRotation = m(modelRenderer_ ,"b" ,"(F)V"); + + guiOptions_buttonList = f(guiOptions_,guiScreen_buttonList); + guiOptions_width = f(guiOptions_,guiScreen_width); + guiOptions_height = f(guiOptions_,guiScreen_height); + guiOptions_mc = f(guiOptions_,guiScreen_mc); + frustrum_setPosition = m(frustrum_,iCamera_setPosition); + worldClient_getCelestialAngle = m(worldClient_,world_getCelestialAngle); + worldClient_getRainStrength = m(worldClient_,world_getRainStrength); + } +} diff --git a/java_dev/shadersmodcore/transform/Namer1_7_2.java b/java_dev/shadersmodcore/transform/Namer1_7_2.java new file mode 100644 index 000000000..e1adc2423 --- /dev/null +++ b/java_dev/shadersmodcore/transform/Namer1_7_2.java @@ -0,0 +1,183 @@ +package shadersmodcore.transform; + +import static shadersmodcore.transform.Names.*; + +public class Namer1_7_2 extends Namer { + + public void setNames() { + block_ = c("net/minecraft/block/Block"); + minecraft_ = c("net/minecraft/client/Minecraft"); + guiButton_ = c("net/minecraft/client/gui/GuiButton"); + guiOptions_ = c("net/minecraft/client/gui/GuiOptions"); + guiScreen_ = c("net/minecraft/client/gui/GuiScreen"); + modelRenderer_ = c("net/minecraft/client/model/ModelRenderer"); + worldClient_ = c("net/minecraft/client/multiplayer/WorldClient"); + effectRenderer_ = c("net/minecraft/client/particle/EffectRenderer"); + entityRenderer_ = c("net/minecraft/client/renderer/EntityRenderer"); + glAllocation_ = c("net/minecraft/client/renderer/GLAllocation"); + itemRenderer_ = c("net/minecraft/client/renderer/ItemRenderer"); + openGlHelper_ = c("net/minecraft/client/renderer/OpenGlHelper"); + renderBlocks_ = c("net/minecraft/client/renderer/RenderBlocks"); + renderGlobal_ = c("net/minecraft/client/renderer/RenderGlobal"); + tessellator_ = c("net/minecraft/client/renderer/Tessellator"); + worldRenderer_ = c("net/minecraft/client/renderer/WorldRenderer"); + frustrum_ = c("net/minecraft/client/renderer/culling/Frustrum"); + iCamera_ = c("net/minecraft/client/renderer/culling/ICamera"); + render_ = c("net/minecraft/client/renderer/entity/Render"); + renderDragon_ = c("net/minecraft/client/renderer/entity/RenderDragon"); + renderEnderman_ = c("net/minecraft/client/renderer/entity/RenderEnderman"); + renderSpider_ = c("net/minecraft/client/renderer/entity/RenderSpider"); + renderManager_ = c("net/minecraft/client/renderer/entity/RenderManager"); + rendererLivingE_ = c("net/minecraft/client/renderer/entity/RendererLivingEntity"); + abstractTexture_ = c("net/minecraft/client/renderer/texture/AbstractTexture"); + dynamicTexture_ = c("net/minecraft/client/renderer/texture/DynamicTexture"); + iTextureObject_ = c("net/minecraft/client/renderer/texture/ITextureObject"); + layeredTexture_ = c("net/minecraft/client/renderer/texture/LayeredTexture"); + simpleTexture_ = c("net/minecraft/client/renderer/texture/SimpleTexture"); + stitcher_ = c("net/minecraft/client/renderer/texture/Stitcher"); + textureAtlasSpri_ = c("net/minecraft/client/renderer/texture/TextureAtlasSprite"); + textureClock_ = c("net/minecraft/client/renderer/texture/TextureClock"); + textureCompass_ = c("net/minecraft/client/renderer/texture/TextureCompass"); + textureManager_ = c("net/minecraft/client/renderer/texture/TextureManager"); + textureMap_ = c("net/minecraft/client/renderer/texture/TextureMap"); + textureUtil_ = c("net/minecraft/client/renderer/texture/TextureUtil"); + textureDownload_ = c("net/minecraft/client/renderer/ThreadDownloadImageData"); + iResource_ = c("net/minecraft/client/resources/IResource"); + iResourceManager_ = c("net/minecraft/client/resources/IResourceManager"); + gameSettings_ = c("net/minecraft/client/settings/GameSettings"); + tessVertexState_ = c("net/minecraft/client/shader/TesselatorVertexState"); + entity_ = c("net/minecraft/entity/Entity"); + entityLivingBase_ = c("net/minecraft/entity/EntityLivingBase"); + entityDragon_ = c("net/minecraft/entity/boss/EntityDragon"); + entityEnderman_ = c("net/minecraft/entity/monster/EntityEnderman"); + entitySpider_ = c("net/minecraft/entity/monster/EntitySpider"); + entityPlayer_ = c("net/minecraft/entity/player/EntityPlayer"); + movingObjectPos_ = c("net/minecraft/util/MovingObjectPosition"); + resourceLocation_ = c("net/minecraft/util/ResourceLocation"); + vec3_ = c("net/minecraft/util/Vec3"); + iBlockAccess_ = c("net/minecraft/world/IBlockAccess"); + world_ = c("net/minecraft/world/World"); + + entityLivingBase_deathTime = f(entityLivingBase_,"field_70725_aQ","I"); + entityLivingBase_hurtTime = f(entityLivingBase_,"field_70737_aN","I"); + entityRenderer_cameraZoom = f(entityRenderer_ ,"field_78503_V" ,"D"); + entityRenderer_mc = f(entityRenderer_ ,"field_78531_r" ,minecraft_.desc); + gameSettings_renderDistance = f(gameSettings_ ,"field_151451_c","I"); + guiButton_id = f(guiButton_ ,"field_146127_k",null); + guiOptions_buttonList = f(guiOptions_ ,"field_146292_n",null); + guiOptions_width = f(guiOptions_ ,"field_146294_l",null); + guiOptions_height = f(guiOptions_ ,"field_146295_m",null); + guiOptions_mc = f(guiOptions_ ,"field_146297_k",null); + guiOptions_options = f(guiOptions_ ,"field_146443_h",null); + layeredTexture_layeredTextureNames = f(layeredTexture_,"field_110567_b",null); + minecraft_renderGlobal = f(minecraft_ ,"field_71438_f" ,null); + minecraft_gameSettings = f(minecraft_ ,"field_71474_y" ,null); + modelRenderer_displayList = f(modelRenderer_ ,"field_78811_r" ,null); + modelRenderer_compiled = f(modelRenderer_ ,"field_78812_q" ,null); + renderGlobal_glSkyList = f(renderGlobal_ ,"field_72771_w" ,null); + renderGlobal_worldRenderers = f(renderGlobal_ ,"field_72765_l" ,"["+worldRenderer_.desc); + rendererLivingE_mainModel = f(rendererLivingE_ ,"field_77045_g" ,null); + rendererLivingE_renderPassModel = f(rendererLivingE_,"field_77046_h",null); + renderManager_instance = f(renderManager_ , "field_78727_a",renderManager_.desc); + simpleTexture_textureLocation = f(simpleTexture_ ,"field_110568_b",resourceLocation_.desc); + tessellator_floatBuffer = f(tessellator_ ,"field_147566_d",null); + tessellator_shortBuffer = f(tessellator_ ,"field_147567_e",null); + tessellator_intBuffer = f(tessellator_ ,"field_147568_c",null); + tessellator_byteBuffer = f(tessellator_ ,"field_78394_d" ,null); + tessellator_rawBuffer = f(tessellator_ ,"field_78405_h" ,null); + tessellator_vertexCount = f(tessellator_ ,"field_78406_i" ,null); + tessellator_hasNormals = f(tessellator_ ,"field_78413_q" ,"Z"); + textureAtlasSpri_width = f(textureAtlasSpri_,"field_130223_c",null); + textureAtlasSpri_height = f(textureAtlasSpri_,"field_130224_d",null); + textureAtlasSpri_border = f(textureAtlasSpri_,"field_147966_k",null); + textureMap_anisotropic = f(textureMap_ ,"field_147637_k",null); + textureDownload_textureUploaded = f(textureDownload_,"field_110559_g","Z"); + vec3_xCoord = f(vec3_ ,"field_72450_a" ,"D"); + + abstractTexture_deleteGlTexture = m(abstractTexture_,"func_147631_c","()V"); + block_getAoLight = m(block_ ,"func_149685_I","("+iBlockAccess_.desc+"III)F"); + dynamicTexture_updateDynamicTexture = m(dynamicTexture_ ,"func_110564_a","()V"); + effectRenderer_renderLitParticles = m(effectRenderer_ ,"func_78872_b" ,"("+entity_.desc+"F)V"); + effectRenderer_renderParticles = m(effectRenderer_ ,"func_78874_a" ,"("+entity_.desc+"F)V"); + entity_getBrightness = m(entity_ ,"func_70013_c" ,"(F)F"); + entityRenderer_enableLightmap = m(entityRenderer_ ,"func_78463_b" ,"(D)V"); + entityRenderer_updateFogColor = m(entityRenderer_ ,"func_78466_h" ,"(F)V"); + entityRenderer_setupFog = m(entityRenderer_ ,"func_78468_a" ,"(IF)V"); + entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"func_78469_a" ,"(FFFF)Ljava/nio/FloatBuffer;"); + entityRenderer_renderWorld = m(entityRenderer_ ,"func_78471_a" ,"(FJ)V"); + entityRenderer_renderRainSnow = m(entityRenderer_ ,"func_78474_d" ,"(F)V"); + entityRenderer_renderHand = m(entityRenderer_ ,"func_78476_b" ,"(FI)V"); + entityRenderer_setupCameraTransform = m(entityRenderer_,"func_78479_a" ,"(FI)V"); + entityRenderer_disableLightmap = m(entityRenderer_ ,"func_78483_a" ,"(D)V"); + entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"func_82829_a" ,"("+renderGlobal_.desc+"F)V"); + gameSettings_saveOptions = m(gameSettings_ ,"func_74303_b" ,"()V"); + gameSettings_shouldRenderClouds = m(gameSettings_ ,"func_74309_c" ,"()Z"); + glAllocation_createDirectByteBuffer = m(glAllocation_ ,"func_74524_c" ,"(I)Ljava/nio/ByteBuffer;"); + glAllocation_createDirectIntBuffer = m(glAllocation_ ,"func_74527_f" ,"(I)Ljava/nio/IntBuffer;"); + guiOptions_actionPerformed = m(guiOptions_ ,"func_146284_a","("+guiButton_.desc+")V"); + guiOptions_initGui = m(guiOptions_ ,"func_73866_w_","()V"); + iCamera_setPosition = m(iCamera_ ,"func_78547_a" ,"(DDD)V"); + iResourceManager_getResource = m(iResourceManager_,"func_110536_a","("+resourceLocation_.desc+")"+iResource_.desc); + itemRenderer_renderItem = m(itemRenderer_ ,"func_78443_a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); + itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"func_78440_a" ,"(F)V"); + itemRenderer_renderOverlays = m(itemRenderer_ ,"func_78447_b" ,"(F)V"); + itemRenderer_updateEquipped = m(itemRenderer_ ,"func_78441_a" ,"()V"); + iTextureObject_loadTexture = m(iTextureObject_ ,"func_110551_a","("+iResourceManager_.desc+")V"); + iTextureObject_getGlTextureId = m(iTextureObject_ ,"func_110552_b","()I"); + minecraft_displayGuiScreen = m(minecraft_ ,"func_147108_a","("+guiScreen_.desc+")V"); + minecraft_startGame = m(minecraft_ ,"func_71384_a" ,"()V"); + openGlHelper_setActiveTexture = m(openGlHelper_ ,"func_77473_a" ,"(I)V"); + render_renderShadow = m(render_ ,"func_76975_c" ,"("+entity_.desc+"DDDFF)V"); + renderBlocks_renderBlockFluids = m(renderBlocks_ ,"func_147721_p","("+block_.desc+"III)Z"); + renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"func_147736_d","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockSandFalling = m(renderBlocks_ ,"func_147749_a","("+block_.desc+world_.desc+"IIII)V"); + renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"func_147751_a","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"func_147754_e","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockDoor = m(renderBlocks_ ,"func_147760_u","("+block_.desc+"III)Z"); + renderBlocks_renderBlockBed = m(renderBlocks_ ,"func_147773_v","("+block_.desc+"III)Z"); + renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"func_147805_b","("+block_.desc+"III)Z"); + renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"func_147808_b","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderPistonExtension = m(renderBlocks_ ,"func_147809_c","("+block_.desc+"IIIZ)Z"); + renderDragon_shouldRenderPass = m(renderDragon_ ,"func_77032_a" , "("+entityDragon_.desc+"IF)I"); + renderEnderman_shouldRenderPass = m(renderEnderman_ ,"func_77032_a" , "("+entityEnderman_.desc+"IF)I"); + renderSpider_shouldRenderPass = m(renderSpider_ ,"func_77032_a" , "("+entitySpider_.desc+"IF)I"); + rendererLivingE_doRender = m(rendererLivingE_,"func_76986_a" ,"("+entityLivingBase_.desc+"DDDFF)V"); + rendererLivingE_renderEquippedItems = m(rendererLivingE_,"func_77029_c","("+entityLivingBase_.desc+"F)V"); + rendererLivingE_getColorMultiplier = m(rendererLivingE_,"func_77030_a" ,"("+entityLivingBase_.desc+"FF)I"); + rendererLivingE_renderLabel = m(rendererLivingE_,"func_96449_a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); + renderGlobal_renderEntities = m(renderGlobal_ ,"func_147589_a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); + renderGlobal_renderSky = m(renderGlobal_ ,"func_72714_a" ,"(F)V"); + renderGlobal_drawBlockDamageTexture = m(renderGlobal_ ,"func_72717_a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); + renderGlobal_renderClouds = m(renderGlobal_ ,"func_72718_b" ,"(F)V"); + renderGlobal_sortAndRender = m(renderGlobal_ ,"func_72719_a" ,"("+entityLivingBase_.desc+"ID)I"); + renderGlobal_clipRenderersByFrustum = m(renderGlobal_ ,"func_72729_a" ,"("+iCamera_.desc+"F)V"); + renderGlobal_drawSelectionBox = m(renderGlobal_ ,"func_72731_b" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); + renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"func_72733_a" ,"(ID)V"); + stitcher_getCurrentWidth = m(stitcher_ ,"func_110935_a","()I"); + tessellator_sortQuad = m(tessellator_ ,"func_147564_a","(FFF)"+tessVertexState_.desc); + tessellator_setNormal = m(tessellator_ ,"func_78375_b" ,"(FFF)V"); + tessellator_addVertex = m(tessellator_ ,"func_78377_a" ,"(DDD)V"); + tessellator_reset = m(tessellator_ ,"func_78379_d" ,"()V"); + tessellator_draw = m(tessellator_ ,"func_78381_a" ,"()I"); + textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"func_130100_a","("+iResource_.desc+")V"); + textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"func_147965_a","(I)[[I"); + textureAtlasSpri_getIconName = m(textureAtlasSpri_,"func_94215_i","()Ljava/lang/String;"); + textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"func_94219_l","()V"); + textureCompass_updateCompass = m(textureCompass_ ,"func_94241_a" ,"("+world_.desc+"DDDZZ)V"); + textureManager_onResourceManagerReload = m(textureManager_,"func_110549_a","("+iResourceManager_.desc+")V"); + textureManager_bindTexture = m(textureManager_ ,"func_110577_a","("+resourceLocation_.desc+")V"); + textureMap_loadTextureAtlas = m(textureMap_ ,"func_110571_b","("+iResourceManager_.desc+")V"); + textureMap_getIconResLoc = m(textureMap_ ,"func_147634_a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); + textureMap_updateAnimations = m(textureMap_ ,"func_94248_c" ,"()V"); + textureUtil_uploadTexture = m(textureUtil_ ,"func_110988_a","(I[III)V"); + textureUtil_uploadTextureImageAllocate = m(textureUtil_,"func_110989_a","(ILjava/awt/image/BufferedImage;ZZ)I"); + textureUtil_allocateTexture = m(textureUtil_ ,"func_110991_a","(III)V"); + textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"func_147946_a","(IIIIF)V"); + textureUtil_uploadTexSub = m(textureUtil_ ,"func_147955_a","([[IIIIIZZ)V"); + textureUtil_bindTexture = m(textureUtil_ ,"func_94277_a" ,"(I)V"); + worldClient_getCelestialAngle = m(worldClient_ ,"func_72826_c" ,"(F)F"); + worldClient_getRainStrength = m(worldClient_ ,"func_72867_j" ,"(F)F"); + + frustrum_setPosition = m(frustrum_,iCamera_setPosition); + } +} diff --git a/java_dev/shadersmodcore/transform/Namer1_7_4.java b/java_dev/shadersmodcore/transform/Namer1_7_4.java new file mode 100644 index 000000000..ce86cac87 --- /dev/null +++ b/java_dev/shadersmodcore/transform/Namer1_7_4.java @@ -0,0 +1,191 @@ +package shadersmodcore.transform; + +import static shadersmodcore.transform.Names.*; + +public class Namer1_7_4 extends Namer { + + public void setNames() { + setNames1_7_4(); + } + public void setNames1_7_4() { + block_ = c("ahz"); + minecraft_ = c("azi"); + guiButton_ = c("bau"); + guiOptions_ = c("bcb"); + guiScreen_ = c("bcl"); + modelRenderer_ = c("bjs"); + worldClient_ = c("bka"); + effectRenderer_ = c("blh"); + entityRenderer_ = c("bmm"); + glAllocation_ = c("azh"); + itemRenderer_ = c("bmr"); + openGlHelper_ = c("bwg"); + renderBlocks_ = c("bmf"); + renderGlobal_ = c("bmt"); + tessellator_ = c("bna"); + worldRenderer_ = c("bmh"); + frustrum_ = c("bnq"); + iCamera_ = c("bno"); + render_ = c("boh"); + renderDragon_ = c("boe"); + renderEnderman_ = c("bof"); + renderSpider_ = c("bpo"); + renderManager_ = c("bog"); + rendererLivingE_ = c("bpa"); + abstractTexture_ = c("bqi"); + dynamicTexture_ = c("bqj"); + iTextureObject_ = c("bra"); + layeredTexture_ = c("bqm"); + simpleTexture_ = c("bqn"); + stitcher_ = c("bqo"); + textureAtlasSpri_ = c("bqw"); + textureClock_ = c("bre"); + textureCompass_ = c("brf"); + textureManager_ = c("bqy"); + textureMap_ = c("bqs"); + textureUtil_ = c("brb"); + textureDownload_ = c("bqk"); + iResource_ = c("brp"); + iResourceManager_ = c("brr"); + gameSettings_ = c("bac"); + tessVertexState_ = c("bnb"); + entity_ = c("qr"); + entityLivingBase_ = c("rm"); + entityDragon_ = c("vr"); + entityEnderman_ = c("wr"); + entitySpider_ = c("xe"); + entityPlayer_ = c("xq"); + itemBlock_ = c("zy"); + itemStack_ = c("abu"); + movingObjectPos_ = c("ayn"); + resourceLocation_ = c("brq"); + vec3_ = c("ayp"); + iBlockAccess_ = c("agc"); + world_ = c("afs"); + + entityLivingBase_deathTime = f(entityLivingBase_,"aA","I"); + entityLivingBase_hurtTime = f(entityLivingBase_,"ax","I"); + entityRenderer_cameraZoom = f(entityRenderer_ ,"af" ,"D"); + entityRenderer_mc = f(entityRenderer_ ,"t" ,minecraft_.desc); + gameSettings_renderDistance = f(gameSettings_ ,"c","I"); + guiButton_id = f(guiButton_ ,"k","I"); + guiOptions_buttonList = f(guiOptions_ ,"n","Ljava/util/List;"); + guiOptions_width = f(guiOptions_ ,"l","I"); + guiOptions_height = f(guiOptions_ ,"m","I"); + guiOptions_mc = f(guiOptions_ ,"k",minecraft_.desc); + guiOptions_options = f(guiOptions_ ,"h",gameSettings_.desc); + itemBlock_block = f(itemBlock_ ,"a",block_.desc); + itemRenderer_itemToRender = f(itemRenderer_ ,"e",itemStack_.desc); + layeredTexture_layeredTextureNames = f(layeredTexture_,"b","Ljava/util/List;"); + minecraft_renderGlobal = f(minecraft_ ,"g" ,renderGlobal_.desc); + minecraft_gameSettings = f(minecraft_ ,"u" ,gameSettings_.desc); + modelRenderer_displayList = f(modelRenderer_ ,"u" ,null); + modelRenderer_compiled = f(modelRenderer_ ,"t" ,null); + renderGlobal_glSkyList = f(renderGlobal_ ,"G" ,null); + renderGlobal_worldRenderers = f(renderGlobal_ ,"v" ,"["+worldRenderer_.desc); + rendererLivingE_mainModel = f(rendererLivingE_ ,"i" ,null); + rendererLivingE_renderPassModel = f(rendererLivingE_,"j",null); + renderManager_entityRenderMap = f(renderManager_ ,"q" ,"Ljava/util/Map;"); + renderManager_instance = f(renderManager_ , "a",renderManager_.desc); + simpleTexture_textureLocation = f(simpleTexture_ ,"b",resourceLocation_.desc); + tessellator_floatBuffer = f(tessellator_ ,"d","Ljava/nio/FloatBuffer;"); + tessellator_shortBuffer = f(tessellator_ ,"e","Ljava/nio/ShortBuffer;"); + tessellator_intBuffer = f(tessellator_ ,"c","Ljava/nio/IntBuffer;"); + tessellator_byteBuffer = f(tessellator_ ,"b" ,"Ljava/nio/ByteBuffer;"); + tessellator_rawBuffer = f(tessellator_ ,"f" ,"[I"); + tessellator_vertexCount = f(tessellator_ ,"g" ,"I"); + tessellator_hasNormals = f(tessellator_ ,"o" ,"Z"); + textureAtlasSpri_width = f(textureAtlasSpri_,"e",null); + textureAtlasSpri_height = f(textureAtlasSpri_,"f",null); + textureAtlasSpri_border = f(textureAtlasSpri_,"k",null); + textureMap_anisotropic = f(textureMap_ ,"k",null); + textureDownload_textureUploaded = f(textureDownload_,"i","Z"); + vec3_xCoord = f(vec3_ ,"c" ,"D"); + + abstractTexture_deleteGlTexture = m(abstractTexture_,"c","()V"); + block_getAoLight = m(block_ ,"I","("+iBlockAccess_.desc+"III)F"); + dynamicTexture_updateDynamicTexture= m(dynamicTexture_ ,"a","()V"); + effectRenderer_renderLitParticles = m(effectRenderer_ ,"b" ,"("+entity_.desc+"F)V"); + effectRenderer_renderParticles = m(effectRenderer_ ,"a" ,"("+entity_.desc+"F)V"); + entity_getBrightness = m(entity_ ,"d" ,"(F)F"); + entityRenderer_enableLightmap = m(entityRenderer_ ,"b" ,"(D)V"); + entityRenderer_updateFogColor = m(entityRenderer_ ,"j" ,"(F)V"); + entityRenderer_setupFog = m(entityRenderer_ ,"a" ,"(IF)V"); + entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"a" ,"(FFFF)Ljava/nio/FloatBuffer;"); + entityRenderer_renderWorld = m(entityRenderer_ ,"a" ,"(FJ)V"); + entityRenderer_renderRainSnow = m(entityRenderer_ ,"e" ,"(F)V"); + entityRenderer_renderHand = m(entityRenderer_ ,"b" ,"(FI)V"); + entityRenderer_setupCameraTransform= m(entityRenderer_ ,"a" ,"(FI)V"); + entityRenderer_disableLightmap = m(entityRenderer_ ,"a" ,"(D)V"); + entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"a" ,"("+renderGlobal_.desc+"F)V"); + gameSettings_saveOptions = m(gameSettings_ ,"b" ,"()V"); + gameSettings_shouldRenderClouds = m(gameSettings_ ,"d" ,"()Z"); + glAllocation_createDirectByteBuffer= m(glAllocation_ ,"c" ,"(I)Ljava/nio/ByteBuffer;"); + glAllocation_createDirectIntBuffer = m(glAllocation_ ,"f" ,"(I)Ljava/nio/IntBuffer;"); + guiOptions_actionPerformed = m(guiOptions_ ,"a","("+guiButton_.desc+")V"); + guiOptions_initGui = m(guiOptions_ ,"r_","()V"); + iCamera_setPosition = m(iCamera_ ,"a" ,"(DDD)V"); + iResourceManager_getResource = m(iResourceManager_,"a","("+resourceLocation_.desc+")"+iResource_.desc); + itemRenderer_renderItem = m(itemRenderer_ ,"a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); + itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"a" ,"(F)V"); + itemRenderer_renderOverlays = m(itemRenderer_ ,"b" ,"(F)V"); + itemRenderer_updateEquipped = m(itemRenderer_ ,"a" ,"()V"); + iTextureObject_loadTexture = m(iTextureObject_ ,"a","("+iResourceManager_.desc+")V"); + iTextureObject_getGlTextureId = m(iTextureObject_ ,"b","()I"); + minecraft_displayGuiScreen = m(minecraft_ ,"a","("+guiScreen_.desc+")V"); + minecraft_startGame = m(minecraft_ ,"ad" ,"()V"); + openGlHelper_setActiveTexture = m(openGlHelper_ ,"j" ,"(I)V"); + render_renderShadow = m(render_ ,"c" ,"("+entity_.desc+"DDDFF)V"); + renderBlocks_renderBlockFluids = m(renderBlocks_ ,"p","("+block_.desc+"III)Z"); + renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"d","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockSandFalling= m(renderBlocks_ ,"a","("+block_.desc+world_.desc+"IIII)V"); + renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"a","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"e","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockDoor = m(renderBlocks_ ,"u","("+block_.desc+"III)Z"); + renderBlocks_renderBlockBed = m(renderBlocks_ ,"v","("+block_.desc+"III)Z"); + renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"b","("+block_.desc+"III)Z"); + renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"b","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderPistonExtension = m(renderBlocks_ ,"c","("+block_.desc+"IIIZ)Z"); + renderDragon_shouldRenderPass = m(renderDragon_ ,"a" , "("+entityDragon_.desc+"IF)I"); + renderEnderman_shouldRenderPass = m(renderEnderman_ ,"a" , "("+entityEnderman_.desc+"IF)I"); + renderSpider_shouldRenderPass = m(renderSpider_ ,"a" , "("+entitySpider_.desc+"IF)I"); + rendererLivingE_doRender = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDFF)V"); + rendererLivingE_renderEquippedItems= m(rendererLivingE_,"c","("+entityLivingBase_.desc+"F)V"); + rendererLivingE_getColorMultiplier = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"FF)I"); + rendererLivingE_renderLabel = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); + renderGlobal_renderEntities = m(renderGlobal_ ,"a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); + renderGlobal_renderSky = m(renderGlobal_ ,"a" ,"(F)V"); + renderGlobal_drawBlockDamageTexture= m(renderGlobal_ ,"a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); + renderGlobal_renderClouds = m(renderGlobal_ ,"b" ,"(F)V"); + renderGlobal_sortAndRender = m(renderGlobal_ ,"a" ,"("+entityLivingBase_.desc+"ID)I"); + renderGlobal_clipRenderersByFrustum= m(renderGlobal_ ,"a" ,"("+iCamera_.desc+"F)V"); + renderGlobal_drawSelectionBox = m(renderGlobal_ ,"a" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); + renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"a" ,"(ID)V"); + stitcher_getCurrentWidth = m(stitcher_ ,"a","()I"); + tessellator_sortQuad = m(tessellator_ ,"a","(FFF)"+tessVertexState_.desc); + tessellator_setNormal = m(tessellator_ ,"c" ,"(FFF)V"); + tessellator_addVertex = m(tessellator_ ,"a" ,"(DDD)V"); + tessellator_reset = m(tessellator_ ,"d" ,"()V"); + tessellator_draw = m(tessellator_ ,"a" ,"()I"); + textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"####","("+iResource_.desc+")V"); + textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"a","(I)[[I"); + textureAtlasSpri_getIconName = m(textureAtlasSpri_,"g","()Ljava/lang/String;"); + textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"j","()V"); + textureCompass_updateCompass = m(textureCompass_ ,"a" ,"("+world_.desc+"DDDZZ)V"); + textureManager_onResourceManagerReload = m(textureManager_,"a","("+iResourceManager_.desc+")V"); + textureManager_bindTexture = m(textureManager_ ,"a","("+resourceLocation_.desc+")V"); + textureMap_loadTextureAtlas = m(textureMap_ ,"b","("+iResourceManager_.desc+")V"); + textureMap_getIconResLoc = m(textureMap_ ,"a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); + textureMap_updateAnimations = m(textureMap_ ,"d" ,"()V"); + textureUtil_uploadTexture = m(textureUtil_ ,"a","(I[III)V"); + textureUtil_uploadTextureImageAllocate = m(textureUtil_,"a","(ILjava/awt/image/BufferedImage;ZZ)I"); + textureUtil_allocateTexture = m(textureUtil_ ,"a","(III)V"); + textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"a","(IIIIF)V"); + textureUtil_uploadTexSub = m(textureUtil_ ,"a","([[IIIIIZZ)V"); + textureUtil_bindTexture = m(textureUtil_ ,"b" ,"(I)V"); + worldClient_getCelestialAngle = m(worldClient_ ,"c" ,"(F)F"); + worldClient_getRainStrength = m(worldClient_ ,"j" ,"(F)F"); + + frustrum_setPosition = m(frustrum_,iCamera_setPosition); + } +} diff --git a/java_dev/shadersmodcore/transform/Namer1_7_5.java b/java_dev/shadersmodcore/transform/Namer1_7_5.java new file mode 100644 index 000000000..40e22ffb0 --- /dev/null +++ b/java_dev/shadersmodcore/transform/Namer1_7_5.java @@ -0,0 +1,191 @@ +package shadersmodcore.transform; + +import static shadersmodcore.transform.Names.*; + +public class Namer1_7_5 extends Namer { + + public void setNames() { + setNames1_7_5(); + } + public void setNames1_7_5() { + block_ = c("aif"); + minecraft_ = c("azl"); + guiButton_ = c("bax"); + guiOptions_ = c("bce"); + guiScreen_ = c("bco"); + modelRenderer_ = c("bjy"); + worldClient_ = c("bkg"); + effectRenderer_ = c("bln"); + entityRenderer_ = c("bms"); + glAllocation_ = c("azk"); + itemRenderer_ = c("bmx"); + openGlHelper_ = c("bwq"); + renderBlocks_ = c("bml"); + renderGlobal_ = c("bmz"); + tessellator_ = c("bng"); + worldRenderer_ = c("bmn"); + frustrum_ = c("bnw"); + iCamera_ = c("bnu"); + render_ = c("bon"); + renderDragon_ = c("bok"); + renderEnderman_ = c("bol"); + renderSpider_ = c("bpu"); + renderManager_ = c("bom"); + rendererLivingE_ = c("bpg"); + abstractTexture_ = c("bqo"); + dynamicTexture_ = c("bqp"); + iTextureObject_ = c("brg"); + layeredTexture_ = c("bqs"); + simpleTexture_ = c("bqt"); + stitcher_ = c("bqu"); + textureAtlasSpri_ = c("brc"); + textureClock_ = c("brk"); + textureCompass_ = c("brl"); + textureManager_ = c("bre"); + textureMap_ = c("bqy"); + textureUtil_ = c("brh"); + textureDownload_ = c("bqq"); + iResource_ = c("brv"); + iResourceManager_ = c("brx"); + gameSettings_ = c("baf"); + tessVertexState_ = c("bnh"); + entity_ = c("qx"); + entityLivingBase_ = c("rs"); + entityDragon_ = c("vx"); + entityEnderman_ = c("wx"); + entitySpider_ = c("xk"); + entityPlayer_ = c("xw"); + itemBlock_ = c("aae"); + itemStack_ = c("aca"); + movingObjectPos_ = c("ayr"); + resourceLocation_ = c("brw"); + vec3_ = c("ayt"); + iBlockAccess_ = c("agi"); + world_ = c("afy"); + + entityLivingBase_deathTime = f(entityLivingBase_,"aA","I"); + entityLivingBase_hurtTime = f(entityLivingBase_,"ax","I"); + entityRenderer_cameraZoom = f(entityRenderer_ ,"af" ,"D"); + entityRenderer_mc = f(entityRenderer_ ,"t" ,minecraft_.desc); + gameSettings_renderDistance = f(gameSettings_ ,"c","I"); + guiButton_id = f(guiButton_ ,"k","I"); + guiOptions_buttonList = f(guiOptions_ ,"n","Ljava/util/List;"); + guiOptions_width = f(guiOptions_ ,"l","I"); + guiOptions_height = f(guiOptions_ ,"m","I"); + guiOptions_mc = f(guiOptions_ ,"k",minecraft_.desc); + guiOptions_options = f(guiOptions_ ,"h",gameSettings_.desc); + itemBlock_block = f(itemBlock_ ,"a",block_.desc); + itemRenderer_itemToRender = f(itemRenderer_ ,"e",itemStack_.desc); + layeredTexture_layeredTextureNames = f(layeredTexture_,"b","Ljava/util/List;"); + minecraft_renderGlobal = f(minecraft_ ,"g" ,renderGlobal_.desc); + minecraft_gameSettings = f(minecraft_ ,"u" ,gameSettings_.desc); + modelRenderer_displayList = f(modelRenderer_ ,"u" ,null); + modelRenderer_compiled = f(modelRenderer_ ,"t" ,null); + renderGlobal_glSkyList = f(renderGlobal_ ,"G" ,null); + renderGlobal_worldRenderers = f(renderGlobal_ ,"v" ,"["+worldRenderer_.desc); + rendererLivingE_mainModel = f(rendererLivingE_ ,"i" ,null); + rendererLivingE_renderPassModel = f(rendererLivingE_,"j",null); + renderManager_entityRenderMap = f(renderManager_ ,"q" ,"Ljava/util/Map;"); + renderManager_instance = f(renderManager_ ,"a" ,renderManager_.desc); + simpleTexture_textureLocation = f(simpleTexture_ ,"b",resourceLocation_.desc); + tessellator_floatBuffer = f(tessellator_ ,"f","Ljava/nio/FloatBuffer;"); + tessellator_shortBuffer = f(tessellator_ ,"e","Ljava/nio/ShortBuffer;"); + tessellator_intBuffer = f(tessellator_ ,"c","Ljava/nio/IntBuffer;"); + tessellator_byteBuffer = f(tessellator_ ,"b" ,"Ljava/nio/ByteBuffer;"); + tessellator_rawBuffer = f(tessellator_ ,"f" ,"[I"); + tessellator_vertexCount = f(tessellator_ ,"g" ,"I"); + tessellator_hasNormals = f(tessellator_ ,"o" ,"Z"); + textureAtlasSpri_width = f(textureAtlasSpri_,"e",null); + textureAtlasSpri_height = f(textureAtlasSpri_,"f",null); + textureAtlasSpri_border = f(textureAtlasSpri_,"k",null); + textureMap_anisotropic = f(textureMap_ ,"k",null); + textureDownload_textureUploaded = f(textureDownload_,"i","Z"); + vec3_xCoord = f(vec3_ ,"a" ,"D"); + + abstractTexture_deleteGlTexture = m(abstractTexture_,"c","()V"); + block_getAoLight = m(block_ ,"I","("+iBlockAccess_.desc+"III)F"); + dynamicTexture_updateDynamicTexture = m(dynamicTexture_ ,"a","()V"); + effectRenderer_renderLitParticles = m(effectRenderer_ ,"b" ,"("+entity_.desc+"F)V"); + effectRenderer_renderParticles = m(effectRenderer_ ,"a" ,"("+entity_.desc+"F)V"); + entity_getBrightness = m(entity_ ,"d" ,"(F)F"); + entityRenderer_enableLightmap = m(entityRenderer_ ,"b" ,"(D)V"); + entityRenderer_updateFogColor = m(entityRenderer_ ,"j" ,"(F)V"); + entityRenderer_setupFog = m(entityRenderer_ ,"a" ,"(IF)V"); + entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"a" ,"(FFFF)Ljava/nio/FloatBuffer;"); + entityRenderer_renderWorld = m(entityRenderer_ ,"a" ,"(FJ)V"); + entityRenderer_renderRainSnow = m(entityRenderer_ ,"e" ,"(F)V"); + entityRenderer_renderHand = m(entityRenderer_ ,"b" ,"(FI)V"); + entityRenderer_setupCameraTransform = m(entityRenderer_,"a" ,"(FI)V"); + entityRenderer_disableLightmap = m(entityRenderer_ ,"a" ,"(D)V"); + entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"a" ,"("+renderGlobal_.desc+"F)V"); + gameSettings_saveOptions = m(gameSettings_ ,"b" ,"()V"); + gameSettings_shouldRenderClouds = m(gameSettings_ ,"d" ,"()Z"); + glAllocation_createDirectByteBuffer = m(glAllocation_ ,"c" ,"(I)Ljava/nio/ByteBuffer;"); + glAllocation_createDirectIntBuffer = m(glAllocation_ ,"f" ,"(I)Ljava/nio/IntBuffer;"); + guiOptions_actionPerformed = m(guiOptions_ ,"a","("+guiButton_.desc+")V"); + guiOptions_initGui = m(guiOptions_ ,"r_","()V"); + iCamera_setPosition = m(iCamera_ ,"a" ,"(DDD)V"); + iResourceManager_getResource = m(iResourceManager_,"a","("+resourceLocation_.desc+")"+iResource_.desc); + itemRenderer_renderItem = m(itemRenderer_ ,"a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); + itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"a" ,"(F)V"); + itemRenderer_renderOverlays = m(itemRenderer_ ,"b" ,"(F)V"); + itemRenderer_updateEquipped = m(itemRenderer_ ,"a" ,"()V"); + iTextureObject_loadTexture = m(iTextureObject_ ,"a","("+iResourceManager_.desc+")V"); + iTextureObject_getGlTextureId = m(iTextureObject_ ,"b","()I"); + minecraft_displayGuiScreen = m(minecraft_ ,"a","("+guiScreen_.desc+")V"); + minecraft_startGame = m(minecraft_ ,"ad" ,"()V"); + openGlHelper_setActiveTexture = m(openGlHelper_ ,"j" ,"(I)V"); + render_renderShadow = m(render_ ,"c" ,"("+entity_.desc+"DDDFF)V"); + renderBlocks_renderBlockFluids = m(renderBlocks_ ,"p","("+block_.desc+"III)Z"); + renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"d","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockSandFalling = m(renderBlocks_ ,"a","("+block_.desc+world_.desc+"IIII)V"); + renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"a","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"e","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderBlockDoor = m(renderBlocks_ ,"u","("+block_.desc+"III)Z"); + renderBlocks_renderBlockBed = m(renderBlocks_ ,"v","("+block_.desc+"III)Z"); + renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"b","("+block_.desc+"III)Z"); + renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"b","("+block_.desc+"IIIFFF)Z"); + renderBlocks_renderPistonExtension = m(renderBlocks_ ,"c","("+block_.desc+"IIIZ)Z"); + renderDragon_shouldRenderPass = m(renderDragon_ ,"a" , "("+entityDragon_.desc+"IF)I"); + renderEnderman_shouldRenderPass = m(renderEnderman_ ,"a" , "("+entityEnderman_.desc+"IF)I"); + renderSpider_shouldRenderPass = m(renderSpider_ ,"a" , "("+entitySpider_.desc+"IF)I"); + rendererLivingE_doRender = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDFF)V"); + rendererLivingE_renderEquippedItems = m(rendererLivingE_,"c","("+entityLivingBase_.desc+"F)V"); + rendererLivingE_getColorMultiplier = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"FF)I"); + rendererLivingE_renderLabel = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); + renderGlobal_renderEntities = m(renderGlobal_ ,"a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); + renderGlobal_renderSky = m(renderGlobal_ ,"a" ,"(F)V"); + renderGlobal_drawBlockDamageTexture = m(renderGlobal_ ,"a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); + renderGlobal_renderClouds = m(renderGlobal_ ,"b" ,"(F)V"); + renderGlobal_sortAndRender = m(renderGlobal_ ,"a" ,"("+entityLivingBase_.desc+"ID)I"); + renderGlobal_clipRenderersByFrustum = m(renderGlobal_ ,"a" ,"("+iCamera_.desc+"F)V"); + renderGlobal_drawSelectionBox = m(renderGlobal_ ,"a" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); + renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"a" ,"(ID)V"); + stitcher_getCurrentWidth = m(stitcher_ ,"a","()I"); + tessellator_sortQuad = m(tessellator_ ,"a","(FFF)"+tessVertexState_.desc); + tessellator_setNormal = m(tessellator_ ,"c" ,"(FFF)V"); + tessellator_addVertex = m(tessellator_ ,"a" ,"(DDD)V"); + tessellator_reset = m(tessellator_ ,"d" ,"()V"); + tessellator_draw = m(tessellator_ ,"a" ,"()I"); + textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"####","("+iResource_.desc+")V"); + textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"a","(I)[[I"); + textureAtlasSpri_getIconName = m(textureAtlasSpri_,"g","()Ljava/lang/String;"); + textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"j","()V"); + textureCompass_updateCompass = m(textureCompass_ ,"a" ,"("+world_.desc+"DDDZZ)V"); + textureManager_onResourceManagerReload = m(textureManager_,"a","("+iResourceManager_.desc+")V"); + textureManager_bindTexture = m(textureManager_ ,"a","("+resourceLocation_.desc+")V"); + textureMap_loadTextureAtlas = m(textureMap_ ,"b","("+iResourceManager_.desc+")V"); + textureMap_getIconResLoc = m(textureMap_ ,"a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); + textureMap_updateAnimations = m(textureMap_ ,"d" ,"()V"); + textureUtil_uploadTexture = m(textureUtil_ ,"a","(I[III)V"); + textureUtil_uploadTextureImageAllocate = m(textureUtil_,"a","(ILjava/awt/image/BufferedImage;ZZ)I"); + textureUtil_allocateTexture = m(textureUtil_ ,"a","(III)V"); + textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"a","(IIIIF)V"); + textureUtil_uploadTexSub = m(textureUtil_ ,"a","([[IIIIIZZ)V"); + textureUtil_bindTexture = m(textureUtil_ ,"b" ,"(I)V"); + worldClient_getCelestialAngle = m(worldClient_ ,"c" ,"(F)F"); + worldClient_getRainStrength = m(worldClient_ ,"j" ,"(F)F"); + + frustrum_setPosition = m(frustrum_,iCamera_setPosition); + } +} diff --git a/java_dev/shadersmodcore/transform/NamerMcf.java b/java_dev/shadersmodcore/transform/NamerMcf.java new file mode 100644 index 000000000..1266f9bf9 --- /dev/null +++ b/java_dev/shadersmodcore/transform/NamerMcf.java @@ -0,0 +1,16 @@ +package shadersmodcore.transform; + +import java.util.HashMap; +import java.util.Map; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.commons.SimpleRemapper; + +public class NamerMcf extends NamerMcp { + + public void setNames() + { + setNamesSrg(); + rename("../build/unpacked/conf/"); + } + +} diff --git a/java_dev/shadersmodcore/transform/NamerMcp.java b/java_dev/shadersmodcore/transform/NamerMcp.java new file mode 100644 index 000000000..d830635bd --- /dev/null +++ b/java_dev/shadersmodcore/transform/NamerMcp.java @@ -0,0 +1,129 @@ +package shadersmodcore.transform; + +import java.io.BufferedReader; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import org.objectweb.asm.commons.Remapper; +import org.objectweb.asm.commons.SimpleRemapper; + +import shadersmodcore.transform.Names.Clas; +import shadersmodcore.transform.Names.Fiel; +import shadersmodcore.transform.Names.Meth; + +public class NamerMcp extends NamerSrg { + + public void setNames() + { + setNamesSrg(); + lookupReobfName("../conf/"); + rename("../conf/"); + } + + public void rename(String confPath) + { + Map nameMap; + nameMap = loadNameMapCSV(confPath+"fields.csv"); + for (Fiel f : af) { + String s = nameMap.get(f.name); + if (s!= null) { + f.name = s; + } + } + nameMap = loadNameMapCSV(confPath+"methods.csv"); + for (Meth m : am) { + String s = nameMap.get(m.name); + if (s!= null) { + m.name = s; + } + } + } + + Map loadNameMapCSV(String fileName) + { + Map map = new HashMap(); + BufferedReader rd = null; + try { + rd = new BufferedReader(new FileReader(fileName)); + String line; + rd.readLine(); // skip first line; + while ((line = rd.readLine()) != null) { + String[] tokens = line.split(","); + if(tokens.length>1) + { + map.put(tokens[0],tokens[1]); + } + } + } catch (FileNotFoundException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } finally { + if (rd != null) { + try { + rd.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + return map; + } + + void lookupReobfName(String confPath) + { + Map nameMap; + nameMap = loadReobfMap(confPath+"joined.srg"); + for (Clas c : ac) { + String s = nameMap.get(c.name); + System.out.printf("C %s %s\n",c.name,s); + } + for (Fiel f : af) { + String s = nameMap.get(f.clas+"/"+f.name); + System.out.printf("F %s %s\n",f.name,s); + } + for (Meth m : am) { + String s = nameMap.get(m.clas+"/"+m.name+m.desc); + System.out.printf("M %s %s\n",m.name,s); + } + } + + + Map loadReobfMap(String fileName) + { + Map map = new HashMap(); + BufferedReader rd = null; + try { + rd = new BufferedReader(new FileReader(fileName)); + String line; + while ((line = rd.readLine()) != null) { + String[] tokens = line.split(" "); + if(tokens.length>1) + { + if ("CL:".equals(tokens[0])) { + map.put(tokens[2], tokens[1]); + } else if ("FD:".equals(tokens[0])) { + map.put(tokens[2], tokens[1]); + } else if ("MD:".equals(tokens[0])) { + map.put(tokens[3]+tokens[4], tokens[1].substring(tokens[1].lastIndexOf('/')+1)); + } + } + } + } catch (FileNotFoundException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } finally { + if (rd != null) { + try { + rd.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + return map; + } +} diff --git a/resources/META-INF/MANIFEST.MF b/resources/META-INF/MANIFEST.MF new file mode 100644 index 000000000..f1c6f5a7d --- /dev/null +++ b/resources/META-INF/MANIFEST.MF @@ -0,0 +1,3 @@ +Manifest-Version: 1.0 +TweakClass: shadersmodcore.loading.SMCTweaker +TweakOrder: 1100 diff --git a/resources/mcmod.info b/resources/mcmod.info new file mode 100644 index 000000000..4d0014b72 --- /dev/null +++ b/resources/mcmod.info @@ -0,0 +1,17 @@ +[ +{ + "modid": "shadersmod", + "name": "GLSL Shaders Mod", + "description": "Use custom GLSL shaders to render world.", + "version": "2.3.18", + "mcversion": "1.7.10", + "url": "http://www.minecraftforum.net/forums/mapping-and-modding/minecraft-mods/1286604", + "updateUrl": "", + "authors": ["karyonix","sonic ether","id_miner","daxnitro"], + "credits": "Based on daxnitro's GLSL Shaders Mod. Updated by karyonix, id_miner, sonic ether.", + "logoFile": "", + "screenshots": [], + "parent":"", + "dependencies": [] +} +] \ No newline at end of file diff --git a/shadersmod-mcf.patch b/shadersmod-mcf.patch new file mode 100644 index 000000000..a2fbda4c7 --- /dev/null +++ b/shadersmod-mcf.patch @@ -0,0 +1,256 @@ +diff U3 net/minecraft/client/model/ModelRenderer.java net/minecraft/client/model/ModelRenderer.java +--- net/minecraft/client/model/ModelRenderer.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/model/ModelRenderer.java Sat Jul 12 03:12:44 2014 +@@ -305,4 +305,18 @@ + this.textureHeight = (float)p_78787_2_; + return this; + } ++ ++ public boolean getCompiled() { ++ return compiled; ++ } ++ public int getDisplayList() { ++ return displayList; ++ } ++ public void resetDisplayList() { ++ if (this.compiled) { ++ GLAllocation.deleteDisplayLists(this.displayList); ++ this.displayList = 0; ++ this.compiled = false; ++ } ++ } + } +\ No newline at end of file +diff U3 net/minecraft/client/renderer/EntityRenderer.java net/minecraft/client/renderer/EntityRenderer.java +--- net/minecraft/client/renderer/EntityRenderer.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/EntityRenderer.java Sun Jul 06 20:40:40 2014 +@@ -756,7 +756,7 @@ + /** + * Render player hand + */ +- private void renderHand(float p_78476_1_, int p_78476_2_) ++ public void renderHand(float p_78476_1_, int p_78476_2_) + { + if (this.debugViewDirection <= 0) + { +diff U3 net/minecraft/client/renderer/RenderGlobal.java net/minecraft/client/renderer/RenderGlobal.java +--- net/minecraft/client/renderer/RenderGlobal.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/RenderGlobal.java Sat Jul 12 03:14:01 2014 +@@ -96,7 +96,7 @@ + private final TextureManager renderEngine; + private List worldRenderersToUpdate = new ArrayList(); + private WorldRenderer[] sortedWorldRenderers; +- private WorldRenderer[] worldRenderers; ++ public WorldRenderer[] worldRenderers; + private int renderChunksWide; + private int renderChunksTall; + private int renderChunksDeep; +diff U3 net/minecraft/client/renderer/Tessellator.java net/minecraft/client/renderer/Tessellator.java +--- net/minecraft/client/renderer/Tessellator.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/Tessellator.java Sun Jul 06 21:01:03 2014 +@@ -24,70 +24,76 @@ + public int textureID = 0; + + /** The byte buffer used for GL allocation. */ +- private static ByteBuffer byteBuffer = GLAllocation.createDirectByteBuffer(nativeBufferSize * 4); ++ public /*static*/ ByteBuffer byteBuffer = GLAllocation.createDirectByteBuffer(nativeBufferSize * 4); + /** The same memory as byteBuffer, but referenced as an integer buffer. */ +- private static IntBuffer intBuffer = byteBuffer.asIntBuffer(); ++ public /*static*/ IntBuffer intBuffer = byteBuffer.asIntBuffer(); + /** The same memory as byteBuffer, but referenced as an float buffer. */ +- private static FloatBuffer floatBuffer = byteBuffer.asFloatBuffer(); ++ public /*static*/ FloatBuffer floatBuffer = byteBuffer.asFloatBuffer(); + /** The same memory as byteBuffer, but referenced as an short buffer. */ +- private static ShortBuffer shortBuffer = byteBuffer.asShortBuffer(); ++ public /*static*/ ShortBuffer shortBuffer = byteBuffer.asShortBuffer(); + /** Raw integer array. */ +- private int[] rawBuffer; ++ public int[] rawBuffer; + /** + * The number of vertices to be drawn in the next draw call. Reset to 0 between draw calls. + */ +- private int vertexCount; ++ public int vertexCount; + /** The first coordinate to be used for the texture. */ +- private double textureU; ++ public double textureU; + /** The second coordinate to be used for the texture. */ +- private double textureV; +- private int brightness; ++ public double textureV; ++ public int brightness; + /** The color (RGBA) value to be used for the following draw call. */ +- private int color; ++ public int color; + /** + * Whether the current draw object for this tessellator has color values. + */ +- private boolean hasColor; ++ public boolean hasColor; + /** + * Whether the current draw object for this tessellator has texture coordinates. + */ +- private boolean hasTexture; +- private boolean hasBrightness; ++ public boolean hasTexture; ++ public boolean hasBrightness; + /** + * Whether the current draw object for this tessellator has normal values. + */ +- private boolean hasNormals; ++ public boolean hasNormals; + /** The index into the raw buffer to be used for the next data. */ +- private int rawBufferIndex; ++ public int rawBufferIndex; + /** + * The number of vertices manually added to the given draw call. This differs from vertexCount because it adds extra + * vertices when converting quads to triangles. + */ +- private int addedVertices; ++ public int addedVertices; + /** Disables all color information for the following draw call. */ + private boolean isColorDisabled; + /** The draw mode currently being used by the tessellator. */ +- private int drawMode; ++ public int drawMode; + /** + * An offset to be applied along the x-axis for all vertices in this draw call. + */ +- private double xOffset; ++ public double xOffset; + /** + * An offset to be applied along the y-axis for all vertices in this draw call. + */ +- private double yOffset; ++ public double yOffset; + /** + * An offset to be applied along the z-axis for all vertices in this draw call. + */ +- private double zOffset; ++ public double zOffset; + /** The normal to be applied to the face being drawn. */ + private int normal; + /** The static instance of the Tessellator. */ + public static final Tessellator instance = new Tessellator(2097152); + /** Whether this tessellator is currently in draw mode. */ +- private boolean isDrawing; ++ public boolean isDrawing; + /** The size of the buffers used (in integers). */ +- private int bufferSize; ++ public int bufferSize; ++ public float midTextureU; ++ public float midTextureV; ++ public float normalX; ++ public float normalY; ++ public float normalZ; ++ public float[] vertexPos = new float[16]; + private static final String __OBFID = "CL_00000960"; + + private Tessellator(int p_i1250_1_) +@@ -245,7 +251,7 @@ + /** + * Clears the tessellator state in preparation for new drawing. + */ +- private void reset() ++ public void reset() + { + this.vertexCount = 0; + this.byteBuffer.clear(); +diff U3 net/minecraft/client/renderer/entity/RendererLivingEntity.java net/minecraft/client/renderer/entity/RendererLivingEntity.java +--- net/minecraft/client/renderer/entity/RendererLivingEntity.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/entity/RendererLivingEntity.java Sun Jul 06 20:40:40 2014 +@@ -31,9 +31,9 @@ + { + private static final Logger logger = LogManager.getLogger(); + private static final ResourceLocation RES_ITEM_GLINT = new ResourceLocation("textures/misc/enchanted_item_glint.png"); +- protected ModelBase mainModel; ++ public ModelBase mainModel; + /** The model to be used during the render passes. */ +- protected ModelBase renderPassModel; ++ public ModelBase renderPassModel; + private static final String __OBFID = "CL_00001012"; + + public static float NAME_TAG_RANGE = 64.0f; +diff U3 net/minecraft/client/renderer/texture/AbstractTexture.java net/minecraft/client/renderer/texture/AbstractTexture.java +--- net/minecraft/client/renderer/texture/AbstractTexture.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/texture/AbstractTexture.java Sun Jul 06 20:40:40 2014 +@@ -1,12 +1,14 @@ + package net.minecraft.client.renderer.texture; + ++import shadersmodcore.client.MultiTexID; + import cpw.mods.fml.relauncher.Side; + import cpw.mods.fml.relauncher.SideOnly; + + @SideOnly(Side.CLIENT) + public abstract class AbstractTexture implements ITextureObject + { +- protected int glTextureId = -1; ++ public int glTextureId = -1; ++ public MultiTexID multiTex; + private static final String __OBFID = "CL_00001047"; + + public int getGlTextureId() +@@ -27,4 +29,10 @@ + this.glTextureId = -1; + } + } ++ ++ @Override ++ public MultiTexID getMultiTexID() { ++ // TODO Auto-generated method stub ++ return null; ++ } + } +\ No newline at end of file +diff U3 net/minecraft/client/renderer/texture/ITextureObject.java net/minecraft/client/renderer/texture/ITextureObject.java +--- net/minecraft/client/renderer/texture/ITextureObject.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/texture/ITextureObject.java Sun Jul 06 20:40:40 2014 +@@ -3,6 +3,8 @@ + import cpw.mods.fml.relauncher.Side; + import cpw.mods.fml.relauncher.SideOnly; + import java.io.IOException; ++ ++import shadersmodcore.client.MultiTexID; + import net.minecraft.client.resources.IResourceManager; + + @SideOnly(Side.CLIENT) +@@ -11,4 +13,6 @@ + void loadTexture(IResourceManager p_110551_1_) throws IOException; + + int getGlTextureId(); ++ ++ MultiTexID getMultiTexID(); + } +\ No newline at end of file +diff U3 net/minecraft/client/renderer/texture/TextureAtlasSprite.java net/minecraft/client/renderer/texture/TextureAtlasSprite.java +--- net/minecraft/client/renderer/texture/TextureAtlasSprite.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/texture/TextureAtlasSprite.java Sun Jul 06 20:40:40 2014 +@@ -24,7 +24,7 @@ + protected List framesTextureData = Lists.newArrayList(); + private AnimationMetadataSection animationMetadata; + protected boolean rotated; +- private boolean useAnisotropicFiltering; ++ public boolean useAnisotropicFiltering; + protected int originX; + protected int originY; + protected int width; +diff U3 net/minecraft/client/renderer/texture/TextureMap.java net/minecraft/client/renderer/texture/TextureMap.java +--- net/minecraft/client/renderer/texture/TextureMap.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/texture/TextureMap.java Sun Jul 06 20:40:40 2014 +@@ -49,6 +49,7 @@ + private int anisotropicFiltering = 1; + private final TextureAtlasSprite missingImage = new TextureAtlasSprite("missingno"); + private static final String __OBFID = "CL_00001058"; ++ public int atlasWidth, atlasHeight; // shadersmod + + public TextureMap(int p_i1281_1_, String p_i1281_2_) + { +@@ -292,7 +293,7 @@ + ForgeHooksClient.onTextureStitchedPost(this); + } + +- private ResourceLocation completeResourceLocation(ResourceLocation p_147634_1_, int p_147634_2_) ++ public ResourceLocation completeResourceLocation(ResourceLocation p_147634_1_, int p_147634_2_) + { + return p_147634_2_ == 0 ? new ResourceLocation(p_147634_1_.getResourceDomain(), String.format("%s/%s%s", new Object[] {this.basePath, p_147634_1_.getResourcePath(), ".png"})): new ResourceLocation(p_147634_1_.getResourceDomain(), String.format("%s/mipmaps/%s.%d%s", new Object[] {this.basePath, p_147634_1_.getResourcePath(), Integer.valueOf(p_147634_2_), ".png"})); + }