sasheg dev
1038 lines
40 KiB
Java
1038 lines
40 KiB
Java
package net.rustnotmc.client;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.nio.FloatBuffer;
|
|
import java.util.Properties;
|
|
import java.util.Random;
|
|
|
|
import org.lwjgl.BufferUtils;
|
|
import org.lwjgl.opengl.EXTFramebufferObject;
|
|
import org.lwjgl.opengl.GL11;
|
|
import org.lwjgl.opengl.GL13;
|
|
import org.lwjgl.opengl.GL14;
|
|
import org.lwjgl.opengl.GL20;
|
|
|
|
import net.minecraft.client.Minecraft;
|
|
import net.rustnotmc.loader.Log;
|
|
|
|
/**
|
|
* The post processing of the remake, redone on top of what the game has.
|
|
*
|
|
* The remake owns its whole renderer and runs its effects on a core profile
|
|
* against G-buffers it fills itself. This game runs a fixed pipeline over a
|
|
* 2.1 context, so the same ideas are rebuilt with the tools that are here:
|
|
* the scene color and the scene depth are copied off the back buffer the
|
|
* moment the world is drawn, and both effects run as full-screen passes in
|
|
* programs of their own.
|
|
*
|
|
* Two effects, the way the remake has them:
|
|
*
|
|
* <ul>
|
|
* <li>SSAO. Sixteen hemisphere samples around each pixel's view-space
|
|
* position, the surface normal reconstructed from depth neighbours, softened
|
|
* by a five by five blur that stops at depth edges, then applied as a
|
|
* multiplier on the scene color.</li>
|
|
* <li>Bloom. A threshold pass picks what shines, a chain of downsamples
|
|
* spreads it, and the chain walks back up adding what it blurred into what
|
|
* lies beneath, landing as one additive layer over the screen.</li>
|
|
* </ul>
|
|
*
|
|
* The server sends none of this and the world bridge sends no light that it
|
|
* works from: every pass reads back what the client already drew, which is
|
|
* the whole point of doing them here.
|
|
*
|
|
* Everything is wrapped. A driver that refuses one of the programs must cost
|
|
* the player the effect, not the game.
|
|
*/
|
|
public final class RsxPostPipeline {
|
|
|
|
private static boolean working = true;
|
|
private static boolean programsBuilt;
|
|
private static int outputWidth;
|
|
private static int outputHeight;
|
|
|
|
private static int colorCopyTexture;
|
|
private static int depthCopyTexture;
|
|
private static int ssaoTexture;
|
|
private static int ssaoFramebuffer;
|
|
private static int blurTexture;
|
|
private static int blurFramebuffer;
|
|
private static int[] bloomTextures;
|
|
private static int[] bloomBuffers;
|
|
private static int mips;
|
|
|
|
private static Program thresholdProgram;
|
|
private static Program downSampleProgram;
|
|
private static Program combineProgram;
|
|
private static Program bloomAddProgram;
|
|
private static Program ssaoProgram;
|
|
private static Program ssaoBlurProgram;
|
|
private static Program ssaoCompositeProgram;
|
|
|
|
/** The world projection as the camera left it, and its inverse. */
|
|
private static final float[] PROJECTION = new float[16];
|
|
private static final float[] INVERSE = new float[16];
|
|
private static final FloatBuffer PROJECTION_BUF = BufferUtils.createFloatBuffer(16);
|
|
private static final FloatBuffer COLUMN_BUF = BufferUtils.createFloatBuffer(16);
|
|
|
|
/* -------- settings, kept the way the remake keeps them -------- */
|
|
|
|
private static boolean buffered;
|
|
private static boolean master = true;
|
|
private static boolean useSSAO = true;
|
|
private static boolean useBloom = true;
|
|
private static float ssaoStrength = 1.0F;
|
|
private static float ssaoRadius = 0.5F;
|
|
private static float ssaoBias = 0.02F;
|
|
private static float ssaoPower = 2.0F;
|
|
private static float bloomIntensity = 1.5F;
|
|
private static float bloomThreshold = 0.3F;
|
|
private static float bloomKnee = 0.0F;
|
|
|
|
private RsxPostPipeline() {
|
|
}
|
|
|
|
/**
|
|
* A chat line beginning with /rsxpost turns the effects around.
|
|
*
|
|
* <pre>
|
|
* /rsxpost what is on right now
|
|
* /rsxpost on|off the whole pipeline
|
|
* /rsxpost ssao on|off the shading of corners
|
|
* /rsxpost bloom on|off the glow of the sky
|
|
* /rsxpost strength 0.8 how strongly SSAO darkens
|
|
* /rsxpost radius 1.2 how far SSAO reaches, in blocks
|
|
* /rsxpost threshold 0.4 what bloom starts to pick up
|
|
* /rsxpost intensity 2.0 how bright the bloom lands
|
|
* </pre>
|
|
*
|
|
* A line that is not one of ours is left alone, which matters: the chat
|
|
* pre-fills commands the player typed before, and a half written
|
|
* /rsxpostday has to go on to the world like any other word.
|
|
*/
|
|
public static boolean command(String line) {
|
|
if (line == null || !line.startsWith("/rsxpost")) {
|
|
return false;
|
|
}
|
|
if (line.length() > 8) {
|
|
char next = line.charAt(8);
|
|
if (next != ' ' && next != '\t') {
|
|
return false;
|
|
}
|
|
}
|
|
String[] words = line.trim().split("\\s+");
|
|
if (words.length < 2) {
|
|
status();
|
|
return true;
|
|
}
|
|
String what = words[1].toLowerCase();
|
|
String value = words.length > 2 ? words[2] : null;
|
|
boolean on = "on".equalsIgnoreCase(value);
|
|
boolean off = "off".equalsIgnoreCase(value);
|
|
if ("on".equals(what)) {
|
|
setMaster(true);
|
|
} else if ("off".equals(what)) {
|
|
setMaster(false);
|
|
} else if ("ssao".equals(what)) {
|
|
if (on || off) {
|
|
useSSAO = on;
|
|
save();
|
|
say("SSAO " + (on ? "on" : "off"));
|
|
} else {
|
|
status();
|
|
}
|
|
} else if ("bloom".equals(what)) {
|
|
if (on || off) {
|
|
useBloom = on;
|
|
save();
|
|
say("bloom " + (on ? "on" : "off"));
|
|
} else {
|
|
status();
|
|
}
|
|
} else if ("strength".equals(what) && value != null) {
|
|
ssaoStrength = clamp(parse(value), 0.0F, 1.0F);
|
|
useSSAO = true;
|
|
save();
|
|
say("SSAO strength " + ssaoStrength);
|
|
} else if ("radius".equals(what) && value != null) {
|
|
ssaoRadius = clamp(parse(value), 0.1F, 2.0F);
|
|
save();
|
|
say("SSAO radius " + ssaoRadius);
|
|
} else if ("threshold".equals(what) && value != null) {
|
|
bloomThreshold = clamp(parse(value), 0.0F, 1.0F);
|
|
save();
|
|
say("bloom threshold " + bloomThreshold);
|
|
} else if ("intensity".equals(what) && value != null) {
|
|
bloomIntensity = clamp(parse(value), 0.0F, 8.0F);
|
|
save();
|
|
say("bloom intensity " + bloomIntensity);
|
|
} else {
|
|
say("unknown: " + what + "; try on, off, ssao, bloom, strength,"
|
|
+ " radius, threshold, intensity");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static float parse(String value) {
|
|
try {
|
|
return Float.parseFloat(value);
|
|
} catch (NumberFormatException notANumber) {
|
|
say("'" + value + "' is not a number");
|
|
return 0.0F;
|
|
}
|
|
}
|
|
|
|
private static float clamp(float value, float least, float most) {
|
|
if (value < least) {
|
|
return least;
|
|
}
|
|
if (value > most) {
|
|
return most;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
private static void status() {
|
|
say("post processing: master=" + master + " ssao=" + useSSAO
|
|
+ " bloom=" + useBloom + " strength=" + ssaoStrength
|
|
+ " radius=" + ssaoRadius + " threshold=" + bloomThreshold
|
|
+ " intensity=" + bloomIntensity);
|
|
}
|
|
|
|
private static void say(String text) {
|
|
Minecraft minecraft = Minecraft.getMinecraft();
|
|
if (minecraft != null && minecraft.player != null) {
|
|
minecraft.player.sendMessage(
|
|
new net.minecraft.util.text.TextComponentString(text));
|
|
}
|
|
}
|
|
|
|
/* -------- one frame -------- */
|
|
|
|
/**
|
|
* Runs the effects over what the world just drew.
|
|
*
|
|
* Called at the end of the world pass, after everything from the sky to
|
|
* the water and before the hand, so the copies carry the whole world and
|
|
* the hand stays sharp above them. Nothing runs when the pipeline is
|
|
* switched off, and once it has failed it stays off: the effects are
|
|
* worth less than the game they draw over.
|
|
*/
|
|
public static void apply(Minecraft minecraft) {
|
|
if (!master || !working || minecraft.world == null) {
|
|
return;
|
|
}
|
|
int w = minecraft.displayWidth;
|
|
int h = minecraft.displayHeight;
|
|
if (w <= 0 || h <= 0) {
|
|
return;
|
|
}
|
|
load();
|
|
try {
|
|
if (!programsBuilt || w != outputWidth || h != outputHeight) {
|
|
build(w, h);
|
|
}
|
|
if (!working) {
|
|
return;
|
|
}
|
|
copyTheBackBuffer(w, h);
|
|
|
|
boolean blendWas = GL11.glIsEnabled(GL11.GL_BLEND);
|
|
boolean depthWas = GL11.glIsEnabled(GL11.GL_DEPTH_TEST);
|
|
boolean alphaWas = GL11.glIsEnabled(GL11.GL_ALPHA_TEST);
|
|
int unitWas = GL11.glGetInteger(GL13.GL_ACTIVE_TEXTURE);
|
|
java.nio.IntBuffer bindingBuf = BufferUtils.createIntBuffer(1);
|
|
GL11.glGetInteger(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_BINDING_EXT,
|
|
bindingBuf);
|
|
int binding = bindingBuf.get(0);
|
|
|
|
GL11.glDisable(GL11.GL_BLEND);
|
|
GL11.glDisable(GL11.GL_DEPTH_TEST);
|
|
GL11.glDisable(GL11.GL_ALPHA_TEST);
|
|
GL11.glDepthMask(false);
|
|
|
|
if (useSSAO && ssaoProgram.complete()) {
|
|
runSSAO(w, h);
|
|
}
|
|
if (useBloom && thresholdProgram.complete()) {
|
|
runBloom(w, h);
|
|
}
|
|
|
|
GL11.glDepthMask(true);
|
|
if (depthWas) {
|
|
GL11.glEnable(GL11.GL_DEPTH_TEST);
|
|
}
|
|
if (blendWas) {
|
|
GL11.glEnable(GL11.GL_BLEND);
|
|
}
|
|
if (alphaWas) {
|
|
GL11.glEnable(GL11.GL_ALPHA_TEST);
|
|
}
|
|
GL13.glActiveTexture(unitWas);
|
|
GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
|
|
EXTFramebufferObject.glBindFramebufferEXT(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_EXT, binding);
|
|
} catch (Throwable failure) {
|
|
Log.error("post processing stopped", failure);
|
|
working = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The projection of the world, taken at camera setup.
|
|
*
|
|
* Everything the SSAO maths does stands on this: positions are read back
|
|
* out of the depth buffer with its inverse, samples are pushed back into
|
|
* it with the matrix itself.
|
|
*/
|
|
public static void captureProjection() {
|
|
PROJECTION_BUF.rewind();
|
|
GL11.glGetFloat(GL11.GL_PROJECTION_MATRIX, PROJECTION_BUF);
|
|
PROJECTION_BUF.rewind();
|
|
for (int i = 0; i < 16; i++) {
|
|
PROJECTION[i] = PROJECTION_BUF.get();
|
|
}
|
|
// the matrices travel column major; a straight copy is enough
|
|
inverted(PROJECTION, INVERSE);
|
|
}
|
|
|
|
/** One matrix, in the column major order the uniforms expect. */
|
|
private static FloatBuffer columnOf(float[] matrix) {
|
|
COLUMN_BUF.rewind();
|
|
COLUMN_BUF.put(matrix);
|
|
COLUMN_BUF.flip();
|
|
return COLUMN_BUF;
|
|
}
|
|
|
|
/* -------- the scene copies -------- */
|
|
|
|
/**
|
|
* Copies color and depth into textures.
|
|
*
|
|
* The storage is allocated once and refilled with a copy every frame;
|
|
* six repeated reallocations a second are how a machine that cannot
|
|
* afford the effects says so.
|
|
*/
|
|
private static void copyTheBackBuffer(int w, int h) {
|
|
GL11.glBindTexture(GL11.GL_TEXTURE_2D, colorCopyTexture);
|
|
GL11.glCopyTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, 0, 0, w, h);
|
|
|
|
GL11.glBindTexture(GL11.GL_TEXTURE_2D, depthCopyTexture);
|
|
GL11.glCopyTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, 0, 0, w, h);
|
|
}
|
|
|
|
/* -------- SSAO -------- */
|
|
|
|
private static void runSSAO(int w, int h) {
|
|
GL11.glViewport(0, 0, w, h);
|
|
|
|
EXTFramebufferObject.glBindFramebufferEXT(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_EXT, ssaoFramebuffer);
|
|
GL11.glClearColor(1.0F, 1.0F, 1.0F, 1.0F);
|
|
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
|
|
ssaoProgram.use();
|
|
bind(0, depthCopyTexture);
|
|
ssaoProgram.mat4("uProjection", columnOf(PROJECTION));
|
|
ssaoProgram.mat4("uInvProjection", columnOf(INVERSE));
|
|
for (int i = 0; i < 16; i++) {
|
|
ssaoProgram.float3("uSamples[" + i + "]", SAMPLES[i]);
|
|
}
|
|
ssaoProgram.float1("uRadius", ssaoRadius);
|
|
ssaoProgram.float1("uBias", ssaoBias);
|
|
ssaoProgram.float1("uPower", ssaoPower);
|
|
ssaoProgram.float2("uTexel", 1.0F / w, 1.0F / h);
|
|
drawQuad();
|
|
ssaoProgram.close();
|
|
|
|
EXTFramebufferObject.glBindFramebufferEXT(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_EXT, blurFramebuffer);
|
|
ssaoBlurProgram.use();
|
|
bind(0, ssaoTexture);
|
|
bind(1, depthCopyTexture);
|
|
ssaoBlurProgram.float2("uTexelSize", 1.0F / w, 1.0F / h);
|
|
drawQuad();
|
|
ssaoBlurProgram.close();
|
|
|
|
// the AO lands on the whole scene in one pass; the hand comes after
|
|
// and the interface after that, both are drawn on top of the result
|
|
GL11.glViewport(0, 0, outputWidth, outputHeight);
|
|
ssaoCompositeProgram.use();
|
|
bind(0, colorCopyTexture);
|
|
bind(1, blurTexture);
|
|
ssaoCompositeProgram.float1("uStrength", ssaoStrength);
|
|
drawQuad();
|
|
ssaoCompositeProgram.close();
|
|
}
|
|
|
|
/**
|
|
* Sixteen directions spread over a hemisphere, farther out the later
|
|
* they come, the same spread the remake's sampler was seeded with.
|
|
*/
|
|
private static final float[][] SAMPLES = buildSamples();
|
|
|
|
private static float[][] buildSamples() {
|
|
Random random = new Random(42L);
|
|
float[][] spread = new float[16][3];
|
|
for (int i = 0; i < 16; i++) {
|
|
float x = random.nextFloat() * 2.0F - 1.0F;
|
|
float y = random.nextFloat() * 2.0F - 1.0F;
|
|
float z = 0.05F + random.nextFloat() * 0.9F;
|
|
float len = (float) Math.sqrt(x * x + y * y + z * z);
|
|
if (len < 1.0E-5F) {
|
|
len = 1.0E-5F;
|
|
}
|
|
float eased = (float) i / 15.0F;
|
|
eased = eased * eased;
|
|
float scale = (0.1F + 0.9F * eased)
|
|
* (0.1F + random.nextFloat() * 0.8F);
|
|
spread[i][0] = x / len * scale / 2.0F;
|
|
spread[i][1] = y / len * scale / 2.0F;
|
|
spread[i][2] = z / len * scale / 2.0F;
|
|
}
|
|
return spread;
|
|
}
|
|
|
|
/* -------- bloom -------- */
|
|
|
|
private static void runBloom(int w, int h) {
|
|
// down the chain: the threshold picks what shines, then each level
|
|
// carries half of what the one above it held
|
|
for (int level = 0; level < mips; level++) {
|
|
GL11.glViewport(0, 0, mipWidth(level), mipHeight(level));
|
|
EXTFramebufferObject.glBindFramebufferEXT(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
|
|
bloomBuffers[level]);
|
|
GL11.glClearColor(0.0F, 0.0F, 0.0F, 0.0F);
|
|
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
|
|
if (level == 0) {
|
|
thresholdProgram.use();
|
|
bind(0, colorCopyTexture);
|
|
thresholdProgram.float2("uSrcTexelSize", 1.0F / w, 1.0F / h);
|
|
thresholdProgram.float1("uThreshold", bloomThreshold);
|
|
thresholdProgram.float1("uKnee", bloomKnee);
|
|
drawQuad();
|
|
thresholdProgram.close();
|
|
} else {
|
|
downSampleProgram.use();
|
|
bind(0, bloomTextures[level - 1]);
|
|
downSampleProgram.float2("uSrcTexelSize",
|
|
1.0F / mipWidth(level - 1), 1.0F / mipHeight(level - 1));
|
|
drawQuad();
|
|
downSampleProgram.close();
|
|
}
|
|
}
|
|
|
|
// back up the chain: what the level below blurred is added to what
|
|
// this level already holds, so halos keep the shape of their light
|
|
for (int level = mips - 2; level >= 0; level--) {
|
|
GL11.glViewport(0, 0, mipWidth(level), mipHeight(level));
|
|
EXTFramebufferObject.glBindFramebufferEXT(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
|
|
bloomBuffers[level]);
|
|
combineProgram.use();
|
|
bind(0, bloomTextures[level + 1]);
|
|
bind(1, bloomTextures[level]);
|
|
combineProgram.float2("uBlurTexelSize",
|
|
1.0F / mipWidth(level + 1), 1.0F / mipHeight(level + 1));
|
|
drawQuad();
|
|
combineProgram.close();
|
|
}
|
|
|
|
// and the sum lands on the screen one additive pass later
|
|
GL11.glViewport(0, 0, outputWidth, outputHeight);
|
|
GL11.glEnable(GL11.GL_BLEND);
|
|
GL11.glBlendFunc(GL11.GL_ONE, GL11.GL_ONE);
|
|
bloomAddProgram.use();
|
|
bind(0, bloomTextures[0]);
|
|
bloomAddProgram.float1("uIntensity", bloomIntensity);
|
|
drawQuad();
|
|
bloomAddProgram.close();
|
|
GL11.glDisable(GL11.GL_BLEND);
|
|
}
|
|
|
|
private static int mipWidth(int level) {
|
|
return Math.max(4, outputWidth >> (level + 1));
|
|
}
|
|
|
|
private static int mipHeight(int level) {
|
|
return Math.max(4, outputHeight >> (level + 1));
|
|
}
|
|
|
|
/* -------- machinery -------- */
|
|
|
|
private static void bind(int unit, int texture) {
|
|
GL13.glActiveTexture(GL13.GL_TEXTURE0 + unit);
|
|
GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
|
}
|
|
|
|
private static void drawQuad() {
|
|
GL11.glBegin(GL11.GL_QUADS);
|
|
GL11.glVertex2f(-1.0F, -1.0F);
|
|
GL11.glVertex2f(1.0F, -1.0F);
|
|
GL11.glVertex2f(1.0F, 1.0F);
|
|
GL11.glVertex2f(-1.0F, 1.0F);
|
|
GL11.glEnd();
|
|
}
|
|
|
|
/**
|
|
* Builds everything once, and grows everything when the window grows.
|
|
*
|
|
* The programs survive a resize: their programs know nothing of pixels.
|
|
* The textures do not exist until the first frame and are re-proposed at
|
|
* every size, and the framebuffers keep pointing at the same names.
|
|
*/
|
|
private static void build(int w, int h) throws IOException {
|
|
outputWidth = w;
|
|
outputHeight = h;
|
|
|
|
if (!programsBuilt) {
|
|
captureIfFresh();
|
|
programsBuilt = true;
|
|
bloomTextures = new int[BLOOM_MIP_LIMIT];
|
|
bloomBuffers = new int[BLOOM_MIP_LIMIT];
|
|
|
|
colorCopyTexture = GL11.glGenTextures();
|
|
depthCopyTexture = GL11.glGenTextures();
|
|
ssaoTexture = GL11.glGenTextures();
|
|
ssaoFramebuffer = EXTFramebufferObject.glGenFramebuffersEXT();
|
|
blurTexture = GL11.glGenTextures();
|
|
blurFramebuffer = EXTFramebufferObject.glGenFramebuffersEXT();
|
|
for (int level = 0; level < BLOOM_MIP_LIMIT; level++) {
|
|
bloomTextures[level] = GL11.glGenTextures();
|
|
bloomBuffers[level] = EXTFramebufferObject
|
|
.glGenFramebuffersEXT();
|
|
}
|
|
|
|
thresholdProgram = program(COMMON_VERTEX, THRESHOLD_FRAGMENT);
|
|
downSampleProgram = program(COMMON_VERTEX, DOWNSAMPLE_FRAGMENT);
|
|
combineProgram = program(COMMON_VERTEX, COMBINE_FRAGMENT);
|
|
bloomAddProgram = program(COMMON_VERTEX, BLOOM_ADD_FRAGMENT);
|
|
ssaoProgram = program(COMMON_VERTEX, SSAO_FRAGMENT);
|
|
ssaoBlurProgram = program(COMMON_VERTEX, SSAO_BLUR_FRAGMENT);
|
|
ssaoCompositeProgram = program(COMMON_VERTEX,
|
|
SSAO_COMPOSITE_FRAGMENT);
|
|
}
|
|
|
|
mips = 0;
|
|
for (int level = 0; level < BLOOM_MIP_LIMIT; level++) {
|
|
if (mipWidth(level) < 8 || mipHeight(level) < 8) {
|
|
break;
|
|
}
|
|
mips++;
|
|
}
|
|
if (mips < 2) {
|
|
mips = Math.min(2, BLOOM_MIP_LIMIT);
|
|
}
|
|
|
|
sizeTexture(colorCopyTexture, w, h, GL11.GL_RGB8, GL11.GL_LINEAR);
|
|
GL11.glBindTexture(GL11.GL_TEXTURE_2D, depthCopyTexture);
|
|
GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL14.GL_DEPTH_COMPONENT24,
|
|
w, h, 0, GL11.GL_DEPTH_COMPONENT, GL11.GL_UNSIGNED_INT,
|
|
(java.nio.ByteBuffer) null);
|
|
nearest(GL11.GL_CLAMP);
|
|
sizeTexture(ssaoTexture, w, h, GL11.GL_RGB8, GL11.GL_LINEAR);
|
|
sizeTexture(blurTexture, w, h, GL11.GL_RGB8, GL11.GL_LINEAR);
|
|
for (int level = 0; level < mips; level++) {
|
|
sizeTexture(bloomTextures[level], mipWidth(level),
|
|
mipHeight(level), GL11.GL_RGB8, GL11.GL_LINEAR);
|
|
}
|
|
|
|
attach(ssaoFramebuffer, ssaoTexture);
|
|
attach(blurFramebuffer, blurTexture);
|
|
for (int level = 0; level < mips; level++) {
|
|
attach(bloomBuffers[level], bloomTextures[level]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The projection may not be captured yet the first time around; after
|
|
* that the camera has run long before the effects will.
|
|
*/
|
|
private static void captureIfFresh() {
|
|
boolean any = false;
|
|
for (float v : PROJECTION) {
|
|
if (v != 0.0F) {
|
|
any = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!any) {
|
|
identity(PROJECTION);
|
|
identity(INVERSE);
|
|
}
|
|
}
|
|
|
|
private static void sizeTexture(int texture, int w, int h, int format,
|
|
int filter) {
|
|
GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
|
GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, format, w, h, 0,
|
|
GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE,
|
|
(java.nio.ByteBuffer) null);
|
|
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER,
|
|
filter);
|
|
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER,
|
|
filter);
|
|
wrap(GL11.GL_CLAMP);
|
|
}
|
|
|
|
private static void wrap(int mode) {
|
|
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, mode);
|
|
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, mode);
|
|
}
|
|
|
|
private static void nearest(int mode) {
|
|
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER,
|
|
GL11.GL_NEAREST);
|
|
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER,
|
|
GL11.GL_NEAREST);
|
|
wrap(mode);
|
|
}
|
|
|
|
private static final int BLOOM_MIP_LIMIT = 5;
|
|
|
|
/**
|
|
* Connects a texture to a framebuffer of the extension the game itself
|
|
* uses everywhere a framebuffer is mentioned, so compatibility is the
|
|
* same compatibility the world already proved.
|
|
*/
|
|
private static void attach(int framebuffer, int texture) {
|
|
EXTFramebufferObject.glBindFramebufferEXT(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_EXT, framebuffer);
|
|
EXTFramebufferObject.glFramebufferTexture2DEXT(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
|
|
EXTFramebufferObject.GL_COLOR_ATTACHMENT0_EXT,
|
|
GL11.GL_TEXTURE_2D, texture, 0);
|
|
int status = EXTFramebufferObject.glCheckFramebufferStatusEXT(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_EXT);
|
|
if (status != EXTFramebufferObject.GL_FRAMEBUFFER_COMPLETE_EXT) {
|
|
Log.error("post processing framebuffer is incomplete: " + status);
|
|
working = false;
|
|
}
|
|
EXTFramebufferObject.glBindFramebufferEXT(
|
|
EXTFramebufferObject.GL_FRAMEBUFFER_EXT, 0);
|
|
}
|
|
|
|
/** One program: the shaders go in, the uniforms come out by name. */
|
|
private static final class Program {
|
|
int handle = 0;
|
|
|
|
void use() {
|
|
GL20.glUseProgram(handle);
|
|
}
|
|
|
|
void close() {
|
|
GL20.glUseProgram(0);
|
|
}
|
|
|
|
boolean complete() {
|
|
return handle != 0;
|
|
}
|
|
|
|
private int at(String name) {
|
|
if (handle == 0) {
|
|
return -1;
|
|
}
|
|
return GL20.glGetUniformLocation(handle, name);
|
|
}
|
|
|
|
void float1(String name, float value) {
|
|
int position = at(name);
|
|
if (position != -1) {
|
|
GL20.glUniform1f(position, value);
|
|
}
|
|
}
|
|
|
|
void float2(String name, float x, float y) {
|
|
int position = at(name);
|
|
if (position != -1) {
|
|
GL20.glUniform2f(position, x, y);
|
|
}
|
|
}
|
|
|
|
void float3(String name, float[] value) {
|
|
int position = at(name);
|
|
if (position != -1) {
|
|
GL20.glUniform3f(position, value[0], value[1], value[2]);
|
|
}
|
|
}
|
|
|
|
void mat4(String name, FloatBuffer value) {
|
|
int position = at(name);
|
|
if (position != -1) {
|
|
GL20.glUniformMatrix4(position, false, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Program program(String vertex, String fragment) {
|
|
Program made = new Program();
|
|
int vertexShader = GL20.glCreateShader(GL20.GL_VERTEX_SHADER);
|
|
GL20.glShaderSource(vertexShader, vertex);
|
|
GL20.glCompileShader(vertexShader);
|
|
if (!compiled(vertexShader)) {
|
|
GL20.glDeleteShader(vertexShader);
|
|
return made;
|
|
}
|
|
int fragmentShader = GL20.glCreateShader(GL20.GL_FRAGMENT_SHADER);
|
|
GL20.glShaderSource(fragmentShader, fragment);
|
|
GL20.glCompileShader(fragmentShader);
|
|
if (!compiled(fragmentShader)) {
|
|
GL20.glDeleteShader(fragmentShader);
|
|
GL20.glDeleteShader(vertexShader);
|
|
return made;
|
|
}
|
|
int handle = GL20.glCreateProgram();
|
|
GL20.glAttachShader(handle, vertexShader);
|
|
GL20.glAttachShader(handle, fragmentShader);
|
|
GL20.glLinkProgram(handle);
|
|
GL20.glDeleteShader(vertexShader);
|
|
GL20.glDeleteShader(fragmentShader);
|
|
if (GL20.glGetProgrami(handle, GL20.GL_LINK_STATUS) == 0) {
|
|
Log.error("post processing program did not link: "
|
|
+ GL20.glGetProgramInfoLog(handle, 4096));
|
|
GL20.glDeleteProgram(handle);
|
|
return made;
|
|
}
|
|
made.handle = handle;
|
|
return made;
|
|
}
|
|
|
|
private static boolean compiled(int shader) {
|
|
int state = GL20.glGetShaderi(shader, GL20.GL_COMPILE_STATUS);
|
|
if (state == 0) {
|
|
Log.error("post processing shader did not compile: "
|
|
+ GL20.glGetShaderInfoLog(shader, 4096));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/** The projection turned the other way, for positions read from depth. */
|
|
private static void inverted(float[] matrix, float[] into) {
|
|
float a00 = matrix[0], a01 = matrix[1], a02 = matrix[2], a03 = matrix[3];
|
|
float a10 = matrix[4], a11 = matrix[5], a12 = matrix[6], a13 = matrix[7];
|
|
float a20 = matrix[8], a21 = matrix[9], a22 = matrix[10], a23 = matrix[11];
|
|
float a30 = matrix[12], a31 = matrix[13], a32 = matrix[14], a33 = matrix[15];
|
|
|
|
float b00 = a00 * a11 - a01 * a10;
|
|
float b01 = a00 * a12 - a02 * a10;
|
|
float b02 = a00 * a13 - a03 * a10;
|
|
float b03 = a01 * a12 - a02 * a11;
|
|
float b04 = a01 * a13 - a03 * a11;
|
|
float b05 = a02 * a13 - a03 * a12;
|
|
float b06 = a20 * a31 - a21 * a30;
|
|
float b07 = a20 * a32 - a22 * a30;
|
|
float b08 = a20 * a33 - a23 * a30;
|
|
float b09 = a21 * a32 - a22 * a31;
|
|
float b10 = a21 * a33 - a23 * a31;
|
|
float b11 = a22 * a33 - a23 * a32;
|
|
|
|
float determinant = b00 * b11 - b01 * b10 + b02 * b09
|
|
+ b03 * b08 - b04 * b07 + b05 * b06;
|
|
if (Math.abs(determinant) < 1.0E-9F) {
|
|
identity(into);
|
|
return;
|
|
}
|
|
float over = 1.0F / determinant;
|
|
|
|
into[0] = (a11 * b11 - a12 * b10 + a13 * b09) * over;
|
|
into[1] = (-a01 * b11 + a02 * b10 - a03 * b09) * over;
|
|
into[2] = (a31 * b05 - a32 * b04 + a33 * b03) * over;
|
|
into[3] = (-a21 * b05 + a22 * b04 - a23 * b03) * over;
|
|
into[4] = (-a10 * b11 + a12 * b08 - a13 * b07) * over;
|
|
into[5] = (a00 * b11 - a02 * b08 + a03 * b07) * over;
|
|
into[6] = (-a30 * b05 + a32 * b02 - a33 * b01) * over;
|
|
into[7] = (a20 * b05 - a22 * b02 + a23 * b01) * over;
|
|
into[8] = (a10 * b10 - a11 * b08 + a13 * b06) * over;
|
|
into[9] = (-a00 * b10 + a01 * b08 - a03 * b06) * over;
|
|
into[10] = (a30 * b04 - a31 * b02 + a33 * b00) * over;
|
|
into[11] = (-a20 * b04 + a21 * b02 - a23 * b00) * over;
|
|
into[12] = (-a10 * b09 + a11 * b07 - a12 * b06) * over;
|
|
into[13] = (a00 * b09 - a01 * b07 + a02 * b06) * over;
|
|
into[14] = (-a30 * b03 + a31 * b01 - a32 * b00) * over;
|
|
into[15] = (a20 * b03 - a21 * b01 + a22 * b00) * over;
|
|
}
|
|
|
|
private static void identity(float[] into) {
|
|
java.util.Arrays.fill(into, 0.0F);
|
|
into[0] = 1.0F;
|
|
into[5] = 1.0F;
|
|
into[10] = 1.0F;
|
|
into[15] = 1.0F;
|
|
}
|
|
|
|
/* -------- the shaders -------- */
|
|
|
|
private static final String COMMON_VERTEX =
|
|
"#version 120\n"
|
|
+ "varying vec2 vUV;\n"
|
|
+ "void main() {\n"
|
|
+ " vUV = gl_Vertex.xy * 0.5 + 0.5;\n"
|
|
+ " gl_Position = vec4(gl_Vertex.xy, 0.0, 1.0);\n"
|
|
+ "}\n";
|
|
|
|
private static final String THRESHOLD_FRAGMENT =
|
|
"#version 120\n"
|
|
+ "varying vec2 vUV;\n"
|
|
+ "uniform sampler2D uTex;\n"
|
|
+ "uniform vec2 uSrcTexelSize;\n"
|
|
+ "uniform float uThreshold;\n"
|
|
+ "uniform float uKnee;\n"
|
|
+ "vec3 gated(vec3 c) {\n"
|
|
+ " float br = max(c.r, max(c.g, c.b));\n"
|
|
+ " float soft = clamp(br - uThreshold + uKnee, 0.0, 2.0 * uKnee);\n"
|
|
+ " soft = (soft * soft) / (4.0 * uKnee + 0.00001);\n"
|
|
+ " float w = max(soft, br - uThreshold) / max(br, 0.00001);\n"
|
|
+ " return c * max(w, 0.0);\n"
|
|
+ "}\n"
|
|
+ "void main() {\n"
|
|
+ " vec2 ht = uSrcTexelSize * 0.5;\n"
|
|
+ " vec3 a = gated(texture2D(uTex, vUV + vec2(-ht.x, -ht.y)).rgb);\n"
|
|
+ " vec3 b = gated(texture2D(uTex, vUV + vec2( ht.x, -ht.y)).rgb);\n"
|
|
+ " vec3 c = gated(texture2D(uTex, vUV + vec2(-ht.x, ht.y)).rgb);\n"
|
|
+ " vec3 d = gated(texture2D(uTex, vUV + vec2( ht.x, ht.y)).rgb);\n"
|
|
+ " gl_FragColor = vec4((a + b + c + d) * 0.25, 1.0);\n"
|
|
+ "}\n";
|
|
|
|
private static final String DOWNSAMPLE_FRAGMENT =
|
|
"#version 120\n"
|
|
+ "varying vec2 vUV;\n"
|
|
+ "uniform sampler2D uTex;\n"
|
|
+ "uniform vec2 uSrcTexelSize;\n"
|
|
+ "void main() {\n"
|
|
+ " vec2 ht = uSrcTexelSize * 0.5;\n"
|
|
+ " vec3 a = texture2D(uTex, vUV + vec2(-ht.x, -ht.y)).rgb;\n"
|
|
+ " vec3 b = texture2D(uTex, vUV + vec2( ht.x, -ht.y)).rgb;\n"
|
|
+ " vec3 c = texture2D(uTex, vUV + vec2(-ht.x, ht.y)).rgb;\n"
|
|
+ " vec3 d = texture2D(uTex, vUV + vec2( ht.x, ht.y)).rgb;\n"
|
|
+ " gl_FragColor = vec4((a + b + c + d) * 0.25, 1.0);\n"
|
|
+ "}\n";
|
|
|
|
private static final String COMBINE_FRAGMENT =
|
|
"#version 120\n"
|
|
+ "varying vec2 vUV;\n"
|
|
+ "uniform sampler2D uBlurTex;\n"
|
|
+ "uniform sampler2D uPrevTex;\n"
|
|
+ "uniform vec2 uBlurTexelSize;\n"
|
|
+ "void main() {\n"
|
|
+ " vec2 t = uBlurTexelSize;\n"
|
|
+ " vec3 s = vec3(0.0);\n"
|
|
+ " s += texture2D(uBlurTex, vUV + vec2(-t.x, -t.y)).rgb;\n"
|
|
+ " s += texture2D(uBlurTex, vUV + vec2( 0.0, -t.y)).rgb * 2.0;\n"
|
|
+ " s += texture2D(uBlurTex, vUV + vec2( t.x, -t.y)).rgb;\n"
|
|
+ " s += texture2D(uBlurTex, vUV + vec2(-t.x, 0.0)).rgb * 2.0;\n"
|
|
+ " s += texture2D(uBlurTex, vUV ).rgb * 4.0;\n"
|
|
+ " s += texture2D(uBlurTex, vUV + vec2( t.x, 0.0)).rgb * 2.0;\n"
|
|
+ " s += texture2D(uBlurTex, vUV + vec2(-t.x, t.y)).rgb;\n"
|
|
+ " s += texture2D(uBlurTex, vUV + vec2( 0.0, t.y)).rgb * 2.0;\n"
|
|
+ " s += texture2D(uBlurTex, vUV + vec2( t.x, t.y)).rgb;\n"
|
|
+ " s /= 16.0;\n"
|
|
+ " vec3 prev = texture2D(uPrevTex, vUV).rgb;\n"
|
|
+ " gl_FragColor = vec4(prev + s, 1.0);\n"
|
|
+ "}\n";
|
|
|
|
private static final String BLOOM_ADD_FRAGMENT =
|
|
"#version 120\n"
|
|
+ "varying vec2 vUV;\n"
|
|
+ "uniform sampler2D uBloom;\n"
|
|
+ "uniform float uIntensity;\n"
|
|
+ "void main() {\n"
|
|
+ " gl_FragColor = vec4(texture2D(uBloom, vUV).rgb * uIntensity, 0.0);\n"
|
|
+ "}\n";
|
|
|
|
private static final String SSAO_FRAGMENT =
|
|
"#version 120\n"
|
|
+ "varying vec2 vUV;\n"
|
|
+ "uniform sampler2D uDepth;\n"
|
|
+ "uniform mat4 uProjection;\n"
|
|
+ "uniform mat4 uInvProjection;\n"
|
|
+ "uniform vec3 uSamples[16];\n"
|
|
+ "uniform vec2 uTexel;\n"
|
|
+ "uniform float uRadius;\n"
|
|
+ "uniform float uBias;\n"
|
|
+ "uniform float uPower;\n"
|
|
+ "vec3 viewPosFromDepth(float depth, vec2 uv) {\n"
|
|
+ " vec4 clipPos = vec4(uv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);\n"
|
|
+ " vec4 viewPos = uInvProjection * clipPos;\n"
|
|
+ " return viewPos.xyz / viewPos.w;\n"
|
|
+ "}\n"
|
|
+ "vec3 hash3(vec2 seed) {\n"
|
|
+ " vec3 q = vec3(dot(seed, vec2(127.1, 311.7)),\n"
|
|
+ " dot(seed, vec2(269.5, 183.3)),\n"
|
|
+ " dot(seed, vec2(419.2, 371.9)));\n"
|
|
+ " return fract(sin(q) * 43758.5453) * 2.0 - 1.0;\n"
|
|
+ "}\n"
|
|
+ "void main() {\n"
|
|
+ " float centerDepth = texture2D(uDepth, vUV).r;\n"
|
|
+ " if (centerDepth >= 0.9999) { gl_FragColor = vec4(1.0); return; }\n"
|
|
+ " float dX = texture2D(uDepth, vUV + vec2(uTexel.x * 2.0, 0.0)).r;\n"
|
|
+ " float dY = texture2D(uDepth, vUV + vec2(0.0, uTexel.y * 2.0)).r;\n"
|
|
+ " if (dX >= 0.9999 || dY >= 0.9999) {\n"
|
|
+ " gl_FragColor = vec4(1.0); return;\n"
|
|
+ " }\n"
|
|
+ " vec3 center = viewPosFromDepth(centerDepth, vUV);\n"
|
|
+ " vec3 pX = viewPosFromDepth(dX, vUV + vec2(uTexel.x * 2.0, 0.0));\n"
|
|
+ " vec3 pY = viewPosFromDepth(dY, vUV + vec2(0.0, uTexel.y * 2.0));\n"
|
|
+ " vec3 n = normalize(cross(pX - center, pY - center));\n"
|
|
+ " if (dot(n, -center) < 0.0) { n = -n; }\n"
|
|
+ " vec3 randVec = normalize(hash3(gl_FragCoord.xy));\n"
|
|
+ " vec3 tangent = normalize(randVec - n * dot(randVec, n));\n"
|
|
+ " vec3 bitangent = cross(n, tangent);\n"
|
|
+ " mat3 tbn = mat3(tangent, bitangent, n);\n"
|
|
+ " float occlusion = 0.0;\n"
|
|
+ " for (int i = 0; i < 16; i++) {\n"
|
|
+ " vec3 samplePos = center + tbn * uSamples[i] * uRadius;\n"
|
|
+ " vec4 offset = uProjection * vec4(samplePos, 1.0);\n"
|
|
+ " offset.xyz /= offset.w;\n"
|
|
+ " vec2 ndc = offset.xy * 0.5 + 0.5;\n"
|
|
+ " if (offset.z >= 1.0 || ndc.x < 0.0 || ndc.x > 1.0\n"
|
|
+ " || ndc.y < 0.0 || ndc.y > 1.0) { continue; }\n"
|
|
+ " float depth = texture2D(uDepth, ndc).r;\n"
|
|
+ " if (depth >= 0.9999) { continue; }\n"
|
|
+ " vec3 sampleView = viewPosFromDepth(depth, ndc);\n"
|
|
+ " if (sampleView.z >= center.z + uBias) {\n"
|
|
+ " occlusion += smoothstep(0.0, 1.0, uRadius\n"
|
|
+ " / max(length(sampleView - center), 0.0001));\n"
|
|
+ " }\n"
|
|
+ " }\n"
|
|
+ " occlusion /= 16.0;\n"
|
|
+ " float ao = 1.0 - pow(occlusion, uPower);\n"
|
|
+ " gl_FragColor = vec4(ao, ao, ao, 1.0);\n"
|
|
+ "}\n";
|
|
|
|
private static final String SSAO_BLUR_FRAGMENT =
|
|
"#version 120\n"
|
|
+ "varying vec2 vUV;\n"
|
|
+ "uniform sampler2D uSSAO;\n"
|
|
+ "uniform sampler2D uDepth;\n"
|
|
+ "uniform vec2 uTexelSize;\n"
|
|
+ "void main() {\n"
|
|
+ " float centerDepth = texture2D(uDepth, vUV).r;\n"
|
|
+ " if (centerDepth >= 0.9999) { gl_FragColor = vec4(1.0); return; }\n"
|
|
+ " float result = 0.0;\n"
|
|
+ " float weight = 0.0;\n"
|
|
+ " for (int x = -2; x <= 2; x++) {\n"
|
|
+ " for (int y = -2; y <= 2; y++) {\n"
|
|
+ " vec2 sampleUV = vUV + vec2(float(x), float(y)) * uTexelSize;\n"
|
|
+ " float sampleDepth = texture2D(uDepth, sampleUV).r;\n"
|
|
+ " float w = abs(centerDepth - sampleDepth) < 0.0002 ? 1.0 : 0.0;\n"
|
|
+ " result += texture2D(uSSAO, sampleUV).r * w;\n"
|
|
+ " weight += w;\n"
|
|
+ " }\n"
|
|
+ " }\n"
|
|
+ " float val = (weight > 0.0) ? result / weight : 1.0;\n"
|
|
+ " gl_FragColor = vec4(val, val, val, 1.0);\n"
|
|
+ "}\n";
|
|
|
|
private static final String SSAO_COMPOSITE_FRAGMENT =
|
|
"#version 120\n"
|
|
+ "varying vec2 vUV;\n"
|
|
+ "uniform sampler2D uColor;\n"
|
|
+ "uniform sampler2D uSSAO;\n"
|
|
+ "uniform float uStrength;\n"
|
|
+ "void main() {\n"
|
|
+ " vec4 c = texture2D(uColor, vUV);\n"
|
|
+ " float ao = texture2D(uSSAO, vUV).r;\n"
|
|
+ " ao = mix(1.0, ao, clamp(uStrength, 0.0, 1.0));\n"
|
|
+ " gl_FragColor = vec4(c.rgb * ao, 1.0);\n"
|
|
+ "}\n";
|
|
|
|
/* -------- the file -------- */
|
|
|
|
/** Where the numbers sit when the game is closed. */
|
|
private static final String FILE = "rsxpost.properties";
|
|
|
|
private static void load() {
|
|
if (buffered) {
|
|
return;
|
|
}
|
|
buffered = true;
|
|
File file = fileFor();
|
|
if (!file.isFile()) {
|
|
save();
|
|
return;
|
|
}
|
|
Properties held = new Properties();
|
|
FileInputStream open = null;
|
|
try {
|
|
open = new FileInputStream(file);
|
|
held.load(open);
|
|
} catch (IOException couldNotRead) {
|
|
Log.error("rsxpost.properties unreadable", couldNotRead);
|
|
return;
|
|
} finally {
|
|
close(open);
|
|
}
|
|
master = Boolean.parseBoolean(held.getProperty("master", "true"));
|
|
useSSAO = Boolean.parseBoolean(held.getProperty("ssao", "true"));
|
|
useBloom = Boolean.parseBoolean(held.getProperty("bloom", "true"));
|
|
ssaoStrength = floatValue(held, "strength", 1.0F);
|
|
ssaoRadius = floatValue(held, "radius", 0.5F);
|
|
ssaoBias = floatValue(held, "bias", 0.02F);
|
|
ssaoPower = floatValue(held, "power", 2.0F);
|
|
bloomIntensity = floatValue(held, "intensity", 1.5F);
|
|
bloomThreshold = floatValue(held, "threshold", 0.3F);
|
|
bloomKnee = floatValue(held, "knee", 0.0F);
|
|
}
|
|
|
|
private static float floatValue(Properties held, String key, float back) {
|
|
try {
|
|
return Float.parseFloat(held.getProperty(key, String.valueOf(back)));
|
|
} catch (NumberFormatException notANumber) {
|
|
return back;
|
|
}
|
|
}
|
|
|
|
private static void save() {
|
|
Properties held = new Properties();
|
|
held.setProperty("master", String.valueOf(master));
|
|
held.setProperty("ssao", String.valueOf(useSSAO));
|
|
held.setProperty("bloom", String.valueOf(useBloom));
|
|
held.setProperty("strength", String.valueOf(ssaoStrength));
|
|
held.setProperty("radius", String.valueOf(ssaoRadius));
|
|
held.setProperty("bias", String.valueOf(ssaoBias));
|
|
held.setProperty("power", String.valueOf(ssaoPower));
|
|
held.setProperty("intensity", String.valueOf(bloomIntensity));
|
|
held.setProperty("threshold", String.valueOf(bloomThreshold));
|
|
held.setProperty("knee", String.valueOf(bloomKnee));
|
|
FileOutputStream out = null;
|
|
try {
|
|
out = new FileOutputStream(fileFor());
|
|
held.store(out, "the remake's post processing, on the fork");
|
|
} catch (IOException couldNotWrite) {
|
|
Log.error("rsxpost.properties unwritable", couldNotWrite);
|
|
} finally {
|
|
close(out);
|
|
}
|
|
}
|
|
|
|
private static void setMaster(boolean on) {
|
|
master = on;
|
|
save();
|
|
if (on) {
|
|
working = true;
|
|
}
|
|
say("post processing " + (on ? "on" : "off"));
|
|
}
|
|
|
|
private static void close(java.io.Closeable stream) {
|
|
if (stream == null) {
|
|
return;
|
|
}
|
|
try {
|
|
stream.close();
|
|
} catch (IOException closedAnyway) {
|
|
}
|
|
}
|
|
|
|
private static File fileFor() {
|
|
Minecraft minecraft = Minecraft.getMinecraft();
|
|
File base = minecraft == null ? new File(".") : minecraft.gameDir;
|
|
return new File(base, FILE);
|
|
}
|
|
}
|