// 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--; } // ---------------------------------------- }